Assist_Design/apps/bff/src/vendors/whmcs/services/whmcs-payment.service.ts

import { getErrorMessage } from "../../../common/utils/error.util";
import { Logger } from "nestjs-pino";
import { Injectable, Inject } from "@nestjs/common";
import { PaymentMethodList, PaymentGateway, PaymentGatewayList } from "@customer-portal/shared";
import { WhmcsConnectionService } from "./whmcs-connection.service";
import { WhmcsDataTransformer } from "../transformers/whmcs-data.transformer";
import { WhmcsCacheService } from "../cache/whmcs-cache.service";
import { WhmcsCreateSsoTokenParams } from "../types/whmcs-api.types";

@Injectable()
export class WhmcsPaymentService {
  constructor(
    @Inject(Logger) private readonly logger: Logger,
    private readonly connectionService: WhmcsConnectionService,
    private readonly dataTransformer: WhmcsDataTransformer,
    private readonly cacheService: WhmcsCacheService
  ) {}

  /**
   * Get payment methods for a client
   */
  async getPaymentMethods(clientId: number, userId: string): Promise<PaymentMethodList> {
    try {
      // Try cache first
      const cached = await this.cacheService.getPaymentMethods(userId);
      if (cached) {
        this.logger.debug(`Cache hit for payment methods: user ${userId}`);
        return cached;
      }

      const response = await this.connectionService.getPayMethods({ clientid: clientId });
      const methods = (response.paymethods?.paymethod || []).map(pm =>
        this.dataTransformer.transformPaymentMethod(pm)
      );
      const result: PaymentMethodList = { paymentMethods: methods, totalCount: methods.length };
      await this.cacheService.setPaymentMethods(userId, result);
      return result;
    } catch (error) {
      this.logger.error(`Failed to fetch payment methods for client ${clientId}`, {
        error: getErrorMessage(error),
        userId,
      });
      throw error;
    }
  }

  /**
   * Get available payment gateways
   */
  async getPaymentGateways(): Promise<PaymentGatewayList> {
    try {
      // Try cache first
      const cached = await this.cacheService.getPaymentGateways();
      if (cached) {
        this.logger.debug("Cache hit for payment gateways");
        return cached;
      }

      // Fetch from WHMCS API
      const response = await this.connectionService.getPaymentGateways();

      if (!response.gateways?.gateway) {
        this.logger.warn("No payment gateways found");
        return {
          gateways: [],
          totalCount: 0,
        };
      }

      // Transform payment gateways
      const gateways = response.gateways.gateway
        .map(whmcsGateway => {
          try {
            return this.dataTransformer.transformPaymentGateway(whmcsGateway);
          } catch (error) {
            this.logger.error(`Failed to transform payment gateway ${whmcsGateway.name}`, {
              error: getErrorMessage(error),
            });
            return null;
          }
        })
        .filter((gateway): gateway is PaymentGateway => gateway !== null);

      const result: PaymentGatewayList = {
        gateways,
        totalCount: gateways.length,
      };

      // Cache the result (cache for 1 hour since gateways don't change often)
      await this.cacheService.setPaymentGateways(result);

      this.logger.log(`Fetched ${gateways.length} payment gateways`);
      return result;
    } catch (error) {
      this.logger.error("Failed to fetch payment gateways", {
        error: getErrorMessage(error),
      });
      throw error;
    }
  }

  /**
   * Create SSO token with payment method for invoice payment
   * This creates a direct link to the payment form with gateway pre-selected
   */
  async createPaymentSsoToken(
    clientId: number,
    invoiceId: number,
    paymentMethodId?: number,
    gatewayName?: string
  ): Promise<{ url: string; expiresAt: string }> {
    try {
      // Use WHMCS Friendly URL format for direct payment page access
      // This goes directly to the payment page, not just invoice view
      let invoiceUrl = `index.php?rp=/invoice/${invoiceId}/pay`;

      if (paymentMethodId) {
        // Pre-select specific saved payment method
        invoiceUrl += `&paymentmethod=${paymentMethodId}`;
      } else if (gatewayName) {
        // Pre-select specific gateway
        invoiceUrl += `&gateway=${gatewayName}`;
      }

      const params: WhmcsCreateSsoTokenParams = {
        client_id: clientId,
        destination: "sso:custom_redirect",
        sso_redirect_path: invoiceUrl,
      };

      const response = await this.connectionService.createSsoToken(params);

      const result = {
        url: response.redirect_url,
        expiresAt: new Date(Date.now() + 3600000).toISOString(), // 1 hour
      };

      this.logger.log(`Created payment SSO token for client ${clientId}, invoice ${invoiceId}`, {
        paymentMethodId,
        gatewayName,
        invoiceUrl,
      });
      return result;
    } catch (error) {
      this.logger.error(`Failed to create payment SSO token for client ${clientId}`, {
        error: getErrorMessage(error),
        invoiceId,
        paymentMethodId,
        gatewayName,
      });
      throw error;
    }
  }

  /**
   * Get products catalog
   */
  async getProducts(): Promise<any> {
    try {
      const response = await this.connectionService.getProducts();
      return response;
    } catch (error) {
      this.logger.error("Failed to get products", {
        error: getErrorMessage(error),
      });
      throw error;
    }
  }

  /**
   * Transform product data (delegate to transformer)
   */
  transformProduct(whmcsProduct: any): any {
    return this.dataTransformer.transformProduct(whmcsProduct);
  }
}