import { defineStore } from "pinia";
import { ref, computed } from "vue";
import InterventionService from "@/services/intervention";
import type {
  Intervention,
  CreateInterventionPayload,
  UpdateInterventionPayload,
  InterventionListResponse,
} from "@/services/intervention";

export const useInterventionStore = defineStore("intervention", () => {
  // State
  const interventions = ref<Intervention[]>([]);
  const currentIntervention = ref<Intervention | 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 allInterventions = computed(() => interventions.value);

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

  const getInterventionById = computed(() => (id: number) =>
    interventions.value.find((i) => i.id === id)
  );

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

  const getInterventionsByDeceased = computed(() => (deceasedId: number) =>
    interventions.value.filter((i) => i.deceased_id === deceasedId)
  );

  const getInterventionsByClient = computed(() => (clientId: number) =>
    interventions.value.filter((i) => i.client_id === clientId)
  );

  const getScheduledInterventions = computed(() =>
    interventions.value.filter(
      (i) => i.scheduled_at && new Date(i.scheduled_at) > new Date()
    )
  );

  const getCompletedInterventions = computed(() =>
    interventions.value.filter((i) => i.status === "completed")
  );

  const getPendingInterventions = computed(() =>
    interventions.value.filter((i) => i.status === "pending")
  );

  // 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 setInterventions = (newInterventions: Intervention[]) => {
    interventions.value = newInterventions;
  };

  const setCurrentIntervention = (intervention: Intervention | null) => {
    currentIntervention.value = intervention;
  };

  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 interventions with pagination and filters
   */
  const fetchInterventions = async (params?: {
    page?: number;
    per_page?: number;
    search?: string;
    deceased_id?: number;
    client_id?: number;
    status?: string;
    scheduled_at?: string;
    sort_by?: string;
    sort_order?: "asc" | "desc";
  }) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const response = await InterventionService.getAllInterventions(params);
      setInterventions(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 interventions";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

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

    try {
      const intervention = await InterventionService.getIntervention(id);
      console.log(intervention);
      setCurrentIntervention(intervention);
      return intervention;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Échec du chargement de l'intervention";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Create a new intervention
   */
  const createIntervention = async (payload: CreateInterventionPayload) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const intervention = await InterventionService.createIntervention(
        payload
      );
      // Add the new intervention to the list
      interventions.value.unshift(intervention);
      setCurrentIntervention(intervention);
      setSuccess(true);
      return intervention;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Échec de la création de l'intervention";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Create a new intervention with all data (deceased, client, location, documents)
   */
  const createInterventionWithAllData = async (formData: FormData) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const intervention = await InterventionService.createInterventionWithAllData(
        formData
      );
      // Add the new intervention to the list
      interventions.value.unshift(intervention);
      setCurrentIntervention(intervention);
      setSuccess(true);
      return intervention;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Échec de la création de l'intervention avec toutes les données";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Update an existing intervention
   */
  const updateIntervention = async (payload: UpdateInterventionPayload) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const intervention = await InterventionService.updateIntervention(
        payload
      );

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

      // Update current intervention if it's the one being edited
      if (
        currentIntervention.value &&
        currentIntervention.value.id === intervention.id
      ) {
        setCurrentIntervention(intervention);
      }

      setSuccess(true);
      return intervention;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Échec de la mise à jour de l'intervention";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Delete an intervention
   */
  const deleteIntervention = async (id: number) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const response = await InterventionService.deleteIntervention(id);

      // Remove from the interventions list
      interventions.value = interventions.value.filter((i) => i.id !== id);

      // Clear current intervention if it's the one being deleted
      if (currentIntervention.value && currentIntervention.value.id === id) {
        setCurrentIntervention(null);
      }

      return response;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Échec de la suppression de l'intervention";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Get interventions by deceased ID
   */
  const fetchInterventionsByDeceased = async (
    deceasedId: number,
    params?: {
      page?: number;
      per_page?: number;
    }
  ) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const response = await InterventionService.getInterventionsByDeceased(
        deceasedId,
        params
      );
      setInterventions(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 interventions du défunt";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Get interventions by client ID
   */
  const fetchInterventionsByClient = async (
    clientId: number,
    params?: {
      page?: number;
      per_page?: number;
    }
  ) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const response = await InterventionService.getInterventionsByClient(
        clientId,
        params
      );
      setInterventions(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 interventions du client";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Search interventions by various criteria
   */
  const searchInterventions = async (
    query: string,
    params?: {
      exact_match?: boolean;
    }
  ) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const results = await InterventionService.searchInterventions(
        query,
        params
      );
      setInterventions(results);
      return results;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Échec de la recherche d'interventions";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Update intervention status
   */
  const updateInterventionStatus = async (id: number, status: string) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const intervention = await InterventionService.updateInterventionStatus(
        id,
        status
      );

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

      // Update current intervention if it's the one being updated
      if (
        currentIntervention.value &&
        currentIntervention.value.id === intervention.id
      ) {
        setCurrentIntervention(intervention);
      }

      setSuccess(true);
      return intervention;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Échec de la mise à jour du statut";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Assign practitioner(s) to intervention
   */
  const assignPractitioner = async (
    id: number,
    practitionerData: {
      practitioners?: number[];
      principal_practitioner_id?: number;
      assistant_practitioner_ids?: number[];
    }
  ) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const intervention = await InterventionService.assignPractitioner(
        id,
        practitionerData
      );

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

      // Update current intervention if it's the one being updated
      if (
        currentIntervention.value &&
        currentIntervention.value.id === intervention.id
      ) {
        setCurrentIntervention(intervention);
      }

      setSuccess(true);
      return intervention;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Échec de l'assignation des praticiens";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Assign multiple practitioners to intervention
   */
  const assignPractitioners = async (
    id: number,
    practitionerIds: number[],
    principalPractitionerId?: number
  ) => {
    return assignPractitioner(id, {
      practitioners: practitionerIds,
      principal_practitioner_id: principalPractitionerId,
    });
  };

  /**
   * Update practitioners for intervention (replace all existing)
   */
  const updatePractitioners = async (
    id: number,
    practitionerData: {
      practitioners?: number[];
      principal_practitioner_id?: number;
      assistant_practitioner_ids?: number[];
    }
  ) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const intervention = await InterventionService.updatePractitioners(
        id,
        practitionerData
      );

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

      // Update current intervention if it's the one being updated
      if (
        currentIntervention.value &&
        currentIntervention.value.id === intervention.id
      ) {
        setCurrentIntervention(intervention);
      }

      setSuccess(true);
      return intervention;
    } catch (err: any) {
      const errorMessage =
        err.response?.data?.message ||
        err.message ||
        "Échec de la mise à jour des praticiens";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Get interventions by month
   */
  const fetchInterventionsByMonth = async (year: number, month: number) => {
    setLoading(true);
    setError(null);
    setSuccess(false);

    try {
      const response = await InterventionService.getInterventionsByMonth(
        year,
        month
      );
      setInterventions(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 interventions du mois";
      setError(errorMessage);
      throw err;
    } finally {
      setLoading(false);
    }
  };

  /**
   * Reset the state
   */
  const resetState = () => {
    interventions.value = [];
    currentIntervention.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
    interventions,
    currentIntervention,
    loading,
    error,
    success,
    pagination,

    // Getters
    allInterventions,
    isLoading,
    hasError,
    getError,
    isSuccess,
    getInterventionById,
    getPagination,
    getInterventionsByDeceased,
    getInterventionsByClient,
    getScheduledInterventions,
    getCompletedInterventions,
    getPendingInterventions,

    // Actions
    setLoading,
    setError,
    clearError,
    setSuccess,
    clearSuccess,
    setInterventions,
    setCurrentIntervention,
    setPagination,
    fetchInterventions,
    fetchInterventionById,
    createIntervention,
    createInterventionWithAllData,
    updateIntervention,
    deleteIntervention,
    fetchInterventionsByDeceased,
    fetchInterventionsByClient,
    searchInterventions,
    updateInterventionStatus,
    assignPractitioner,
    assignPractitioners,
    updatePractitioners,
    fetchInterventionsByMonth,
    resetState,
  };
});

export default useInterventionStore;