btpxpress-frontend/hooks/useStocks.ts

import { useState, useEffect } from 'react';
import { apiClient } from '../services/api-client';
import { Stock, CategorieStock, StatutStock, MouvementStock } from '../types/stocks';

export const useStocks = () => {
    const [stocks, setStocks] = useState<Stock[]>([]);
    const [loading, setLoading] = useState(true);
    const [error, setError] = useState<string | null>(null);

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

    const getStockByReference = async (reference: string) => {
        try {
            const response = await apiClient.get(`/stocks/reference/${reference}`);
            return response.data;
        } catch (err) {
            console.error('Erreur lors du chargement du stock:', err);
            throw err;
        }
    };

    const searchByDesignation = async (designation: string) => {
        try {
            const response = await apiClient.get('/stocks/search', {
                params: { designation }
            });
            return response.data;
        } catch (err) {
            console.error('Erreur lors de la recherche:', err);
            throw err;
        }
    };

    const getStocksByCategorie = async (categorie: CategorieStock) => {
        try {
            const response = await apiClient.get(`/stocks/categorie/${categorie}`);
            return response.data;
        } catch (err) {
            console.error('Erreur lors du chargement des stocks par catégorie:', err);
            throw err;
        }
    };

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

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

    const createStock = async (stock: Partial<Stock>) => {
        try {
            const response = await apiClient.post('/stocks', stock);
            await fetchStocks();
            return response.data;
        } catch (err) {
            console.error('Erreur lors de la création du stock:', err);
            throw err;
        }
    };

    const updateStock = async (id: string, stock: Partial<Stock>) => {
        try {
            const response = await apiClient.put(`/stocks/${id}`, stock);
            await fetchStocks();
            return response.data;
        } catch (err) {
            console.error('Erreur lors de la mise à jour du stock:', err);
            throw err;
        }
    };

    const entreeStock = async (mouvement: MouvementStock) => {
        try {
            const response = await apiClient.post('/stocks/entree', mouvement);
            await fetchStocks();
            return response.data;
        } catch (err) {
            console.error('Erreur lors de l\'entrée de stock:', err);
            throw err;
        }
    };

    const sortieStock = async (mouvement: MouvementStock) => {
        try {
            const response = await apiClient.post('/stocks/sortie', mouvement);
            await fetchStocks();
            return response.data;
        } catch (err) {
            console.error('Erreur lors de la sortie de stock:', err);
            throw err;
        }
    };

    const reserverStock = async (stockId: string, quantite: number, chantierId?: string) => {
        try {
            const response = await apiClient.post('/stocks/reserver', {
                stockId,
                quantite,
                chantierId
            });
            await fetchStocks();
            return response.data;
        } catch (err) {
            console.error('Erreur lors de la réservation:', err);
            throw err;
        }
    };

    const libererReservation = async (stockId: string, quantite: number) => {
        try {
            const response = await apiClient.post('/stocks/liberer-reservation', {
                stockId,
                quantite
            });
            await fetchStocks();
            return response.data;
        } catch (err) {
            console.error('Erreur lors de la libération de réservation:', err);
            throw err;
        }
    };

    const inventaire = async (stockId: string, quantiteReelle: number, observations?: string) => {
        try {
            const response = await apiClient.post('/stocks/inventaire', {
                stockId,
                quantiteReelle,
                observations
            });
            await fetchStocks();
            return response.data;
        } catch (err) {
            console.error('Erreur lors de l\'inventaire:', err);
            throw err;
        }
    };

    const changerStatut = async (stockId: string, nouveauStatut: StatutStock, motif?: string) => {
        try {
            const response = await apiClient.post('/stocks/statut', {
                stockId,
                nouveauStatut,
                motif
            });
            await fetchStocks();
            return response.data;
        } catch (err) {
            console.error('Erreur lors du changement de statut:', err);
            throw err;
        }
    };

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

    const deleteStock = async (id: string) => {
        try {
            await apiClient.delete(`/stocks/${id}`);
            await fetchStocks();
        } catch (err) {
            console.error('Erreur lors de la suppression du stock:', err);
            throw err;
        }
    };

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

    return {
        stocks,
        loading,
        error,
        refresh: fetchStocks,
        getStockByReference,
        searchByDesignation,
        getStocksByCategorie,
        getStocksEnRupture,
        getStocksSousMinimum,
        createStock,
        updateStock,
        entreeStock,
        sortieStock,
        reserverStock,
        libererReservation,
        inventaire,
        changerStatut,
        getStatistiques,
        deleteStock
    };
};