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

import { defineStore } from "pinia";
import { ref, computed } from "vue";
import DeceasedService, {
  Deceased,
  CreateDeceasedPayload,
  UpdateDeceasedPayload,
  DeceasedListResponse,
} from "@/services/deceased";

export const useDeceasedStore = defineStore("deceased", () => {
  // State
  const deceased = ref<Deceased[]>([]);
  const currentDeceased = ref<Deceased | null>(null);
  const loading = ref(false);
  const error = ref<string | null>(null);
  const success = ref(false);

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

  // Getters
  const allDeceased = computed(() => deceased.value);

  const isLoading = computed(() => loading.value);
  const hasError = computed(() => error.value !== null);
  const getError = computed(() => error.value);
  const isSuccess = computed(() => success.value);

  const getDeceasedById = computed(() => (id: number) =>
    deceased.value.find((d) => d.id === id)
  );

  const getPagination = computed(() => pagination.value);

  const getDeceasedFullName = computed(() => (deceased: Deceased) => {
    const parts = [deceased.first_name, deceased.last_name].filter(Boolean);
    return parts.join(" ").trim();
  });

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

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

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

  const setSuccess = (isSuccess: boolean) => {
    success.value = isSuccess;
  };

  const clearSuccess = () => {
    success.value = false;
  };

  const setDeceased = (newDeceased: Deceased[]) => {
    deceased.value = newDeceased;
  };

  const setCurrentDeceased = (deceased: Deceased | null) => {
    currentDeceased.value = deceased;
  };

  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,
      };
    }
  };

  /**
   * Get all deceased with pagination and filters
   */
  const fetchDeceased = async (params?: {
    page?: number;
    per_page?: number;
    search?: string;
    sort_by?: string;
    sort_order?: "asc" | "desc";
  }) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const response = await DeceasedService.getAllDeceased(params);
      setDeceased(response.data);
      if (response.meta) {
        setPagination(response.meta);
      }
      return response;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Échec du chargement des personnes décédées";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Get a single deceased by ID
   */
  const fetchDeceasedById = async (id: number) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const deceased = await DeceasedService.getDeceased(id);
      setCurrentDeceased(deceased);
      return deceased;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Échec du chargement de la personne décédée";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Create a new deceased
   */
  const createDeceased = async (payload: CreateDeceasedPayload) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const response = await DeceasedService.createDeceased(payload);
      // Add the new deceased to the list
      deceased.value.unshift(response.data);
      setCurrentDeceased(response.data);
      setSuccess(true);
      return response.data;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Échec de la création de la personne décédée";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Update an existing deceased
   */
  const updateDeceased = async (payload: UpdateDeceasedPayload) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const response = await DeceasedService.updateDeceased(payload);
      const updatedDeceased = response.data;

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

      // Update current deceased if it's the one being edited
      if (
        currentDeceased.value &&
        currentDeceased.value.id === updatedDeceased.id
      ) {
        setCurrentDeceased(updatedDeceased);
      }

      setSuccess(true);
      return updatedDeceased;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Échec de la mise à jour de la personne décédée";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Delete a deceased
   */
  const deleteDeceased = async (id: number) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const response = await DeceasedService.deleteDeceased(id);

      // Remove from the deceased list
      deceased.value = deceased.value.filter((d) => d.id !== id);

      // Clear current deceased if it's the one being deleted
      if (currentDeceased.value && currentDeceased.value.id === id) {
        setCurrentDeceased(null);
      }

      return response;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Échec de la suppression de la personne décédée";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Search deceased by name or other criteria
   */
  const searchDeceased = async (
    query: string,
    params?: {
      exact_match?: boolean;
    }
  ) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const results = await DeceasedService.searchDeceased(query, params);
      setDeceased(results);
      return results;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Échec de la recherche de personnes décédées";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Reset the state
   */
  const resetState = () => {
    deceased.value = [];
    currentDeceased.value = null;
    loading.value = false;
    error.value = null;
    success.value = false;
    pagination.value = {
      current_page: 1,
      last_page: 1,
      per_page: 10,
      total: 0,
    };
  };

  return {
    // State
    deceased,
    currentDeceased,
    loading,
    error,
    success,
    pagination,

    // Getters
    allDeceased,
    isLoading,
    hasError,
    getError,
    isSuccess,
    getDeceasedById,
    getPagination,
    getDeceasedFullName,

    // Actions
    setLoading,
    setError,
    clearError,
    setSuccess,
    clearSuccess,
    setDeceased,
    setCurrentDeceased,
    setPagination,
    fetchDeceased,
    fetchDeceasedById,
    createDeceased,
    updateDeceased,
    deleteDeceased,
    searchDeceased,
    resetState,
  };
});

export default useDeceasedStore;