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

import { getErrorMessage } from "../../../common/utils/error.util";
import { Injectable, Logger, NotFoundException } from "@nestjs/common";
import { Invoice, InvoiceList } 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 { WhmcsGetInvoicesParams } from "../types/whmcs-api.types";

export interface InvoiceFilters {
  status?: string;
  page?: number;
  limit?: number;
}

@Injectable()
export class WhmcsInvoiceService {
  private readonly logger = new Logger(WhmcsInvoiceService.name);

  constructor(
    private readonly connectionService: WhmcsConnectionService,
    private readonly dataTransformer: WhmcsDataTransformer,
    private readonly cacheService: WhmcsCacheService,
  ) {}

  /**
   * Get paginated invoices for a client with caching
   */
  async getInvoices(
    clientId: number,
    userId: string,
    filters: InvoiceFilters = {},
  ): Promise<InvoiceList> {
    const { status, page = 1, limit = 10 } = filters;

    try {
      // Try cache first
      const cached = await this.cacheService.getInvoicesList(
        userId,
        page,
        limit,
        status,
      );
      if (cached) {
        this.logger.debug(
          `Cache hit for invoices: user ${userId}, page ${page}`,
        );
        return cached;
      }

      // Calculate pagination for WHMCS API
      const limitstart = (page - 1) * limit;

      // Fetch from WHMCS API
      const params: WhmcsGetInvoicesParams = {
        userid: clientId, // WHMCS API uses 'userid' parameter, not 'clientid'
        limitstart,
        limitnum: limit,
        orderby: "date",
        order: "DESC",
        ...(status && { status: status as any }),
      };

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

      if (!response.invoices?.invoice) {
        this.logger.warn(`No invoices found for client ${clientId}`);
        return {
          invoices: [],
          pagination: {
            page,
            totalPages: 0,
            totalItems: 0,
          },
        };
      }

      // Transform invoices (note: items are not included by GetInvoices API)
      const invoices = response.invoices.invoice
        .map((whmcsInvoice) => {
          try {
            return this.dataTransformer.transformInvoice(whmcsInvoice);
          } catch (error) {
            this.logger.error(
              `Failed to transform invoice ${whmcsInvoice.id}`,
              error,
            );
            return null;
          }
        })
        .filter((invoice): invoice is Invoice => invoice !== null);

      // Build result with pagination
      this.logger.debug(
        `WHMCS GetInvoices Response Analysis for Client ${clientId}:`,
        {
          totalresults: response.totalresults,
          numreturned: response.numreturned,
          startnumber: response.startnumber,
          actualInvoicesReturned: invoices.length,
          requestParams: {
            userid: clientId,
            limitstart,
            limitnum: limit,
            orderby: "date",
            order: "DESC",
          },
        },
      );

      const totalItems = response.totalresults || 0;
      const totalPages = Math.ceil(totalItems / limit);

      const result: InvoiceList = {
        invoices,
        pagination: {
          page,
          totalPages,
          totalItems,
          nextCursor: page < totalPages ? (page + 1).toString() : undefined,
        },
      };

      // Cache the result
      await this.cacheService.setInvoicesList(
        userId,
        page,
        limit,
        status,
        result,
      );

      this.logger.log(
        `Fetched ${invoices.length} invoices for client ${clientId}, page ${page}`,
      );
      return result;
    } catch (error) {
      this.logger.error(`Failed to fetch invoices for client ${clientId}`, {
        error: getErrorMessage(error),
        filters,
      });
      throw error;
    }
  }

  /**
   * Get invoices with items (for subscription linking)
   * This method fetches invoices and then enriches them with item details
   */
  async getInvoicesWithItems(
    clientId: number,
    userId: string,
    filters: InvoiceFilters = {},
  ): Promise<InvoiceList> {
    try {
      // First get the basic invoices list
      const invoiceList = await this.getInvoices(clientId, userId, filters);

      // For each invoice, fetch the detailed version with items
      const invoicesWithItems = await Promise.all(
        invoiceList.invoices.map(async (invoice) => {
          try {
            // Get detailed invoice with items
            const detailedInvoice = await this.getInvoiceById(
              clientId,
              userId,
              invoice.id,
            );
            return detailedInvoice;
          } catch (error) {
            this.logger.warn(
              `Failed to fetch details for invoice ${invoice.id}`,
              getErrorMessage(error),
            );
            // Return the basic invoice if detailed fetch fails
            return invoice;
          }
        }),
      );

      const result: InvoiceList = {
        invoices: invoicesWithItems,
        pagination: invoiceList.pagination,
      };

      this.logger.log(
        `Fetched ${invoicesWithItems.length} invoices with items for client ${clientId}`,
      );
      return result;
    } catch (error) {
      this.logger.error(
        `Failed to fetch invoices with items for client ${clientId}`,
        {
          error: getErrorMessage(error),
          filters,
        },
      );
      throw error;
    }
  }

  /**
   * Get individual invoice by ID with caching
   */
  async getInvoiceById(
    clientId: number,
    userId: string,
    invoiceId: number,
  ): Promise<Invoice> {
    try {
      // Try cache first
      const cached = await this.cacheService.getInvoice(userId, invoiceId);
      if (cached) {
        this.logger.debug(
          `Cache hit for invoice: user ${userId}, invoice ${invoiceId}`,
        );
        return cached;
      }

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

      if (!response.invoiceid) {
        throw new NotFoundException(`Invoice ${invoiceId} not found`);
      }

      // Verify the invoice belongs to this client
      const invoiceClientId = response.userid;
      if (invoiceClientId !== clientId) {
        throw new NotFoundException(`Invoice ${invoiceId} not found`);
      }

      // Transform invoice
      const invoice = this.dataTransformer.transformInvoice(response);

      // Validate transformation
      if (!this.dataTransformer.validateInvoice(invoice)) {
        throw new Error(`Invalid invoice data after transformation`);
      }

      // Cache the result
      await this.cacheService.setInvoice(userId, invoiceId, invoice);

      this.logger.log(`Fetched invoice ${invoiceId} for client ${clientId}`);
      return invoice;
    } catch (error) {
      this.logger.error(
        `Failed to fetch invoice ${invoiceId} for client ${clientId}`,
        {
          error: getErrorMessage(error),
        },
      );
      throw error;
    }
  }

  /**
   * Invalidate cache for a specific invoice
   */
  async invalidateInvoiceCache(
    userId: string,
    invoiceId: number,
  ): Promise<void> {
    await this.cacheService.invalidateInvoice(userId, invoiceId);
    this.logger.log(
      `Invalidated invoice cache for user ${userId}, invoice ${invoiceId}`,
    );
  }
}