peakskills/hooks/use-teams-management.ts

import { useState, useEffect } from "react";
import { useToast } from "@/hooks/use-toast";
import { Team as TeamType } from "@/lib/types";
import { TeamStats } from "@/lib/admin-types";
import { adminClient } from "@/clients";

interface TeamFormData {
  name: string;
  direction: string;
}

export function useTeamsManagement(
  initialTeams: TeamType[],
  initialTeamStats: TeamStats[]
) {
  const [teams, setTeams] = useState<TeamType[]>(initialTeams);
  const [teamStats, setTeamStats] = useState<TeamStats[]>(initialTeamStats);
  const [editingTeam, setEditingTeam] = useState<TeamType | null>(null);
  const [teamFormData, setTeamFormData] = useState<TeamFormData>({
    name: "",
    direction: "",
  });
  const [isSubmitting, setIsSubmitting] = useState(false);
  const { toast } = useToast();

  const resetForm = () => {
    setTeamFormData({ name: "", direction: "" });
    setEditingTeam(null);
  };

  const getTeamStats = (teamId: string): TeamStats | undefined => {
    return teamStats.find((stats) => stats.teamId === teamId);
  };

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

    try {
      setIsSubmitting(true);
      const newTeam = await adminClient.createTeam(teamFormData);
      toast({
        title: "Succès",
        description: "Équipe créée avec succès",
      });

      resetForm();

      // Mettre à jour l'état local avec la nouvelle équipe
      const newLocalTeam: TeamType = {
        id: newTeam.id,
        name: newTeam.name,
        direction: newTeam.direction,
      };
      setTeams((prev) => [...prev, newLocalTeam]);

      // Ajouter les stats de la nouvelle équipe (avec les propriétés minimales)
      const newTeamStats = {
        teamId: newTeam.id,
        teamName: newTeam.name,
        direction: newTeam.direction,
        totalMembers: 0,
        averageSkillLevel: 0,
        skillCoverage: 0,
        topSkills: [],
        members: [],
      } as TeamStats;
      setTeamStats((prev) => [...prev, newTeamStats]);
      return true;
    } catch (error: any) {
      toast({
        title: "Erreur",
        description: error.message || "Erreur lors de la création de l'équipe",
        variant: "destructive",
      });
      return false;
    } finally {
      setIsSubmitting(false);
    }
  };

  const handleEditTeam = (team: TeamType) => {
    setEditingTeam(team);
    setTeamFormData({
      name: team.name,
      direction: team.direction,
    });
  };

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

    try {
      setIsSubmitting(true);
      await adminClient.updateTeam({
        id: editingTeam.id,
        ...teamFormData,
        memberCount: (editingTeam as any).memberCount || 0,
      });

      toast({
        title: "Succès",
        description: "Équipe mise à jour avec succès",
      });

      resetForm();
      return true;
    } catch (error: any) {
      toast({
        title: "Erreur",
        description:
          error.message || "Erreur lors de la mise à jour de l'équipe",
        variant: "destructive",
      });
      return false;
    } finally {
      setIsSubmitting(false);
    }
  };

  const handleDeleteTeam = async (teamId: string) => {
    const team = teams.find((t) => t.id === teamId);
    const stats = getTeamStats(teamId);

    if (stats && stats.totalMembers > 0) {
      toast({
        title: "Erreur",
        description:
          "Impossible de supprimer une équipe qui contient des membres",
        variant: "destructive",
      });
      return;
    }

    if (
      confirm(
        `Êtes-vous sûr de vouloir supprimer l'équipe "${team?.name}" ? Cette action est irréversible.`
      )
    ) {
      try {
        await adminClient.deleteTeam(teamId);
        toast({
          title: "Succès",
          description: "Équipe supprimée avec succès",
        });

        // Mettre à jour l'état local au lieu de recharger la page
        setTeams((prev) => prev.filter((t) => t.id !== teamId));
        setTeamStats((prev) => prev.filter((stats) => stats.teamId !== teamId));
      } catch (error: any) {
        toast({
          title: "Erreur",
          description:
            error.message || "Erreur lors de la suppression de l'équipe",
          variant: "destructive",
        });
      }
    }
  };

  const handleDeleteDirection = async (direction: string) => {
    // Vérifier si des équipes de cette direction ont des membres
    const teamsInDirection = teams.filter(
      (team) => team.direction === direction
    );
    const hasMembers = teamsInDirection.some((team) => {
      const stats = getTeamStats(team.id);
      return stats && stats.totalMembers > 0;
    });

    if (hasMembers) {
      toast({
        title: "Erreur",
        description: `Impossible de supprimer la direction "${direction}" car certaines équipes ont des membres`,
        variant: "destructive",
      });
      return;
    }

    if (
      confirm(
        `Êtes-vous sûr de vouloir supprimer la direction "${direction}" et TOUTES ses équipes ?\n\n⚠️ Cette action est irréversible !\n\nÉquipes qui seront supprimées :\n${teamsInDirection
          .map((t) => `• ${t.name}`)
          .join("\n")}`
      )
    ) {
      try {
        await adminClient.deleteDirection(direction);
        toast({
          title: "Succès",
          description: `Direction "${direction}" et toutes ses équipes supprimées avec succès`,
          variant: "default",
        });

        // Mettre à jour l'état local au lieu de recharger la page
        setTeams((prev) => prev.filter((team) => team.direction !== direction));
        setTeamStats((prev) =>
          prev.filter((stats) => stats.direction !== direction)
        );
      } catch (error: any) {
        toast({
          title: "Erreur",
          description:
            error.message || "Erreur lors de la suppression de la direction",
          variant: "destructive",
        });
      }
    }
  };

  // Extraire les directions uniques pour les formulaires
  const directions = Array.from(new Set(teams.map((team) => team.direction)));

  // Calculer les stats par direction
  const getDirectionStats = (direction: string) => {
    const teamsInDirection = teams.filter(
      (team) => team.direction === direction
    );
    const totalMembers = teamsInDirection.reduce((total, team) => {
      const stats = getTeamStats(team.id);
      return total + (stats?.totalMembers || 0);
    }, 0);

    return {
      direction,
      totalMembers,
      hasMembers: totalMembers > 0,
    };
  };

  return {
    teams,
    teamStats,
    editingTeam,
    teamFormData,
    isSubmitting,
    directions,
    setTeamFormData,
    resetForm,
    getTeamStats,
    getDirectionStats,
    handleCreateTeam,
    handleEditTeam,
    handleUpdateTeam,
    handleDeleteTeam,
    handleDeleteDirection,
  };
}