/**
 * Services API pour BTP Xpress
 */

import axios, { AxiosInstance, AxiosResponse } from 'axios';
import { API_CONFIG } from '../config/api';
import keycloak from '../lib/keycloak';
import { CacheService, CacheKeys } from './cacheService';
import {
  Client,
  Chantier,
  Devis,
  Facture,
  DashboardStats,
  ChantierRecent,
  FactureEnRetard,
  DevisEnAttente,
  FilterOptions,
  SearchResult,
  Employe,
  Equipe,
  Materiel,
  MaintenanceMateriel,
  PlanningEvent,
  PlanningCalendrierView,
  PlanningConflict,
  PlanningStats
} from '../types/btp';
import { UserInfo } from '../types/auth';

class ApiService {
  private api: AxiosInstance;
  private serverStatusListeners: ((isOnline: boolean) => void)[] = [];

  constructor() {
    this.api = axios.create({
      baseURL: API_CONFIG.baseURL,
      timeout: API_CONFIG.timeout,
      headers: API_CONFIG.headers,
    });

    // Interceptor pour les requêtes
    this.api.interceptors.request.use(
      async (config) => {
        console.log('🔐 API Request:', config.url);

        // Vérifier si Keycloak est initialisé et l'utilisateur authentifié
        if (keycloak && keycloak.authenticated && keycloak.token) {
          try {
            // Rafraîchir le token si nécessaire (70 secondes avant expiration)
            await keycloak.updateToken(70);

            // Ajouter le token Bearer à l'en-tête Authorization
            config.headers['Authorization'] = `Bearer ${keycloak.token}`;
            console.log('✅ Token ajouté à la requête');
          } catch (error) {
            console.error('❌ Erreur lors de la mise à jour du token Keycloak:', error);
            // En cas d'erreur, rediriger vers la page de connexion
            keycloak.login();
            throw error;
          }
        } else {
          console.warn('⚠️ Keycloak non authentifié, requête sans token');
        }

        // Ajouter des en-têtes par défaut
        config.headers['X-Requested-With'] = 'XMLHttpRequest';

        return config;
      },
      (error) => {
        return Promise.reject(error);
      }
    );

    // Interceptor pour les réponses
    this.api.interceptors.response.use(
      (response: AxiosResponse) => response,
      async (error) => {
        // Ne pas logger les 404 sur les endpoints de chantiers par client (pas encore implémentés)
        const is404OnChantiersByClient = error.response?.status === 404 && 
                                         error.config?.url?.includes('/chantiers/client/');
        
        if (!is404OnChantiersByClient) {
          // Utiliser console.warn au lieu de console.error pour éviter les erreurs React DevTools
          console.warn('API Error:', error.response?.status, error.response?.data || error.message);
        }
        
        // Gérer les erreurs de connexion réseau
        if (!error.response) {
          // Erreur réseau (serveur indisponible, pas de connexion, etc.)
          if (error.code === 'ECONNABORTED') {
            error.userMessage = 'Délai d\'attente dépassé. Le serveur backend met trop de temps à répondre.';
            error.statusCode = 'TIMEOUT';
          } else if (error.code === 'ERR_NETWORK') {
            error.userMessage = 'Impossible de joindre le serveur backend. Vérifiez votre connexion internet et que le serveur backend est démarré (mvn quarkus:dev).';
            error.statusCode = 'NETWORK_ERROR';
          } else {
            error.userMessage = 'Serveur backend indisponible. Vérifiez que le serveur backend est démarré (mvn quarkus:dev) et accessible sur le port 8080.';
            error.statusCode = 'SERVER_UNAVAILABLE';
          }
          
          // Émettre un événement global pour notifier l'application
          this.notifyServerStatus(false);
          return Promise.reject(error);
        }
        
        // Serveur répond, donc il est disponible
        this.notifyServerStatus(true);
        
        if (error.response?.status === 401) {
          // Gestion des erreurs d'authentification (token expiré ou absent)
          if (typeof window !== 'undefined') {
            const currentUrl = window.location.href;
            const hasAuthCode = currentUrl.includes('code=') && currentUrl.includes('/dashboard');

            if (!hasAuthCode) {
              console.log('🔄 Token expiré ou absent, redirection vers Keycloak...');

              // Essayer de rafraîchir le token Keycloak
              if (keycloak && keycloak.authenticated) {
                try {
                  await keycloak.updateToken(-1); // Force refresh
                  // Retry the original request
                  return this.api.request(error.config);
                } catch (refreshError) {
                  console.error('❌ Impossible de rafraîchir le token, reconnexion requise');
                  // Sauvegarder la page actuelle pour y revenir après reconnexion
                  const currentPath = window.location.pathname + window.location.search;
                  sessionStorage.setItem('returnUrl', currentPath);
                  // Rediriger vers Keycloak pour authentification
                  keycloak.login();
                }
              } else {
                // Pas authentifié, rediriger vers Keycloak
                console.log('❌ Non authentifié, redirection vers Keycloak...');
                if (keycloak) {
                  keycloak.login();
                }
              }
            } else {
              console.log('🔄 API Service: Erreur 401 ignorée car authentification en cours...');
            }
          }
        }
        
        // Créer une erreur plus propre pour l'affichage
        const errorMessage = error.response?.data?.message || 
                           error.response?.data?.error || 
                           error.message || 
                           'Une erreur est survenue';
        
        const enhancedError = {
          ...error,
          userMessage: errorMessage,
          statusCode: error.response?.status
        };
        
        return Promise.reject(enhancedError);
      }
    );
  }

