btpxpress-frontend/hooks/usePhases.ts

import { useState, useEffect } from 'react';
import { apiClient } from '../services/api-client';
import { PhaseChantier, StatutPhase } from '../types/phases';

export const usePhases = () => {
    const [phases, setPhases] = useState<PhaseChantier[]>([]);
    const [loading, setLoading] = useState(true);
    const [error, setError] = useState<string | null>(null);

    const fetchPhases = async () => {
        try {
            setLoading(true);
            const response = await apiClient.get('/phases');
            setPhases(response.data);
            setError(null);
        } catch (err) {
            console.error('Erreur lors du chargement des phases:', err);
            setError('Erreur lors du chargement des phases');
        } finally {
            setLoading(false);
        }
    };

    const getPhasesByChantier = async (chantierId: string) => {
        try {
            const response = await apiClient.get(`/phases/chantier/${chantierId}`);
            return response.data;
        } catch (err) {
            console.error('Erreur lors du chargement des phases du chantier:', err);
            throw err;
        }
    };

    const getPhasesByStatut = async (statut: StatutPhase) => {
        try {
            const response = await apiClient.get(`/phases/statut/${statut}`);
            return response.data;
        } catch (err) {
            console.error('Erreur lors du chargement des phases par statut:', err);
            throw err;
        }
    };

    const getPhasesEnRetard = async () => {
        try {
            const response = await apiClient.get('/phases/en-retard');
            return response.data;
        } catch (err) {
            console.error('Erreur lors du chargement des phases en retard:', err);
            throw err;
        }
    };

    const getPhasesCritiques = async () => {
        try {
            const response = await apiClient.get('/phases/critiques');
            return response.data;
        } catch (err) {
            console.error('Erreur lors du chargement des phases critiques:', err);
            throw err;
        }
    };

    const createPhase = async (phase: Partial<PhaseChantier>) => {
        try {
            const response = await apiClient.post('/phases', phase);
            await fetchPhases();
            return response.data;
        } catch (err) {
            console.error('Erreur lors de la création de la phase:', err);
            throw err;
        }
    };

    const updatePhase = async (id: string, phase: Partial<PhaseChantier>) => {
        try {
            const response = await apiClient.put(`/phases/${id}`, phase);
            await fetchPhases();
            return response.data;
        } catch (err) {
            console.error('Erreur lors de la mise à jour de la phase:', err);
            throw err;
        }
    };

    const demarrerPhase = async (id: string) => {
        try {
            const response = await apiClient.post(`/phases/${id}/demarrer`);
            await fetchPhases();
            return response.data;
        } catch (err) {
            console.error('Erreur lors du démarrage de la phase:', err);
            throw err;
        }
    };

    const terminerPhase = async (id: string) => {
        try {
            const response = await apiClient.post(`/phases/${id}/terminer`);
            await fetchPhases();
            return response.data;
        } catch (err) {
            console.error('Erreur lors de la terminaison de la phase:', err);
            throw err;
        }
    };

    const suspendrePhase = async (id: string, motif: string) => {
        try {
            const response = await apiClient.post(`/phases/${id}/suspendre`, { motif });
            await fetchPhases();
            return response.data;
        } catch (err) {
            console.error('Erreur lors de la suspension de la phase:', err);
            throw err;
        }
    };

    const reprendrePhase = async (id: string) => {
        try {
            const response = await apiClient.post(`/phases/${id}/reprendre`);
            await fetchPhases();
            return response.data;
        } catch (err) {
            console.error('Erreur lors de la reprise de la phase:', err);
            throw err;
        }
    };

    const updateAvancement = async (id: string, pourcentage: number) => {
        try {
            const response = await apiClient.post(`/phases/${id}/avancement`, { pourcentage });
            await fetchPhases();
            return response.data;
        } catch (err) {
            console.error('Erreur lors de la mise à jour de l\'avancement:', err);
            throw err;
        }
    };

    const deletePhase = async (id: string) => {
        try {
            await apiClient.delete(`/phases/${id}`);
            await fetchPhases();
        } catch (err) {
            console.error('Erreur lors de la suppression de la phase:', err);
            throw err;
        }
    };

    useEffect(() => {
        fetchPhases();
    }, []);

    return {
        phases,
        loading,
        error,
        refresh: fetchPhases,
        getPhasesByChantier,
        getPhasesByStatut,
        getPhasesEnRetard,
        getPhasesCritiques,
        createPhase,
        updatePhase,
        demarrerPhase,
        terminerPhase,
        suspendrePhase,
        reprendrePhase,
        updateAvancement,
        deletePhase
    };
};