package dev.lions.btpxpress.presentation.controller;

import dev.lions.btpxpress.application.service.EmployeService;
import dev.lions.btpxpress.domain.core.entity.Employe;
import dev.lions.btpxpress.domain.core.entity.StatutEmploye;
import jakarta.inject.Inject;
import jakarta.validation.Valid;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import java.time.LocalDate;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import org.eclipse.microprofile.openapi.annotations.tags.Tag;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/** Controller REST pour la gestion des employés */
@Path("/api/employes")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Tag(name = "Employés", description = "Gestion des employés")
public class EmployeController {

  private static final Logger logger = LoggerFactory.getLogger(EmployeController.class);

  @Inject EmployeService employeService;

  /** Récupère tous les employés */
  @GET
  public Response getAllEmployes() {
    try {
      List<Employe> employes = employeService.findAll();
      return Response.ok(employes).build();
    } catch (Exception e) {
      logger.error("Erreur lors de la récupération des employés", e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la récupération des employés"))
          .build();
    }
  }

  /** Récupère un employé par son ID */
  @GET
  @Path("/{id}")
  public Response getEmployeById(@PathParam("id") UUID id) {
    try {
      Optional<Employe> employeOpt = employeService.findById(id);
      if (employeOpt.isEmpty()) {
        return Response.status(Response.Status.NOT_FOUND)
            .entity(Map.of("error", "Employé non trouvé"))
            .build();
      }
      return Response.ok(employeOpt.get()).build();
    } catch (NotFoundException e) {
      return Response.status(Response.Status.NOT_FOUND)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (Exception e) {
      logger.error("Erreur lors de la récupération de l'employé: " + id, e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la récupération de l'employé"))
          .build();
    }
  }

  /** Récupère les employés par statut */
  @GET
  @Path("/statut/{statut}")
  public Response getEmployesByStatut(@PathParam("statut") StatutEmploye statut) {
    try {
      List<Employe> employes = employeService.findByStatut(statut);
      return Response.ok(employes).build();
    } catch (Exception e) {
      logger.error("Erreur lors de la récupération des employés par statut: " + statut, e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la récupération des employés"))
          .build();
    }
  }

  /** Récupère les employés actifs */
  @GET
  @Path("/actifs")
  public Response getEmployesActifs() {
    try {
      List<Employe> employes = employeService.findActifs();
      return Response.ok(employes).build();
    } catch (Exception e) {
      logger.error("Erreur lors de la récupération des employés actifs", e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la récupération des employés"))
          .build();
    }
  }

  /** Récupère un employé par email */
  @GET
  @Path("/email/{email}")
  public Response getEmployeByEmail(@PathParam("email") String email) {
    try {
      Optional<Employe> employeOpt = employeService.findByEmail(email);
      if (employeOpt.isEmpty()) {
        return Response.status(Response.Status.NOT_FOUND)
            .entity(Map.of("error", "Employé non trouvé"))
            .build();
      }
      return Response.ok(employeOpt.get()).build();
    } catch (Exception e) {
      logger.error("Erreur lors de la récupération de l'employé par email: " + email, e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la récupération de l'employé"))
          .build();
    }
  }

  /** Recherche des employés par nom ou prénom */
  @GET
  @Path("/search/nom")
  public Response searchEmployesByNom(@QueryParam("nom") String searchTerm) {
    try {
      if (searchTerm == null || searchTerm.trim().isEmpty()) {
        return Response.status(Response.Status.BAD_REQUEST)
            .entity(Map.of("error", "Terme de recherche requis"))
            .build();
      }
      List<Employe> employes = employeService.searchByNom(searchTerm);
      return Response.ok(employes).build();
    } catch (Exception e) {
      logger.error("Erreur lors de la recherche par nom: " + searchTerm, e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la recherche"))
          .build();
    }
  }

  /** Récupère les employés par métier */
  @GET
  @Path("/metier/{metier}")
  public Response getEmployesByMetier(@PathParam("metier") String metier) {
    try {
      List<Employe> employes = employeService.findByMetier(metier);
      return Response.ok(employes).build();
    } catch (Exception e) {
      logger.error("Erreur lors de la récupération des employés par métier: " + metier, e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la récupération des employés"))
          .build();
    }
  }

  /** Récupère les employés par équipe */
  @GET
  @Path("/equipe/{equipeId}")
  public Response getEmployesByEquipe(@PathParam("equipeId") UUID equipeId) {
    try {
      List<Employe> employes = employeService.findByEquipe(equipeId);
      return Response.ok(employes).build();
    } catch (Exception e) {
      logger.error("Erreur lors de la récupération des employés par équipe: " + equipeId, e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la récupération des employés"))
          .build();
    }
  }

  /** Récupère les employés disponibles pour une période */
  @GET
  @Path("/disponibles")
  public Response getEmployesDisponibles(
      @QueryParam("dateDebut") String dateDebut, @QueryParam("dateFin") String dateFin) {
    try {
      List<Employe> employes = employeService.findDisponibles(dateDebut, dateFin);
      return Response.ok(employes).build();
    } catch (Exception e) {
      logger.error("Erreur lors de la récupération des employés disponibles", e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la récupération des employés"))
          .build();
    }
  }

  /** Récupère les employés avec certifications */
  @GET
  @Path("/avec-certifications")
  public Response getEmployesAvecCertifications() {
    try {
      List<Employe> employes = employeService.findAvecCertifications();
      return Response.ok(employes).build();
    } catch (Exception e) {
      logger.error("Erreur lors de la récupération des employés avec certifications", e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la récupération des employés"))
          .build();
    }
  }

  /** Récupère les employés par niveau d'expérience */
  @GET
  @Path("/experience/{niveau}")
  public Response getEmployesByExperience(@PathParam("niveau") String niveau) {
    try {
      List<Employe> employes = employeService.findByNiveauExperience(niveau);
      return Response.ok(employes).build();
    } catch (Exception e) {
      logger.error("Erreur lors de la récupération des employés par expérience: " + niveau, e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la récupération des employés"))
          .build();
    }
  }

  /** Crée un nouveau employé */
  @POST
  public Response createEmploye(@Valid Employe employe) {
    try {
      Employe nouvelEmploye = employeService.create(employe);
      return Response.status(Response.Status.CREATED).entity(nouvelEmploye).build();
    } catch (IllegalArgumentException e) {
      return Response.status(Response.Status.BAD_REQUEST)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (Exception e) {
      logger.error("Erreur lors de la création de l'employé", e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la création de l'employé"))
          .build();
    }
  }

  /** Met à jour un employé */
  @PUT
  @Path("/{id}")
  public Response updateEmploye(@PathParam("id") UUID id, @Valid Employe employeData) {
    try {
      Employe employe = employeService.update(id, employeData);
      return Response.ok(employe).build();
    } catch (NotFoundException e) {
      return Response.status(Response.Status.NOT_FOUND)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (IllegalArgumentException e) {
      return Response.status(Response.Status.BAD_REQUEST)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (Exception e) {
      logger.error("Erreur lors de la mise à jour de l'employé: " + id, e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la mise à jour de l'employé"))
          .build();
    }
  }

  /** Active un employé */
  @POST
  @Path("/{id}/activer")
  public Response activerEmploye(@PathParam("id") UUID id) {
    try {
      Employe employe = employeService.activerEmploye(id);
      return Response.ok(employe).build();
    } catch (NotFoundException e) {
      return Response.status(Response.Status.NOT_FOUND)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (Exception e) {
      logger.error("Erreur lors de l'activation de l'employé: " + id, e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de l'activation de l'employé"))
          .build();
    }
  }

  /** Désactive un employé */
  @POST
  @Path("/{id}/desactiver")
  public Response desactiverEmploye(@PathParam("id") UUID id, Map<String, String> payload) {
    try {
      String motif = payload != null ? payload.get("motif") : null;
      Employe employe = employeService.desactiverEmploye(id, motif);
      return Response.ok(employe).build();
    } catch (NotFoundException e) {
      return Response.status(Response.Status.NOT_FOUND)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (Exception e) {
      logger.error("Erreur lors de la désactivation de l'employé: " + id, e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la désactivation de l'employé"))
          .build();
    }
  }

  /** Affecte un employé à une équipe */
  @POST
  @Path("/{id}/affecter-equipe")
  public Response affecterEquipe(@PathParam("id") UUID employeId, Map<String, Object> payload) {
    try {
      UUID equipeId =
          payload.get("equipeId") != null
              ? UUID.fromString(payload.get("equipeId").toString())
              : null;

      Employe employe = employeService.affecterEquipe(employeId, equipeId);
      return Response.ok(employe).build();
    } catch (NotFoundException e) {
      return Response.status(Response.Status.NOT_FOUND)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (IllegalArgumentException e) {
      return Response.status(Response.Status.BAD_REQUEST)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (Exception e) {
      logger.error("Erreur lors de l'affectation d'équipe: " + employeId, e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de l'affectation d'équipe"))
          .build();
    }
  }

  /** Supprime un employé */
  @DELETE
  @Path("/{id}")
  public Response deleteEmploye(@PathParam("id") UUID id) {
    try {
      employeService.delete(id);
      return Response.noContent().build();
    } catch (NotFoundException e) {
      return Response.status(Response.Status.NOT_FOUND)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (IllegalStateException e) {
      return Response.status(Response.Status.BAD_REQUEST)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (Exception e) {
      logger.error("Erreur lors de la suppression de l'employé: " + id, e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la suppression de l'employé"))
          .build();
    }
  }

  /** Recherche d'employés par multiple critères */
  @GET
  @Path("/search")
  public Response searchEmployes(@QueryParam("term") String searchTerm) {
    try {
      if (searchTerm == null || searchTerm.trim().isEmpty()) {
        return Response.status(Response.Status.BAD_REQUEST)
            .entity(Map.of("error", "Terme de recherche requis"))
            .build();
      }
      List<Employe> employes = employeService.searchEmployes(searchTerm);
      return Response.ok(employes).build();
    } catch (Exception e) {
      logger.error("Erreur lors de la recherche d'employés: " + searchTerm, e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la recherche"))
          .build();
    }
  }

  /** Récupère les statistiques des employés */
  @GET
  @Path("/statistiques")
  public Response getStatistiques() {
    try {
      Map<String, Object> stats = employeService.getStatistiques();
      return Response.ok(stats).build();
    } catch (Exception e) {
      logger.error("Erreur lors de la récupération des statistiques", e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la récupération des statistiques"))
          .build();
    }
  }

  /** Récupère le planning d'un employé */
  @GET
  @Path("/{id}/planning")
  public Response getPlanningEmploye(
      @PathParam("id") UUID id,
      @QueryParam("dateDebut") String dateDebut,
      @QueryParam("dateFin") String dateFin) {
    try {
      LocalDate debut = LocalDate.parse(dateDebut);
      LocalDate fin = LocalDate.parse(dateFin);
      List<Object> planning = employeService.getPlanningEmploye(id, debut, fin);
      return Response.ok(planning).build();
    } catch (NotFoundException e) {
      return Response.status(Response.Status.NOT_FOUND)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (Exception e) {
      logger.error("Erreur lors de la récupération du planning: " + id, e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la récupération du planning"))
          .build();
    }
  }

  /** Récupère les compétences d'un employé */
  @GET
  @Path("/{id}/competences")
  public Response getCompetencesEmploye(@PathParam("id") UUID id) {
    try {
      List<Object> competences = employeService.getCompetencesEmploye(id);
      return Response.ok(competences).build();
    } catch (NotFoundException e) {
      return Response.status(Response.Status.NOT_FOUND)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (Exception e) {
      logger.error("Erreur lors de la récupération des compétences: " + id, e);
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur lors de la récupération des compétences"))
          .build();
    }
  }
}