  // === GESTION STATUT SERVEUR ===
  private notifyServerStatus(isOnline: boolean) {
    this.serverStatusListeners.forEach(listener => {
      try {
        listener(isOnline);
      } catch (error) {
        console.error('Erreur dans listener de statut serveur:', error);
      }
    });
  }

  public onServerStatusChange(callback: (isOnline: boolean) => void) {
    this.serverStatusListeners.push(callback);
    return () => {
      const index = this.serverStatusListeners.indexOf(callback);
      if (index > -1) {
        this.serverStatusListeners.splice(index, 1);
      }
    };
  }

  public async checkServerHealth(urgentCheck: boolean = false): Promise<boolean> {
    const timeout = urgentCheck ? 3000 : 8000; // Timeout plus long pour checks de routine
    
    try {
      // Endpoint dédié health check ultra-léger
      await this.api.get('/api/v1/health', {
        timeout,
        headers: { 'Cache-Control': 'no-cache' },
        params: { _t: Date.now() } // Cache busting
      });
      this.notifyServerStatus(true);
      return true;
    } catch (error) {
      // Fallback sur endpoint Quarkus standard puis clients
      try {
        await this.api.get('/q/health', { timeout: timeout * 0.8 });
        this.notifyServerStatus(true);
        return true;
      } catch (secondError) {
        try {
          await this.api.get('/api/v1/clients', {
            timeout: timeout * 0.6,
            params: { size: 1 }
          });
          this.notifyServerStatus(true);
          return true;
        } catch (thirdError) {
          this.notifyServerStatus(false);
          return false;
        }
      }
    }
  }

  // === CLIENTS ===
  async getClients(): Promise<Client[]> {
    return CacheService.getOrSet(
      CacheKeys.CLIENTS,
      async () => {
        const response = await this.api.get<Client[]>('/api/v1/clients');
        return Array.isArray(response.data) ? response.data : [];
      },
      5 * 60 * 1000 // 5 minutes
    );
  }

  async getClient(id: string): Promise<Client> {
    const response = await this.api.get<Client>(`/api/v1/clients/${id}`);
    return response.data;
  }

  async createClient(client: Partial<Client>): Promise<Client> {
    const response = await this.api.post<Client>('/api/v1/clients', client);
    return response.data;
  }

  async updateClient(id: string, client: Partial<Client>): Promise<Client> {
    const response = await this.api.put<Client>(`/api/v1/clients/${id}`, client);
    return response.data;
  }

  async deleteClient(id: string): Promise<void> {
    await this.api.delete(`/api/v1/clients/${id}`);
  }

  async searchClients(params: {
    nom?: string;
    entreprise?: string;
    ville?: string;
    email?: string;
  }): Promise<Client[]> {
    const response = await this.api.get<Client[]>('/api/v1/clients/search', { params });
    return response.data;
  }

  async searchClientsByNom(nom: string): Promise<Client[]> {
    const response = await this.api.get<Client[]>('/api/v1/clients/search', { params: { nom } });
    return response.data;
  }

  async searchClientsByEntreprise(entreprise: string): Promise<Client[]> {
    const response = await this.api.get<Client[]>('/api/v1/clients/search', { params: { entreprise } });
    return response.data;
  }

  async searchClientsByVille(ville: string): Promise<Client[]> {
    const response = await this.api.get<Client[]>('/api/v1/clients/search', { params: { ville } });
    return response.data;
  }

  async searchClientsByEmail(email: string): Promise<Client[]> {
    const response = await this.api.get<Client[]>('/api/v1/clients/search', { params: { email } });
    return response.data;
  }

  async getClientsCount(): Promise<number> {
    const response = await this.api.get<number>('/api/v1/clients/count');
    return response.data;
  }

  // === CHANTIERS ===
  async getChantiers(): Promise<Chantier[]> {
    const response = await this.api.get<Chantier[]>('/api/v1/chantiers');
    return Array.isArray(response.data) ? response.data : [];
  }

  async getChantiersActifs(): Promise<Chantier[]> {
    const response = await this.api.get<Chantier[]>('/api/v1/chantiers/actifs');
    return Array.isArray(response.data) ? response.data : [];
  }

