/**
 * Service pour la gestion des clients - COOP-CA AMIFOND
 *
 * Service pour interagir avec l'API des clients
 */

import { apiClient } from "@/lib/api-client";
import type {
  Client,
  ClientListResponse,
  ClientListParams,
  ClientCreateRequest,
  ClientUpdateRequest,
  ClientDocument,
  ClientContact,
  ClientReferral,
  ClientActivity,
  MembershipHistory,
  MemberConversionRequest,
  ClientStats,
  ClientEvolutionData,
  ClientDashboardChartData,
} from "@/types/clients";

export class ClientService {
  /**
   * Récupérer la liste des clients avec pagination et filtres
   */
  static async getClients(params: ClientListParams = {}): Promise<ClientListResponse> {
    const searchParams = new URLSearchParams();

    if (params.page) searchParams.append("page", params.page.toString());
    if (params.page_size) searchParams.append("page_size", params.page_size.toString());
    if (params.search) searchParams.append("search", params.search);
    if (params.is_member !== undefined) searchParams.append("is_member", params.is_member.toString());
    if (params.status) searchParams.append("status", params.status);
    if (params.ordering) searchParams.append("ordering", params.ordering);

    const queryString = searchParams.toString();
    const baseUrl = "/api/v1/clients/";
    const url = queryString ? `${baseUrl}?${queryString}` : baseUrl;

    return apiClient.get<ClientListResponse>(url);
  }

  /**
   * Récupérer un client par son ID
   */
  static async getClient(id: number): Promise<Client> {
    return apiClient.get<Client>(`/api/v1/clients/${id}/`);
  }

  /**
   * Créer un nouveau client
   */
  static async createClient(data: ClientCreateRequest): Promise<Client> {
    return apiClient.post<Client>("/api/v1/clients/", data);
  }

  /**
   * Mettre à jour un client
   */
  static async updateClient(id: number, data: ClientUpdateRequest): Promise<Client> {
    return apiClient.patch<Client>(`/api/v1/clients/${id}/`, data);
  }

  /**
   * Supprimer un client
   */
  static async deleteClient(id: number): Promise<void> {
    return apiClient.delete(`/api/v1/clients/${id}/`);
  }

  /**
   * Convertir un client en membre
   */
  static async convertToMember(id: number, data: MemberConversionRequest): Promise<Client> {
    return apiClient.post<Client>(`/api/v1/clients/${id}/convert-to-member/`, data);
  }

  /**
   * Récupérer le score d'un client
   */
  static async getClientScore(id: number): Promise<{ score: number; factors: Record<string, unknown> }> {
    return apiClient.get(`/api/v1/clients/${id}/get-score/`);
  }

  /**
   * Effectuer des actions en lot sur plusieurs clients
   */
  static async bulkAction(
    action: string,
    client_ids: number[],
    data?: Record<string, unknown>,
  ): Promise<Record<string, unknown>> {
    return apiClient.post("/api/v1/clients/bulk-action/", {
      action,
      client_ids,
      ...data,
    });
  }

  /**
   * Récupérer les statistiques des clients
   */
  static async getClientStats(): Promise<ClientStats> {
    return apiClient.get<ClientStats>("/api/v1/clients/stats/");
  }

  /**
   * Récupérer les données d'évolution des clients sur plusieurs mois
   */
  static async getClientEvolution(months: number = 6): Promise<ClientEvolutionData[]> {
    return apiClient.get(`/api/v1/clients/evolution/?months=${months}`);
  }

  /**
   * Récupérer les données pour les graphiques du dashboard
   */
  static async getDashboardChartData(): Promise<ClientDashboardChartData> {
    return apiClient.get("/api/v1/clients/dashboard-charts/");
  }

  /**
   * Enregistrer une activité client
   */
  static async logActivity(clientId: number, activityType: string, description: string): Promise<ClientActivity> {
    return apiClient.post<ClientActivity>(`/api/v1/clients/${clientId}/log-activity/`, {
      activity_type: activityType,
      description,
    });
  }

