import { useState, useEffect } from "react";
import { useToast } from "@/hooks/use-toast";
import { SkillCategory } from "@/lib/types";
import { adminClient } from "@/clients";
import { Skill } from "@/clients/domains/admin-client";

interface SkillFormData {
  name: string;
  categoryId: string;
  description: string;
  icon: string;
}

// Hook pour gérer les catégories de skills
export function useSkillCategoriesManagement(
  initialCategories: SkillCategory[]
) {
  const [skillCategories, setSkillCategories] = useState(initialCategories);
  const { toast } = useToast();

  const handleDeleteCategory = async (categoryName: string) => {
    try {
      // Trouver la catégorie par son nom
      const category = skillCategories.find((cat) => cat.name === categoryName);
      if (!category) {
        throw new Error("Catégorie non trouvée");
      }

      await adminClient.deleteSkillCategory(category.id);

      // Mettre à jour l'état local
      setSkillCategories((prevCategories) =>
        prevCategories.filter((cat) => cat.id !== category.id)
      );

      toast({
        title: "Succès",
        description: `Catégorie "${categoryName}" supprimée avec succès`,
      });
      return true;
    } catch (error: any) {
      toast({
        title: "Erreur",
        description:
          error.message || "Erreur lors de la suppression de la catégorie",
        variant: "destructive",
      });
      return false;
    }
  };

  return {
    skillCategories,
    setSkillCategories,
    handleDeleteCategory,
  };
}

export function useSkillsManagement(
  skillCategories: SkillCategory[],
  initialSkills?: any[]
) {
  const [skills, setSkills] = useState<Skill[]>(initialSkills || []);
  const [isLoading, setIsLoading] = useState(!initialSkills);
  const [editingSkill, setEditingSkill] = useState<Skill | null>(null);
  const [skillFormData, setSkillFormData] = useState<SkillFormData>({
    name: "",
    categoryId: "",
    description: "",
    icon: "",
  });
  const [isSubmitting, setIsSubmitting] = useState(false);
  const { toast } = useToast();

  const resetForm = () => {
    setSkillFormData({ name: "", categoryId: "", description: "", icon: "" });
    setEditingSkill(null);
  };

  const handleCreateSkill = async () => {
    if (!skillFormData.name || !skillFormData.categoryId) {
      toast({
        title: "Erreur",
        description: "Veuillez remplir tous les champs obligatoires",
        variant: "destructive",
      });
      return false;
    }

    try {
      setIsSubmitting(true);
      const categoryIndex = parseInt(skillFormData.categoryId);
      const category = skillCategories[categoryIndex];

      const skillData = {
        ...skillFormData,
        category: category.category,
        categoryId: category.id,
        importance: "standard", // Valeur par défaut
      };

      const newSkill = await adminClient.createSkill(skillData);

      setSkills((prevSkills) => [...prevSkills, newSkill]);
      resetForm();

      toast({
        title: "Succès",
        description: "Skill créée avec succès",
      });
      return true;
    } catch (error: any) {
      toast({
        title: "Erreur",
        description: error.message || "Erreur lors de la création de la skill",
        variant: "destructive",
      });
      return false;
    } finally {
      setIsSubmitting(false);
    }
  };

  const handleEditSkill = (skill: Skill) => {
    setEditingSkill(skill);
    const categoryIndex = skillCategories.findIndex(
      (cat) => cat.category === skill.category
    );
    setSkillFormData({
      name: skill.name,
      categoryId: categoryIndex !== -1 ? categoryIndex.toString() : "",
      description: skill.description,
      icon: skill.icon,
    });
  };

  const handleUpdateSkill = async () => {
    if (!editingSkill || !skillFormData.name || !skillFormData.categoryId) {
      toast({
        title: "Erreur",
        description: "Veuillez remplir tous les champs obligatoires",
        variant: "destructive",
      });
      return false;
    }

    try {
      setIsSubmitting(true);
      const categoryIndex = parseInt(skillFormData.categoryId);
      const category = skillCategories[categoryIndex];

      const skillData = {
        id: editingSkill.id,
        ...skillFormData,
        category: category.category,
        usageCount: editingSkill.usageCount,
        importance: editingSkill.importance || "standard", // Garder l'importance existante
      };

      const updatedSkill = await adminClient.updateSkill(skillData);

      const updatedSkills = skills.map((skill) =>
        skill.id === editingSkill.id ? updatedSkill : skill
      );

      setSkills(updatedSkills);
      resetForm();

      toast({
        title: "Succès",
        description: "Skill mise à jour avec succès",
      });
      return true;
    } catch (error: any) {
      toast({
        title: "Erreur",
        description:
          error.message || "Erreur lors de la mise à jour de la skill",
        variant: "destructive",
      });
      return false;
    } finally {
      setIsSubmitting(false);
    }
  };

  const handleDeleteSkill = async (skillId: string) => {
    if (
      !confirm(
        "Êtes-vous sûr de vouloir supprimer cette skill ? Cette action est irréversible."
      )
    ) {
      return;
    }

    try {
      await adminClient.deleteSkill(skillId);
      setSkills(skills.filter((s) => s.id !== skillId));
      toast({
        title: "Succès",
        description: "Skill supprimée avec succès",
      });
    } catch (error: any) {
      toast({
        title: "Erreur",
        description:
          error.message || "Erreur lors de la suppression de la skill",
        variant: "destructive",
      });
    }
  };

  const handleImportanceChange = async (
    skillId: string,
    newImportance: string
  ) => {
    try {
      await adminClient.updateSkillImportance(skillId, newImportance as any);

      // Mettre à jour l'état local
      setSkills((prevSkills) =>
        prevSkills.map((skill) =>
          skill.id === skillId ? { ...skill, importance: newImportance } : skill
        )
      );

      toast({
        title: "Succès",
        description: "Importance mise à jour avec succès",
      });
      return true;
    } catch (error: any) {
      toast({
        title: "Erreur",
        description:
          error.message || "Erreur lors de la mise à jour de l'importance",
        variant: "destructive",
      });
      return false;
    }
  };

  return {
    skills,
    isLoading,
    editingSkill,
    skillFormData,
    isSubmitting,
    setSkillFormData,
    resetForm,
    handleCreateSkill,
    handleEditSkill,
    handleUpdateSkill,
    handleDeleteSkill,
    handleImportanceChange,
  };
}