  async getChantier(id: string): Promise<Chantier> {
    const response = await this.api.get<Chantier>(`/api/v1/chantiers/${id}`);
    return response.data;
  }

  async createChantier(chantier: Partial<Chantier>): Promise<Chantier> {
    const response = await this.api.post<Chantier>('/api/v1/chantiers', chantier);
    return response.data;
  }

  async updateChantier(id: string, chantier: Partial<Chantier>): Promise<Chantier> {
    const response = await this.api.put<Chantier>(`/api/v1/chantiers/${id}`, chantier);
    return response.data;
  }

  async deleteChantier(id: string, permanent: boolean = false): Promise<void> {
    await this.api.delete(`/api/v1/chantiers/${id}`, {
      params: { permanent }
    });
  }

  async getChantiersByClient(clientId: string): Promise<Chantier[]> {
    try {
      const response = await this.api.get<Chantier[]>(`/api/v1/chantiers/client/${clientId}`);
      return response.data;
    } catch (error: any) {
      // Si l'endpoint n'existe pas encore côté backend (404)
      if (error.response?.status === 404) {
        console.debug(`Endpoint /api/v1/chantiers/client/${clientId} non implémenté, retour d'une liste vide`);
        // Retourner une liste vide en attendant l'implémentation backend
        return [];
      }
      // Relancer l'erreur pour les autres cas
      throw error;
    }
  }

  async getChantiersRecents(): Promise<ChantierRecent[]> {
    const response = await this.api.get<ChantierRecent[]>('/api/v1/chantiers/recent');
    return response.data;
  }

  // === DEVIS ===
  async getDevis(): Promise<Devis[]> {
    return CacheService.getOrSet(
      CacheKeys.DEVIS,
      async () => {
        const response = await this.api.get<Devis[]>('/api/v1/devis');
        return Array.isArray(response.data) ? response.data : [];
      },
      3 * 60 * 1000 // 3 minutes (plus court car données plus volatiles)
    );
  }

  async getDevisById(id: string): Promise<Devis> {
    const response = await this.api.get<Devis>(`/api/v1/devis/${id}`);
    return response.data;
  }

  async getDevisEnAttente(): Promise<DevisEnAttente[]> {
    const response = await this.api.get<DevisEnAttente[]>('/api/v1/devis/en-attente');
    return response.data;
  }

  async createDevis(devis: Partial<Devis>): Promise<Devis> {
    const response = await this.api.post<Devis>('/api/v1/devis', devis);
    // Invalider le cache des devis
    CacheService.delete(CacheKeys.DEVIS);
    CacheService.invalidatePattern('devis_.*');
    return response.data;
  }

  async updateDevis(id: string, devis: Partial<Devis>): Promise<Devis> {
    const response = await this.api.put<Devis>(`/api/v1/devis/${id}`, devis);
    // Invalider le cache des devis
    CacheService.delete(CacheKeys.DEVIS);
    CacheService.delete(CacheKeys.devisById(id));
    CacheService.invalidatePattern('devis_.*');
    return response.data;
  }

  async deleteDevis(id: string): Promise<void> {
    await this.api.delete(`/api/v1/devis/${id}`);
    // Invalider le cache des devis
    CacheService.delete(CacheKeys.DEVIS);
    CacheService.delete(CacheKeys.devisById(id));
    CacheService.invalidatePattern('devis_.*');
  }

  // === FACTURES ===
  async getFactures(): Promise<Facture[]> {
    return CacheService.getOrSet(
      CacheKeys.FACTURES,
      async () => {
        const response = await this.api.get<Facture[]>('/api/v1/factures');
        return Array.isArray(response.data) ? response.data : [];
      },
      3 * 60 * 1000 // 3 minutes
    );
  }

  async getFacture(id: string): Promise<Facture> {
    const response = await this.api.get<Facture>(`/api/v1/factures/${id}`);
    return response.data;
  }

  async getFacturesEnRetard(): Promise<FactureEnRetard[]> {
    const response = await this.api.get<FactureEnRetard[]>('/api/v1/factures/en-retard');
    return response.data;
  }

  async createFacture(facture: Partial<Facture>): Promise<Facture> {
    const response = await this.api.post<Facture>('/api/v1/factures', facture);
    // Invalider le cache des factures
    CacheService.delete(CacheKeys.FACTURES);
    CacheService.invalidatePattern('factures_.*');
    return response.data;
  }

  async updateFacture(id: string, facture: Partial<Facture>): Promise<Facture> {
    const response = await this.api.put<Facture>(`/api/v1/factures/${id}`, facture);
    // Invalider le cache des factures
    CacheService.delete(CacheKeys.FACTURES);
    CacheService.delete(CacheKeys.factureById(id));
    CacheService.invalidatePattern('factures_.*');
    return response.data;
  }

