import { AxiosError } from "axios";
import { apiClient } from "../../app/api/client";
import { handleAPIError } from "../utils/apiErrorHandler";
import { getLanguageCode } from "../utils/getLanguageCode";
import {
  Program,
  ProgramsResponse,
  ProcessedProgram,
} from "@/src/lib/types/programs";

export class ProgramsService {
  private readonly endpoint = "programs";

  /**
   * Parse age range string like "4-7" into min and max ages
   */
  private parseAgeRange(ageRange: string): { minAge: number; maxAge: number } {
    const parts = ageRange.split("-").map((s) => parseInt(s.trim(), 10));
    return {
      minAge: parts[0] || 0,
      maxAge: parts[1] || parts[0] || 0,
    };
  }

  async fetchByDomain(domain: string, franchiseeId?: string | null, language?: string | null): Promise<ProcessedProgram[]> {
    const startTime = Date.now();

    try {
      // Use getLanguageCode to handle explicitly requested languages, "default" filtering, 
      // and automatic domain-based extraction if omitted.
      const languageCode = getLanguageCode(language || undefined, domain);

      const params: Record<string, string> = {};
      if (franchiseeId) {
        params.franchiseeId = franchiseeId;
      }
      if (languageCode) {
        params.language = languageCode;
      }

      const response = await apiClient.get<ProgramsResponse>(this.endpoint, {
        headers: { "X-Domain": domain },
        params: Object.keys(params).length > 0 ? params : undefined,
      });

      if (!response.data?.status || !Array.isArray(response.data?.data)) {
        return [];
      }

      // Process programs to include parsed age ranges
      const processedPrograms: ProcessedProgram[] = response.data.data
        .filter((program) => program.is_enabled)
        .sort((a, b) => a.order_no - b.order_no)
        .map((program) => {
          const { minAge, maxAge } = this.parseAgeRange(program.age_range);
          return {
            ...program,
            minAge,
            maxAge,
          };
        });

      const elapsed = Date.now() - startTime;
      return processedPrograms;
    } catch (error) {
      // Delegate error handling to reusable utility
      return handleAPIError(
        error,
        domain,
        startTime,
        () => []
      );
    }
  }
}

export const programsService = new ProgramsService();