New-Thanasoft/thanasoft-front/src/stores/fournisseurStore.ts

import { defineStore } from "pinia";
import { ref, computed } from "vue";
import FournisseurService from "@/services/fournisseur";

import type {
  Fournisseur,
  CreateFournisseurPayload,
  UpdateFournisseurPayload,
  FournisseurListResponse,
} from "@/services/fournisseur";

export const useFournisseurStore = defineStore("fournisseur", () => {
  // State
  const fournisseurs = ref<Fournisseur[]>([]);
  const currentFournisseur = ref<Fournisseur | null>(null);
  const loading = ref(false);
  const error = ref<string | null>(null);
  const searchResults = ref<Fournisseur[]>([]);

  // Pagination state
  const pagination = ref({
    current_page: 1,
    last_page: 1,
    per_page: 10,
    total: 0,
  });

  // Getters
  const allFournisseurs = computed(() => fournisseurs.value);
  const activeFournisseurs = computed(() =>
    fournisseurs.value.filter((fournisseur) => fournisseur.is_active)
  );
  const inactiveFournisseurs = computed(() =>
    fournisseurs.value.filter((fournisseur) => !fournisseur.is_active)
  );
  const isLoading = computed(() => loading.value);
  const hasError = computed(() => error.value !== null);
  const getError = computed(() => error.value);
  const getFournisseurById = computed(() => (id: number) =>
    fournisseurs.value.find((fournisseur) => fournisseur.id === id)
  );
  const getPagination = computed(() => pagination.value);

  // Actions
  const setLoading = (isLoading: boolean) => {
    loading.value = isLoading;
  };

  const setError = (err: string | null) => {
    error.value = err;
  };

  const clearError = () => {
    error.value = null;
  };

  const setFournisseurs = (newFournisseurs: Fournisseur[]) => {
    fournisseurs.value = newFournisseurs;
  };

  const setCurrentFournisseur = (fournisseur: Fournisseur | null) => {
    currentFournisseur.value = fournisseur;
  };

  const setSearchFournisseur = (searchFournisseur: Fournisseur[]) => {
    searchResults.value = searchFournisseur;
  };

  const setPagination = (meta: any) => {
    if (meta) {
      pagination.value = {
        current_page: meta.current_page || 1,
        last_page: meta.last_page || 1,
        per_page: meta.per_page || 10,
        total: meta.total || 0,
      };
    }
  };

  /**
   * Fetch all fournisseurs with optional pagination and filters
   */
  const fetchFournisseurs = async (params?: {
    page?: number;
    per_page?: number;
    search?: string;
    is_active?: boolean;
  }) => {
    setLoading(true);
    setError(null);

    try {
      const response = await FournisseurService.getAllFournisseurs(params);
      setFournisseurs(response.data);
      if (response.meta) {
        setPagination(response.meta);
      }
      return response;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Failed to fetch fournisseurs";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Fetch a single fournisseur by ID
   */
  const fetchFournisseur = async (id: number) => {
    setLoading(true);
    setError(null);

    try {
      const response = await FournisseurService.getFournisseur(id);
      setCurrentFournisseur(response.data);
      return response.data;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Failed to fetch fournisseur";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Create a new fournisseur
   */
  const createFournisseur = async (payload: CreateFournisseurPayload) => {
    setLoading(true);
    setError(null);

    try {
      const response = await FournisseurService.createFournisseur(payload);
      // Add the new fournisseur to the list
      fournisseurs.value.push(response.data);
      setCurrentFournisseur(response.data);
      return response.data;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Failed to create fournisseur";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Update an existing fournisseur
   */
  const updateFournisseur = async (payload: UpdateFournisseurPayload) => {
    setLoading(true);
    setError(null);

    try {
      const response = await FournisseurService.updateFournisseur(payload);
      const updatedFournisseur = response.data;

      // Update in the fournisseurs list
      const index = fournisseurs.value.findIndex(
        (fournisseur) => fournisseur.id === updatedFournisseur.id
      );
      if (index !== -1) {
        fournisseurs.value[index] = updatedFournisseur;
      }

      // Update current fournisseur if it's the one being edited
      if (
        currentFournisseur.value &&
        currentFournisseur.value.id === updatedFournisseur.id
      ) {
        setCurrentFournisseur(updatedFournisseur);
      }

      return updatedFournisseur;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Failed to update fournisseur";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Delete a fournisseur
   */
  const deleteFournisseur = async (id: number) => {
    setLoading(true);
    setError(null);

    try {
      const response = await FournisseurService.deleteFournisseur(id);

      // Remove from the fournisseurs list
      fournisseurs.value = fournisseurs.value.filter(
        (fournisseur) => fournisseur.id !== id
      );

      // Clear current fournisseur if it's the one being deleted
      if (currentFournisseur.value && currentFournisseur.value.id === id) {
        setCurrentFournisseur(null);
      }

      return response;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Failed to delete fournisseur";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Search fournisseurs
   */
  const searchFournisseurs = async (
    query: string,
    exactMatch: boolean = false
  ) => {
    setLoading(true);
    error.value = null;

    try {
      const results = await FournisseurService.searchFournisseurs(query, {
        exact_match: exactMatch,
      });
      setSearchFournisseur(results);
      return results;
    } catch (err) {
      error.value = "Erreur lors de la recherche des fournisseurs";
      console.error("Error searching fournisseurs:", err);
      setSearchFournisseur([]);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Clear current fournisseur
   */
  const clearCurrentFournisseur = () => {
    setCurrentFournisseur(null);
  };

  /**
   * Clear all state
   */
  const clearStore = () => {
    fournisseurs.value = [];
    currentFournisseur.value = null;
    error.value = null;
    pagination.value = {
      current_page: 1,
      last_page: 1,
      per_page: 10,
      total: 0,
    };
  };

  return {
    // State
    fournisseurs,
    currentFournisseur,
    loading,
    error,

    // Getters
    allFournisseurs,
    activeFournisseurs,
    inactiveFournisseurs,
    isLoading,
    hasError,
    getError,
    getFournisseurById,
    getPagination,

    // Actions
    fetchFournisseurs,
    fetchFournisseur,
    createFournisseur,
    updateFournisseur,
    deleteFournisseur,
    searchFournisseurs,
    clearCurrentFournisseur,
    clearStore,
    clearError,
  };
});