  async deleteFacture(id: string): Promise<void> {
    await this.api.delete(`/api/v1/factures/${id}`);
    // Invalider le cache des factures
    CacheService.delete(CacheKeys.FACTURES);
    CacheService.delete(CacheKeys.factureById(id));
    CacheService.invalidatePattern('factures_.*');
  }

  // === DASHBOARD ===
  async getDashboardStats(): Promise<DashboardStats> {
    const response = await this.api.get<DashboardStats>('/api/v1/dashboard/stats');
    return response.data;
  }

  // === HEALTH ===
  async getHealth(): Promise<{ status: string; timestamp: string }> {
    const response = await this.api.get('/api/v1/health');
    return response.data;
  }

  async getVersion(): Promise<{ version: string; environment: string }> {
    const response = await this.api.get('/api/v1/version');
    return response.data;
  }

  // === AUTH ===
  async getCurrentUser(): Promise<UserInfo> {
    const response = await this.api.get('/api/v1/auth/user');
    return response.data;
  }

  async getAuthStatus(): Promise<{ authenticated: boolean; principal: string | null; hasJWT: boolean; timestamp: number }> {
    const response = await this.api.get('/api/v1/auth/status');
    return response.data;
  }

  // === BUDGETS ===
  async getBudgets(params?: { search?: string; statut?: string; tendance?: string }) {
    const response = await this.api.get('/api/v1/budgets', { params });
    return response.data;
  }

  async getBudget(id: string) {
    const response = await this.api.get(`/api/v1/budgets/${id}`);
    return response.data;
  }

  async getBudgetByChantier(chantierId: string) {
    const response = await this.api.get(`/api/v1/budgets/chantier/${chantierId}`);
    return response.data;
  }

  async getBudgetsEnDepassement() {
    const response = await this.api.get('/api/v1/budgets/depassement');
    return response.data;
  }

  async getBudgetsNecessitantAttention() {
    const response = await this.api.get('/api/v1/budgets/attention');
    return response.data;
  }

  async createBudget(budget: any) {
    const response = await this.api.post('/api/v1/budgets', budget);
    return response.data;
  }

  async updateBudget(id: string, budget: any) {
    const response = await this.api.put(`/api/v1/budgets/${id}`, budget);
    return response.data;
  }

  async deleteBudget(id: string) {
    const response = await this.api.delete(`/api/v1/budgets/${id}`);
    return response.data;
  }

  async updateBudgetDepenses(id: string, depense: number) {
    const response = await this.api.put(`/api/v1/budgets/${id}/depenses`, { depense });
    return response.data;
  }

  async updateBudgetAvancement(id: string, avancement: number) {
    const response = await this.api.put(`/api/v1/budgets/${id}/avancement`, { avancement });
    return response.data;
  }

  async ajouterAlerteBudget(id: string, description: string) {
    const response = await this.api.post(`/api/v1/budgets/${id}/alertes`, { description });
    return response.data;
  }

  async supprimerAlertesBudget(id: string) {
    const response = await this.api.delete(`/api/v1/budgets/${id}/alertes`);
    return response.data;
  }

  // === EMPLOYÉS ===
  async getEmployes(): Promise<Employe[]> {
    const response = await this.api.get<Employe[]>('/api/v1/employes');
    return Array.isArray(response.data) ? response.data : [];
  }

  async getEmploye(id: string): Promise<Employe> {
    const response = await this.api.get<Employe>(`/api/v1/employes/${id}`);
    return response.data;
  }

  async createEmploye(employe: Partial<Employe>): Promise<Employe> {
    const response = await this.api.post<Employe>('/api/v1/employes', employe);
    return response.data;
  }

  async updateEmploye(id: string, employe: Partial<Employe>): Promise<Employe> {
    const response = await this.api.put<Employe>(`/api/v1/employes/${id}`, employe);
    return response.data;
  }

  async deleteEmploye(id: string): Promise<void> {
    await this.api.delete(`/api/v1/employes/${id}`);
  }

  async searchEmployes(params: {
    nom?: string;
    poste?: string;
    specialite?: string;
    statut?: string;
  }): Promise<Employe[]> {
    const response = await this.api.get<Employe[]>('/api/v1/employes/search', { params });
    return response.data;
  }

  async getEmployesDisponibles(dateDebut?: string, dateFin?: string): Promise<Employe[]> {
    const response = await this.api.get<Employe[]>('/api/v1/employes/disponibles', {
      params: { dateDebut, dateFin }
    });
    return response.data;
  }

  async getEmployesByEquipe(equipeId: string): Promise<Employe[]> {
    const response = await this.api.get<Employe[]>(`/api/v1/employes/by-equipe/${equipeId}`);
    return response.data;
  }

  async getEmployesCount(): Promise<number> {
    const response = await this.api.get<number>('/api/v1/employes/count');
    return response.data;
  }

