/**
 * Hooks TanStack Query pour l'authentification - COOP-CA AMIFOND
 *
 * Hooks personnalisés pour les requêtes d'authentification avec TanStack Query
 */

import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { toast } from "sonner";

import { QUERY_KEYS, QUERY_CONFIG } from "@/lib/api-config";
import { AuthService } from "@/services/auth.service";
import { useAuthStore } from "@/stores/auth/auth-store";
import type {
  LoginRequest,
  RegisterRequest,
  PasswordChangeRequest,
  PasswordResetRequest,
  PasswordResetConfirmRequest,
  User,
} from "@/types/auth";

/**
 * Hook pour la connexion utilisateur
 */
export const useLogin = () => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (credentials: LoginRequest) => {
      // Appeler directement le store sans passer par le hook
      await useAuthStore.getState().login(credentials);
    },
    onSuccess: () => {
      toast.success("Connexion réussie !", {
        description: "Vous êtes maintenant connecté.",
      });

      // Invalider et refetch les données utilisateur
      queryClient.invalidateQueries({ queryKey: QUERY_KEYS.auth.user() });
    },
    onError: (error: any) => {
      toast.error("Erreur de connexion", {
        description: error?.message || "Identifiants incorrects",
      });
    },
  });
};

/**
 * Hook pour l'inscription utilisateur
 */
export const useRegister = () => {
  return useMutation({
    mutationFn: async (data: RegisterRequest) => {
      return await useAuthStore.getState().register(data);
    },
    onSuccess: () => {
      toast.success("Inscription réussie !", {
        description: "Veuillez vérifier votre email pour activer votre compte.",
      });
    },
    onError: (error: any) => {
      toast.error("Erreur d'inscription", {
        description: error?.message || "Veuillez vérifier vos informations",
      });
    },
  });
};

/**
 * Hook pour la déconnexion utilisateur
 */
export const useLogout = () => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async () => {
      await useAuthStore.getState().logout();
    },
    onSuccess: () => {
      toast.success("Déconnexion réussie");

      // Nettoyer toutes les données en cache
      queryClient.clear();

      // Add a small delay to ensure cookies are cleared before redirect
      setTimeout(() => {
        if (typeof window !== "undefined") {
          // Force a complete navigation to ensure middleware re-evaluates
          window.location.replace("/auth/login");
        }
      }, 100);
    },
    onError: (error: any) => {
      console.warn("Erreur lors de la déconnexion:", error);

      // Même en cas d'erreur, nettoyer le cache et rediriger
      queryClient.clear();

      // Add a small delay to ensure cleanup before redirect
      setTimeout(() => {
        if (typeof window !== "undefined") {
          window.location.replace("/auth/login");
        }
      }, 100);
    },
  });
};

/**
 * Hook pour récupérer les informations de l'utilisateur actuel
 */
export const useCurrentUser = () => {
  const isAuthenticated = useAuthStore((state) => state.isAuthenticated);
  const logout = useAuthStore((state) => state.logout);

  return useQuery({
    queryKey: QUERY_KEYS.auth.user(),
    queryFn: async () => {
      try {
        const user = await AuthService.getCurrentUser();
        useAuthStore.getState().updateUser(user);
        return user;
      } catch (error: any) {
        console.error("Erreur lors de la récupération des données utilisateur:", error);
        // Si l'erreur est une 401 (Non autorisé), déconnecter l'utilisateur
        if (error?.status === 401) {
          logout();
        }
        // Renvoyer une promesse rejetée pour que TanStack Query marque la requête comme étant en erreur
        return Promise.reject(error);
      }
    },
    enabled: isAuthenticated,
    staleTime: QUERY_CONFIG.defaultOptions.queries.staleTime,
    retry: (failureCount, error: any) => {
      // Ne pas réessayer en cas d'erreur 401, car la session est invalide
      if (error?.status === 401) {
        return false;
      }
      // Comportement par défaut pour les autres erreurs (3 tentatives)
      return failureCount < 3;
    },
  });
};

/**
 * Hook pour mettre à jour les informations utilisateur
 */
export const useUpdateUser = () => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (userData: Partial<User>) => {
      const updatedUser = await AuthService.updateUser(userData);
      return updatedUser;
    },
    onSuccess: (updatedUser) => {
      // Mettre à jour le store
      useAuthStore.getState().updateUser(updatedUser);

      // Invalider et refetch les données utilisateur
      queryClient.setQueryData(QUERY_KEYS.auth.user(), updatedUser);

      toast.success("Profil mis à jour", {
        description: "Vos informations ont été sauvegardées.",
      });
    },
    onError: (error: any) => {
      toast.error("Erreur de mise à jour", {
        description: error?.message || "Impossible de sauvegarder vos modifications",
      });
    },
  });
};

/**
 * Hook pour changer le mot de passe
 */
export const useChangePassword = () => {
  return useMutation({
    mutationFn: async (data: PasswordChangeRequest) => {
      return await AuthService.changePassword(data);
    },
    onSuccess: () => {
      toast.success("Mot de passe modifié", {
        description: "Votre mot de passe a été mis à jour avec succès.",
      });
    },
    onError: (error: any) => {
      toast.error("Erreur de modification", {
        description: error?.message || "Impossible de modifier le mot de passe",
      });
    },
  });
};

/**
 * Hook pour demander une réinitialisation de mot de passe
 */
export const usePasswordReset = () => {
  return useMutation({
    mutationFn: async (data: PasswordResetRequest) => {
      return await AuthService.requestPasswordReset(data);
    },
    onSuccess: () => {
      toast.success("Email envoyé", {
        description: "Vérifiez votre boîte mail pour réinitialiser votre mot de passe.",
      });
    },
    onError: (error: any) => {
      toast.error("Erreur d'envoi", {
        description: error?.message || "Impossible d'envoyer l'email de réinitialisation",
      });
    },
  });
};

/**
 * Hook pour confirmer la réinitialisation de mot de passe
 */
export const usePasswordResetConfirm = () => {
  return useMutation({
    mutationFn: async (data: PasswordResetConfirmRequest) => {
      return await AuthService.confirmPasswordReset(data);
    },
    onSuccess: () => {
      toast.success("Mot de passe réinitialisé", {
        description: "Votre mot de passe a été réinitialisé avec succès.",
      });
    },
    onError: (error: any) => {
      toast.error("Erreur de réinitialisation", {
        description: error?.message || "Impossible de réinitialiser le mot de passe",
      });
    },
  });
};



/**
 * Hook personnalisé pour gérer l'état de chargement global de l'authentification
 */
export const useAuthLoading = () => {
  const isLoading = useAuthStore((state) => state.isLoading);
  const { isLoading: isUserLoading } = useCurrentUser();

  return isLoading || isUserLoading;
};

/**
 * Hook pour gérer l'état d'authentification complet
 */
export const useAuth = () => {
  const authState = useAuthStore();
  const currentUserQuery = useCurrentUser();

  return {
    ...authState,
    isLoading: authState.isLoading || currentUserQuery.isLoading,
    error: authState.error || currentUserQuery.error,
  };
};