  /**
   * Récupérer la completion du profil d'un client
   */
  static async getProfileCompletion(id: number): Promise<{ completion_percentage: number; missing_fields: string[] }> {
    return apiClient.get(`/api/v1/clients/${id}/profile-completion/`);
  }
}

export class ClientDocumentService {
  /**
   * Récupérer les documents d'un client
   */
  static async getClientDocuments(clientId?: number): Promise<ClientDocument[]> {
    const url = clientId ? `/api/v1/clients/documents/?client=${clientId}` : "/api/v1/clients/documents/";
    return apiClient.get<ClientDocument[]>(url);
  }

  /**
   * Télécharger un document
   */
  static async uploadDocument(clientId: number, file: File, documentType: string): Promise<ClientDocument> {
    const formData = new FormData();
    formData.append("file", file);
    formData.append("client", clientId.toString());
    formData.append("document_type", documentType);

    return apiClient.post<ClientDocument>("/api/v1/clients/documents/", formData, {
      headers: {
        "Content-Type": "multipart/form-data",
      },
    });
  }

  /**
   * Vérifier un document
   */
  static async verifyDocument(id: number, notes?: string): Promise<ClientDocument> {
    return apiClient.post<ClientDocument>(`/api/v1/clients/documents/${id}/verify/`, { notes });
  }

  /**
   * Supprimer un document
   */
  static async deleteDocument(id: number): Promise<void> {
    return apiClient.delete(`/api/v1/clients/documents/${id}/`);
  }
}

export class ClientContactService {
  /**
   * Récupérer les contacts d'un client
   */
  static async getClientContacts(clientId?: number): Promise<ClientContact[]> {
    const url = clientId ? `/api/v1/clients/contacts/?client=${clientId}` : "/api/v1/clients/contacts/";
    return apiClient.get<ClientContact[]>(url);
  }

  /**
   * Créer un nouveau contact
   */
  static async createContact(data: Partial<ClientContact>): Promise<ClientContact> {
    return apiClient.post<ClientContact>("/api/v1/clients/contacts/", data);
  }

  /**
   * Mettre à jour un contact
   */
  static async updateContact(id: number, data: Partial<ClientContact>): Promise<ClientContact> {
    return apiClient.patch<ClientContact>(`/api/v1/clients/contacts/${id}/`, data);
  }

  /**
   * Supprimer un contact
   */
  static async deleteContact(id: number): Promise<void> {
    return apiClient.delete(`/api/v1/clients/contacts/${id}/`);
  }
}

export class ClientReferralService {
  /**
   * Récupérer les parrainages
   */
  static async getReferrals(params: Record<string, string | number> = {}): Promise<ClientReferral[]> {
    const searchParams = new URLSearchParams();
    Object.entries(params).forEach(([key, value]) => {
      searchParams.append(key, value.toString());
    });
    const url = `/api/v1/clients/referrals/?${searchParams.toString()}`;
    return apiClient.get<ClientReferral[]>(url);
  }

  /**
   * Créer un nouveau parrainage
   */
  static async createReferral(data: Partial<ClientReferral>): Promise<ClientReferral> {
    return apiClient.post<ClientReferral>("/api/v1/clients/referrals/", data);
  }
}

export class ClientActivityService {
  /**
   * Récupérer les activités d'un client
   */
  static async getClientActivities(clientId?: number): Promise<ClientActivity[]> {
    const url = clientId ? `/api/v1/clients/activities/?client=${clientId}` : "/api/v1/clients/activities/";
    return apiClient.get<ClientActivity[]>(url);
  }

  /**
   * Créer une nouvelle activité
   */
  static async createActivity(data: Partial<ClientActivity>): Promise<ClientActivity> {
    return apiClient.post<ClientActivity>("/api/v1/clients/activities/", data);
  }
}