  async getEmployesStats(): Promise<any> {
    const response = await this.api.get('/api/v1/employes/stats');
    return response.data;
  }

  // === ÉQUIPES ===
  async getEquipes(): Promise<Equipe[]> {
    const response = await this.api.get<Equipe[]>('/api/v1/equipes');
    return Array.isArray(response.data) ? response.data : [];
  }

  async getEquipe(id: string): Promise<Equipe> {
    const response = await this.api.get<Equipe>(`/api/v1/equipes/${id}`);
    return response.data;
  }

  async createEquipe(equipe: Partial<Equipe>): Promise<Equipe> {
    const response = await this.api.post<Equipe>('/api/v1/equipes', equipe);
    return response.data;
  }

  async updateEquipe(id: string, equipe: Partial<Equipe>): Promise<Equipe> {
    const response = await this.api.put<Equipe>(`/api/v1/equipes/${id}`, equipe);
    return response.data;
  }

  async deleteEquipe(id: string): Promise<void> {
    await this.api.delete(`/api/v1/equipes/${id}`);
  }

  async searchEquipes(params: {
    nom?: string;
    specialite?: string;
    statut?: string;
  }): Promise<Equipe[]> {
    const response = await this.api.get<Equipe[]>('/api/v1/equipes/search', { params });
    return response.data;
  }

  async getEquipesDisponibles(dateDebut?: string, dateFin?: string): Promise<Equipe[]> {
    const response = await this.api.get<Equipe[]>('/api/v1/equipes/disponibles', {
      params: { dateDebut, dateFin }
    });
    return response.data;
  }

  async getMembresEquipe(equipeId: string): Promise<Employe[]> {
    const response = await this.api.get<Employe[]>(`/api/v1/equipes/${equipeId}/membres`);
    return response.data;
  }

  async ajouterMembreEquipe(equipeId: string, employeId: string): Promise<void> {
    await this.api.post(`/api/v1/equipes/${equipeId}/membres/${employeId}`);
  }

  async retirerMembreEquipe(equipeId: string, employeId: string): Promise<void> {
    await this.api.delete(`/api/v1/equipes/${equipeId}/membres/${employeId}`);
  }

  async getEquipesCount(): Promise<number> {
    const response = await this.api.get<number>('/api/v1/equipes/count');
    return response.data;
  }

  async getEquipesStats(): Promise<any> {
    const response = await this.api.get('/api/v1/equipes/stats');
    return response.data;
  }

  // === MATÉRIELS ===
  async getMateriels(): Promise<Materiel[]> {
    const response = await this.api.get<Materiel[]>('/api/v1/materiels');
    return Array.isArray(response.data) ? response.data : [];
  }

  async getMateriel(id: string): Promise<Materiel> {
    const response = await this.api.get<Materiel>(`/api/v1/materiels/${id}`);
    return response.data;
  }

  async createMateriel(materiel: Partial<Materiel>): Promise<Materiel> {
    const response = await this.api.post<Materiel>('/api/v1/materiels', materiel);
    return response.data;
  }

  async updateMateriel(id: string, materiel: Partial<Materiel>): Promise<Materiel> {
    const response = await this.api.put<Materiel>(`/api/v1/materiels/${id}`, materiel);
    return response.data;
  }

  async deleteMateriel(id: string): Promise<void> {
    await this.api.delete(`/api/v1/materiels/${id}`);
  }

  async searchMateriels(params: {
    nom?: string;
    type?: string;
    marque?: string;
    statut?: string;
    localisation?: string;
  }): Promise<Materiel[]> {
    const response = await this.api.get<Materiel[]>('/api/v1/materiels/search', { params });
    return response.data;
  }

  async getMaterielsDisponibles(dateDebut?: string, dateFin?: string, type?: string): Promise<Materiel[]> {
    const response = await this.api.get<Materiel[]>('/api/v1/materiels/disponibles', {
      params: { dateDebut, dateFin, type }
    });
    return response.data;
  }

  async getMaterielsMaintenancePrevue(jours: number = 30): Promise<Materiel[]> {
    const response = await this.api.get<Materiel[]>('/api/v1/materiels/maintenance-prevue', {
      params: { jours }
    });
    return response.data;
  }

  async getMaterielsByType(type: string): Promise<Materiel[]> {
    const response = await this.api.get<Materiel[]>(`/api/v1/materiels/by-type/${type}`);
    return response.data;
  }

  async reserverMateriel(id: string, dateDebut: string, dateFin: string): Promise<void> {
    await this.api.post(`/api/v1/materiels/${id}/reserve`, null, {
      params: { dateDebut, dateFin }
    });
  }

  async libererMateriel(id: string): Promise<void> {
    await this.api.post(`/api/v1/materiels/${id}/liberer`);
  }

