import { UserEvaluation, UserProfile, SkillLevel, Team } from "../lib/types";

export class ApiClient {
  private baseUrl: string;

  constructor() {
    this.baseUrl = process.env.NEXT_PUBLIC_API_URL || "";
  }

  /**
   * Charge une évaluation utilisateur depuis l'API
   */
  async loadUserEvaluation(
    profile: UserProfile
  ): Promise<UserEvaluation | null> {
    try {
      const params = new URLSearchParams({
        firstName: profile.firstName,
        lastName: profile.lastName,
        teamId: profile.teamId,
      });

      const response = await fetch(`${this.baseUrl}/api/evaluations?${params}`);

      if (!response.ok) {
        throw new Error("Erreur lors du chargement de l'évaluation");
      }

      const data = await response.json();
      return data.evaluation;
    } catch (error) {
      console.error("Erreur lors du chargement de l'évaluation:", error);
      return null;
    }
  }

  /**
   * Sauvegarde une évaluation utilisateur via l'API
   */
  async saveUserEvaluation(evaluation: UserEvaluation): Promise<void> {
    try {
      const response = await fetch(`${this.baseUrl}/api/evaluations`, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ evaluation }),
      });

      if (!response.ok) {
        throw new Error("Erreur lors de la sauvegarde de l'évaluation");
      }
    } catch (error) {
      console.error("Erreur lors de la sauvegarde de l'évaluation:", error);
      throw error;
    }
  }

  /**
   * Met à jour le niveau d'une skill
   */
  async updateSkillLevel(
    profile: UserProfile,
    category: string,
    skillId: string,
    level: SkillLevel
  ): Promise<void> {
    await this.updateSkill(profile, category, skillId, {
      action: "updateLevel",
      level,
    });
  }

  /**
   * Met à jour le statut de mentorat d'une skill
   */
  async updateSkillMentorStatus(
    profile: UserProfile,
    category: string,
    skillId: string,
    canMentor: boolean
  ): Promise<void> {
    await this.updateSkill(profile, category, skillId, {
      action: "updateMentorStatus",
      canMentor,
    });
  }

  /**
   * Met à jour le statut d'apprentissage d'une skill
   */
  async updateSkillLearningStatus(
    profile: UserProfile,
    category: string,
    skillId: string,
    wantsToLearn: boolean
  ): Promise<void> {
    await this.updateSkill(profile, category, skillId, {
      action: "updateLearningStatus",
      wantsToLearn,
    });
  }

  /**
   * Ajoute une skill à l'évaluation
   */
  async addSkillToEvaluation(
    profile: UserProfile,
    category: string,
    skillId: string
  ): Promise<void> {
    await this.updateSkill(profile, category, skillId, {
      action: "addSkill",
    });
  }

  /**
   * Supprime une skill de l'évaluation
   */
  async removeSkillFromEvaluation(
    profile: UserProfile,
    category: string,
    skillId: string
  ): Promise<void> {
    await this.updateSkill(profile, category, skillId, {
      action: "removeSkill",
    });
  }

  /**
   * Méthode utilitaire pour mettre à jour une skill
   */
  private async updateSkill(
    profile: UserProfile,
    category: string,
    skillId: string,
    options: {
      action:
        | "updateLevel"
        | "updateMentorStatus"
        | "updateLearningStatus"
        | "addSkill"
        | "removeSkill";
      level?: SkillLevel;
      canMentor?: boolean;
      wantsToLearn?: boolean;
    }
  ): Promise<void> {
    try {
      const response = await fetch(`${this.baseUrl}/api/evaluations/skills`, {
        method: "PUT",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          profile,
          category,
          skillId,
          ...options,
        }),
      });

      if (!response.ok) {
        throw new Error("Erreur lors de la mise à jour de la skill");
      }
    } catch (error) {
      console.error("Erreur lors de la mise à jour de la skill:", error);
      throw error;
    }
  }

  /**
   * Charge toutes les équipes
   */
  async loadTeams(): Promise<Team[]> {
    try {
      const response = await fetch(`${this.baseUrl}/api/teams`);

      if (!response.ok) {
        throw new Error("Erreur lors du chargement des équipes");
      }

      return await response.json();
    } catch (error) {
      console.error("Erreur lors du chargement des équipes:", error);
      return [];
    }
  }

  /**
   * Charge une équipe par ID
   */
  async loadTeamById(teamId: string): Promise<Team | null> {
    try {
      const response = await fetch(`${this.baseUrl}/api/teams/${teamId}`);

      if (!response.ok) {
        if (response.status === 404) {
          return null;
        }
        throw new Error("Erreur lors du chargement de l'équipe");
      }

      return await response.json();
    } catch (error) {
      console.error("Erreur lors du chargement de l'équipe:", error);
      return null;
    }
  }

  /**
   * Charge les équipes par direction
   */
  async loadTeamsByDirection(direction: string): Promise<Team[]> {
    try {
      const response = await fetch(
        `${this.baseUrl}/api/teams/direction/${direction}`
      );

      if (!response.ok) {
        throw new Error("Erreur lors du chargement des équipes par direction");
      }

      return await response.json();
    } catch (error) {
      console.error(
        "Erreur lors du chargement des équipes par direction:",
        error
      );
      return [];
    }
  }

  /**
   * Charge toutes les directions
   */
  async loadDirections(): Promise<string[]> {
    try {
      const response = await fetch(`${this.baseUrl}/api/teams/directions`);

      if (!response.ok) {
        throw new Error("Erreur lors du chargement des directions");
      }

      return await response.json();
    } catch (error) {
      console.error("Erreur lors du chargement des directions:", error);
      return [];
    }
  }

  /**
   * Crée une nouvelle équipe
   */
  async createTeam(
    team: Omit<Team, "created_at" | "updated_at">
  ): Promise<Team | null> {
    try {
      const response = await fetch(`${this.baseUrl}/api/teams`, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify(team),
      });

      if (!response.ok) {
        throw new Error("Erreur lors de la création de l'équipe");
      }

      return await response.json();
    } catch (error) {
      console.error("Erreur lors de la création de l'équipe:", error);
      return null;
    }
  }

  /**
   * Met à jour une équipe
   */
  async updateTeam(
    teamId: string,
    updates: Partial<Omit<Team, "id">>
  ): Promise<Team | null> {
    try {
      const response = await fetch(`${this.baseUrl}/api/teams/${teamId}`, {
        method: "PUT",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify(updates),
      });

      if (!response.ok) {
        throw new Error("Erreur lors de la mise à jour de l'équipe");
      }

      return await response.json();
    } catch (error) {
      console.error("Erreur lors de la mise à jour de l'équipe:", error);
      return null;
    }
  }

  /**
   * Supprime une équipe
   */
  async deleteTeam(teamId: string): Promise<boolean> {
    try {
      const response = await fetch(`${this.baseUrl}/api/teams/${teamId}`, {
        method: "DELETE",
      });

      if (!response.ok) {
        throw new Error("Erreur lors de la suppression de l'équipe");
      }

      return true;
    } catch (error) {
      console.error("Erreur lors de la suppression de l'équipe:", error);
      return false;
    }
  }
}

// Instance singleton
export const apiClient = new ApiClient();