/**
 * Service pour la gestion des utilisateurs - COOP-CA AMIFOND
 *
 * Gestion CRUD des utilisateurs avec intégration API backend
 */

import { apiClient } from "@/lib/api-client";
import { apiEndpoints } from "@/lib/api-config";
import { User } from "@/types/auth";
import {
  UserListParams,
  UserListResponse,
  CreateUserRequest,
  UpdateUserRequest,
  UserDetail,
  UserStats,
  UserAction,
} from "@/types/users";

export class UsersService {
  /**
   * Récupérer la liste des utilisateurs avec pagination et filtres
   */
  static async getUsers(params: UserListParams = {}): Promise<UserListResponse> {
    const queryParams = new URLSearchParams();

    Object.entries(params).forEach(([key, value]) => {
      if (value !== undefined && value !== null && value !== "") {
        queryParams.append(key, String(value));
      }
    });

    const url = `${apiEndpoints.users.list}?${queryParams.toString()}`;
    const response = await apiClient.get<User[] | UserListResponse>(url);

    // Vérifier si la réponse est un tableau (ancienne API) ou un objet paginé (nouvelle API)
    if (Array.isArray(response)) {
      // Transformer le tableau en objet UserListResponse
      return {
        count: response.length,
        next: null,
        previous: null,
        results: response,
      };
    }

    // Si c'est déjà un objet paginé, le retourner directement
    return response as UserListResponse;
  }

  /**
   * Récupérer les détails d'un utilisateur
   */
  static async getUserById(id: number): Promise<UserDetail> {
    return apiClient.get<UserDetail>(apiEndpoints.users.detail(id));
  }

  /**
   * Créer un nouvel utilisateur
   */
  static async createUser(userData: CreateUserRequest): Promise<User> {
    return apiClient.post<User>(apiEndpoints.users.create, userData);
  }

  /**
   * Mettre à jour un utilisateur
   */
  static async updateUser(id: number, userData: UpdateUserRequest): Promise<User> {
    return apiClient.patch<User>(apiEndpoints.users.update(id), userData);
  }

  /**
   * Supprimer un utilisateur
   */
  static async deleteUser(id: number): Promise<void> {
    return apiClient.delete(apiEndpoints.users.delete(id));
  }

  /**
   * Activer un utilisateur
   */
  static async activateUser(id: number): Promise<{ detail: string }> {
    return apiClient.post<{ detail: string }>(`${apiEndpoints.users.detail(id)}activate/`);
  }

  /**
   * Désactiver un utilisateur
   */
  static async deactivateUser(id: number): Promise<{ detail: string }> {
    return apiClient.post<{ detail: string }>(`${apiEndpoints.users.detail(id)}deactivate/`);
  }

  /**
   * Changer le mot de passe d'un utilisateur
   */
  static async changeUserPassword(id: number, data: { new_password: string }): Promise<{ detail: string }> {
    return apiClient.post<{ detail: string }>(`${apiEndpoints.users.detail(id)}change-password/`, data);
  }

  /**
   * Récupérer les statistiques des utilisateurs
   */
  static async getUserStats(): Promise<UserStats> {
    return apiClient.get<UserStats>(apiEndpoints.users.stats);
  }

  /**
   * Actions en lot sur les utilisateurs
   */
  static async bulkUserAction(
    action: UserAction,
  ): Promise<{ detail: string; results: Array<{ id: number; success: boolean; message?: string }> }> {
    return apiClient.post<{ detail: string; results: Array<{ id: number; success: boolean; message?: string }> }>(
      apiEndpoints.users.bulkActions,
      action,
    );
  }

  /**
   * Récupérer le profil d'un utilisateur
   */
  static async getUserProfile(userId: number): Promise<UserDetail> {
    return apiClient.get(`${apiEndpoints.users.detail(userId)}profile/`);
  }

  /**
   * Envoyer un email de vérification à un utilisateur
   */
  static async sendVerificationEmail(id: number): Promise<{ detail: string }> {
    return apiClient.post<{ detail: string }>(`${apiEndpoints.users.detail(id)}send-verification/`);
  }

  /**
   * Rechercher des utilisateurs
   */
  static async searchUsers(query: string, filters?: Partial<UserListParams>): Promise<UserListResponse> {
    const params: UserListParams = {
      search: query,
      page_size: 20,
      ...filters,
    };
    return this.getUsers(params);
  }

  /**
   * Exporter la liste des utilisateurs
   */
  static async exportUsers(format: "csv" | "xlsx" = "csv", filters?: UserListParams): Promise<Blob> {
    const queryParams = new URLSearchParams();

    if (filters) {
      Object.entries(filters).forEach(([key, value]) => {
        if (value !== undefined && value !== null && value !== "") {
          queryParams.append(key, String(value));
        }
      });
    }

    queryParams.append("export", format);

    const url = `${apiEndpoints.users.list}?${queryParams.toString()}`;

    const response = await fetch(url, {
      credentials: 'include',
    });

    if (!response.ok) {
      throw new Error("Erreur lors de l'export");
    }

    return response.blob();
  }
}