import { apiClient } from "../../app/api/client";
import { handleAPIError } from "../utils/apiErrorHandler";

export interface TermsOfUseSection {
  heading?: string;
  effectiveDate?: string;
  content?: string;
}

export interface TermsOfUseContent {
  termsOfUse?: TermsOfUseSection;
  // Some franchisees may store content under a generic key — accept both.
  privacyPolicy?: TermsOfUseSection;
}

export interface TermsOfUsePageData {
  id: string;
  franchisee_id: string | null;
  is_global: boolean;
  title: string;
  slug: string;
  template_id: string;
  content: TermsOfUseContent;
  translated_content?: TermsOfUseContent;
  status: string;
  seo_title?: string | null;
  seo_description?: string | null;
  version?: number;
  effective_language?: string;
}

export interface TermsOfUseDataWithTranslations {
  default: TermsOfUseContent;
  translated?: TermsOfUseContent;
  version: number;
  language_code: string;
}

const DEFAULTS: TermsOfUseSection = {
  heading: "Terms of Use",
  effectiveDate: "",
  content: "Terms of Use content is not available at this time. Please contact us for more information.",
};

export class TermsOfUseService {
  private readonly endpoint = "pages/terms-of-use";

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

    try {
      const params: Record<string, string> = {};
      if (franchiseeId) params.franchiseeId = franchiseeId;
      if (language && language !== "default") params.lang = language;

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

      if (!response.data?.status || !response.data?.data?.content) {
        return this.getDefaultData();
      }

      const elapsed = Date.now() - startTime;

      return {
        default: response.data.data.content,
        translated: response.data.data.translated_content || undefined,
        version: response.data.data.version ?? 1,
        language_code: response.data.data.effective_language ?? 'en',
      };
    } catch (error) {
      return handleAPIError(error, domain, startTime, this.getDefaultData.bind(this));
    }
  }

  private async getDefaultData(): Promise<TermsOfUseDataWithTranslations> {
    return {
      default: { termsOfUse: DEFAULTS },
      translated: undefined,
      version: 1,
      language_code: 'en',
    };
  }
}

export const termsOfUseService = new TermsOfUseService();