  async getMaterielsCount(): Promise<number> {
    const response = await this.api.get<number>('/api/v1/materiels/count');
    return response.data;
  }

  async getMaterielsStats(): Promise<any> {
    const response = await this.api.get('/api/v1/materiels/stats');
    return response.data;
  }

  async getValeurTotaleMateriels(): Promise<number> {
    const response = await this.api.get<number>('/api/v1/materiels/valeur-totale');
    return response.data;
  }

  // === MAINTENANCES ===
  async getMaintenances(): Promise<MaintenanceMateriel[]> {
    const response = await this.api.get<MaintenanceMateriel[]>('/api/v1/maintenances');
    return Array.isArray(response.data) ? response.data : [];
  }

  async getMaintenance(id: string): Promise<MaintenanceMateriel> {
    const response = await this.api.get<MaintenanceMateriel>(`/api/v1/maintenances/${id}`);
    return response.data;
  }

  async createMaintenance(maintenance: Partial<MaintenanceMateriel>): Promise<MaintenanceMateriel> {
    const response = await this.api.post<MaintenanceMateriel>('/api/v1/maintenances', maintenance);
    return response.data;
  }

  async updateMaintenance(id: string, maintenance: Partial<MaintenanceMateriel>): Promise<MaintenanceMateriel> {
    const response = await this.api.put<MaintenanceMateriel>(`/api/v1/maintenances/${id}`, maintenance);
    return response.data;
  }

  async deleteMaintenance(id: string): Promise<void> {
    await this.api.delete(`/api/v1/maintenances/${id}`);
  }

  async getMaintenancesByMateriel(materielId: string): Promise<MaintenanceMateriel[]> {
    const response = await this.api.get<MaintenanceMateriel[]>(`/api/v1/maintenances/by-materiel/${materielId}`);
    return response.data;
  }

  // === PLANNING ===
  async getPlanningEvents(params?: {
    dateDebut?: string;
    dateFin?: string;
    type?: string;
    statut?: string;
  }): Promise<PlanningEvent[]> {
    const response = await this.api.get<PlanningEvent[]>('/api/v1/planning/events', { params });
    return Array.isArray(response.data) ? response.data : [];
  }

  async getPlanningEvent(id: string): Promise<PlanningEvent> {
    const response = await this.api.get<PlanningEvent>(`/api/v1/planning/events/${id}`);
    return response.data;
  }

  async createPlanningEvent(event: Partial<PlanningEvent>): Promise<PlanningEvent> {
    const response = await this.api.post<PlanningEvent>('/api/v1/planning/events', event);
    return response.data;
  }

  async updatePlanningEvent(id: string, event: Partial<PlanningEvent>): Promise<PlanningEvent> {
    const response = await this.api.put<PlanningEvent>(`/api/v1/planning/events/${id}`, event);
    return response.data;
  }

  async deletePlanningEvent(id: string): Promise<void> {
    await this.api.delete(`/api/v1/planning/events/${id}`);
  }

  async getCalendrierView(annee: number, mois: number): Promise<PlanningCalendrierView> {
    const response = await this.api.get<PlanningCalendrierView>('/api/v1/planning/calendrier', {
      params: { annee, mois }
    });
    return response.data;
  }

  async detecterConflitsPlanification(dateDebut?: string, dateFin?: string): Promise<PlanningConflict[]> {
    const response = await this.api.get<PlanningConflict[]>('/api/v1/planning/conflits', {
      params: { dateDebut, dateFin }
    });
    return response.data;
  }

  async getPlanningEmploye(employeId: string, dateDebut?: string, dateFin?: string): Promise<PlanningEvent[]> {
    const response = await this.api.get<PlanningEvent[]>(`/api/v1/planning/employe/${employeId}`, {
      params: { dateDebut, dateFin }
    });
    return response.data;
  }

  async getPlanningEquipe(equipeId: string, dateDebut?: string, dateFin?: string): Promise<PlanningEvent[]> {
    const response = await this.api.get<PlanningEvent[]>(`/api/v1/planning/equipe/${equipeId}`, {
      params: { dateDebut, dateFin }
    });
    return response.data;
  }

  async getPlanningMateriel(materielId: string, dateDebut?: string, dateFin?: string): Promise<PlanningEvent[]> {
    const response = await this.api.get<PlanningEvent[]>(`/api/v1/planning/materiel/${materielId}`, {
      params: { dateDebut, dateFin }
    });
    return response.data;
  }

  async assignEmployesToEvent(eventId: string, employeIds: string[]): Promise<void> {
    await this.api.post(`/api/v1/planning/events/${eventId}/assign-employes`, employeIds);
  }

  async assignMaterielsToEvent(eventId: string, materielIds: string[]): Promise<void> {
    await this.api.post(`/api/v1/planning/events/${eventId}/assign-materiels`, materielIds);
  }

  async getPlanningStats(): Promise<PlanningStats> {
    const response = await this.api.get<PlanningStats>('/api/v1/planning/stats');
    return response.data;
  }

  async getTauxOccupation(dateDebut?: string, dateFin?: string): Promise<any> {
    const response = await this.api.get('/api/v1/planning/occupation', {
      params: { dateDebut, dateFin }
    });
    return response.data;
  }

  // === TEST ===
  async testCreateChantier(chantier: any): Promise<string> {
    const response = await this.api.post('/api/v1/test/chantier', chantier);
    return response.data;
  }
}

// Instance singleton
export const apiService = new ApiService();

// Services spécialisés
export const clientService = {
  getAll: () => apiService.getClients(),
  getById: (id: string) => apiService.getClient(id),
  create: (client: Partial<Client>) => apiService.createClient(client),
  update: (id: string, client: Partial<Client>) => apiService.updateClient(id, client),
  delete: (id: string) => apiService.deleteClient(id),
  search: (params: any) => apiService.searchClients(params),
  searchByNom: (nom: string) => apiService.searchClientsByNom(nom),
  searchByEntreprise: (entreprise: string) => apiService.searchClientsByEntreprise(entreprise),
  searchByVille: (ville: string) => apiService.searchClientsByVille(ville),
  searchByEmail: (email: string) => apiService.searchClientsByEmail(email),
  count: () => apiService.getClientsCount(),
};

export const chantierService = {
  getAll: () => apiService.getChantiers(),
  getAllActive: () => apiService.getChantiersActifs(),
  getById: (id: string) => apiService.getChantier(id),
  create: (chantier: Partial<Chantier>) => apiService.createChantier(chantier),
  update: (id: string, chantier: Partial<Chantier>) => apiService.updateChantier(id, chantier),
  delete: (id: string, permanent: boolean = false) => apiService.deleteChantier(id, permanent),
  getByClient: (clientId: string) => apiService.getChantiersByClient(clientId),
  getRecents: () => apiService.getChantiersRecents(),
};

export const devisService = {
  getAll: () => apiService.getDevis(),
  getById: (id: string) => apiService.getDevisById(id),
  getEnAttente: () => apiService.getDevisEnAttente(),
  create: (devis: Partial<Devis>) => apiService.createDevis(devis),
  update: (id: string, devis: Partial<Devis>) => apiService.updateDevis(id, devis),
  delete: (id: string) => apiService.deleteDevis(id),
};

export const factureService = {
  getAll: () => apiService.getFactures(),
  getById: (id: string) => apiService.getFacture(id),
  getEnRetard: () => apiService.getFacturesEnRetard(),
  create: (facture: Partial<Facture>) => apiService.createFacture(facture),
  update: (id: string, facture: Partial<Facture>) => apiService.updateFacture(id, facture),
  delete: (id: string) => apiService.deleteFacture(id),
};

export const dashboardService = {
  getStats: () => apiService.getDashboardStats(),
};

export const employeService = {
  getAll: () => apiService.getEmployes(),
  getById: (id: string) => apiService.getEmploye(id),
  create: (employe: Partial<Employe>) => apiService.createEmploye(employe),
  update: (id: string, employe: Partial<Employe>) => apiService.updateEmploye(id, employe),
  delete: (id: string) => apiService.deleteEmploye(id),
  search: (params: any) => apiService.searchEmployes(params),
  getDisponibles: (dateDebut?: string, dateFin?: string) => apiService.getEmployesDisponibles(dateDebut, dateFin),
  getByEquipe: (equipeId: string) => apiService.getEmployesByEquipe(equipeId),
  count: () => apiService.getEmployesCount(),
  getStats: () => apiService.getEmployesStats(),
};

export const equipeService = {
  getAll: () => apiService.getEquipes(),
  getById: (id: string) => apiService.getEquipe(id),
  create: (equipe: Partial<Equipe>) => apiService.createEquipe(equipe),
  update: (id: string, equipe: Partial<Equipe>) => apiService.updateEquipe(id, equipe),
  delete: (id: string) => apiService.deleteEquipe(id),
  search: (params: any) => apiService.searchEquipes(params),
  getDisponibles: (dateDebut?: string, dateFin?: string) => apiService.getEquipesDisponibles(dateDebut, dateFin),
  getMembres: (equipeId: string) => apiService.getMembresEquipe(equipeId),
  ajouterMembre: (equipeId: string, employeId: string) => apiService.ajouterMembreEquipe(equipeId, employeId),
  retirerMembre: (equipeId: string, employeId: string) => apiService.retirerMembreEquipe(equipeId, employeId),
  count: () => apiService.getEquipesCount(),
  getStats: () => apiService.getEquipesStats(),
};

export const materielService = {
  getAll: () => apiService.getMateriels(),
  getById: (id: string) => apiService.getMateriel(id),
  create: (materiel: Partial<Materiel>) => apiService.createMateriel(materiel),
  update: (id: string, materiel: Partial<Materiel>) => apiService.updateMateriel(id, materiel),
  delete: (id: string) => apiService.deleteMateriel(id),
  search: (params: any) => apiService.searchMateriels(params),
  getDisponibles: (dateDebut?: string, dateFin?: string, type?: string) => apiService.getMaterielsDisponibles(dateDebut, dateFin, type),
  getMaintenancePrevue: (jours?: number) => apiService.getMaterielsMaintenancePrevue(jours),
  getByType: (type: string) => apiService.getMaterielsByType(type),
  reserver: (id: string, dateDebut: string, dateFin: string) => apiService.reserverMateriel(id, dateDebut, dateFin),
  liberer: (id: string) => apiService.libererMateriel(id),
  count: () => apiService.getMaterielsCount(),
  getStats: () => apiService.getMaterielsStats(),
  getValeurTotale: () => apiService.getValeurTotaleMateriels(),
};

export const budgetService = {
  getAll: (params?: { search?: string; statut?: string; tendance?: string }) => apiService.getBudgets(params),
  getById: (id: string) => apiService.getBudget(id),
  getByChantier: (chantierId: string) => apiService.getBudgetByChantier(chantierId),
  getEnDepassement: () => apiService.getBudgetsEnDepassement(),
  getNecessitantAttention: () => apiService.getBudgetsNecessitantAttention(),
  create: (budget: any) => apiService.createBudget(budget),
  update: (id: string, budget: any) => apiService.updateBudget(id, budget),
  delete: (id: string) => apiService.deleteBudget(id),
  updateDepenses: (id: string, depense: number) => apiService.updateBudgetDepenses(id, depense),
  updateAvancement: (id: string, avancement: number) => apiService.updateBudgetAvancement(id, avancement),
  ajouterAlerte: (id: string, description: string) => apiService.ajouterAlerteBudget(id, description),
  supprimerAlertes: (id: string) => apiService.supprimerAlertesBudget(id),
};

export const maintenanceService = {
  getAll: () => apiService.getMaintenances(),
  getById: (id: string) => apiService.getMaintenance(id),
  create: (maintenance: Partial<MaintenanceMateriel>) => apiService.createMaintenance(maintenance),
  update: (id: string, maintenance: Partial<MaintenanceMateriel>) => apiService.updateMaintenance(id, maintenance),
  delete: (id: string) => apiService.deleteMaintenance(id),
  getByMateriel: (materielId: string) => apiService.getMaintenancesByMateriel(materielId),
};

export const planningService = {
  getEvents: (params?: any) => apiService.getPlanningEvents(params),
  getEvent: (id: string) => apiService.getPlanningEvent(id),
  createEvent: (event: Partial<PlanningEvent>) => apiService.createPlanningEvent(event),
  updateEvent: (id: string, event: Partial<PlanningEvent>) => apiService.updatePlanningEvent(id, event),
  deleteEvent: (id: string) => apiService.deletePlanningEvent(id),
  getCalendrierView: (annee: number, mois: number) => apiService.getCalendrierView(annee, mois),
  detecterConflits: (dateDebut?: string, dateFin?: string) => apiService.detecterConflitsPlanification(dateDebut, dateFin),
  getPlanningEmploye: (employeId: string, dateDebut?: string, dateFin?: string) => apiService.getPlanningEmploye(employeId, dateDebut, dateFin),
  getPlanningEquipe: (equipeId: string, dateDebut?: string, dateFin?: string) => apiService.getPlanningEquipe(equipeId, dateDebut, dateFin),
  getPlanningMateriel: (materielId: string, dateDebut?: string, dateFin?: string) => apiService.getPlanningMateriel(materielId, dateDebut, dateFin),
  assignEmployes: (eventId: string, employeIds: string[]) => apiService.assignEmployesToEvent(eventId, employeIds),
  assignMateriels: (eventId: string, materielIds: string[]) => apiService.assignMaterielsToEvent(eventId, materielIds),
  getStats: () => apiService.getPlanningStats(),
  getTauxOccupation: (dateDebut?: string, dateFin?: string) => apiService.getTauxOccupation(dateDebut, dateFin),
};

// Service pour les types de chantier
// TODO: Implement proper methods in ApiService class
export const typeChantierService = {
  getAll: () => Promise.resolve([]),
  getByCategorie: () => Promise.resolve([]),
  getById: (id: string) => Promise.resolve(null),
  getByCode: (code: string) => Promise.resolve(null),
  create: (typeChantier: any) => Promise.resolve(typeChantier),
  update: (id: string, typeChantier: any) => Promise.resolve(typeChantier),
  delete: (id: string) => Promise.resolve(true),
  reactivate: (id: string) => Promise.resolve(true),
  getStatistiques: () => Promise.resolve({}),
};

export default apiService;