package dev.lions.unionflow.server.resource;

import dev.lions.unionflow.server.api.dto.organisation.OrganisationDTO;
import dev.lions.unionflow.server.entity.Organisation;
import dev.lions.unionflow.server.service.KeycloakService;
import dev.lions.unionflow.server.service.OrganisationService;
import io.quarkus.security.Authenticated;
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.net.URI;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;
import org.eclipse.microprofile.openapi.annotations.Operation;
import org.eclipse.microprofile.openapi.annotations.enums.SchemaType;
import org.eclipse.microprofile.openapi.annotations.media.Content;
import org.eclipse.microprofile.openapi.annotations.media.Schema;
import org.eclipse.microprofile.openapi.annotations.parameters.Parameter;
import org.eclipse.microprofile.openapi.annotations.responses.APIResponse;
import org.eclipse.microprofile.openapi.annotations.responses.APIResponses;
import org.eclipse.microprofile.openapi.annotations.tags.Tag;
import org.jboss.logging.Logger;

/**
 * Resource REST pour la gestion des organisations
 *
 * @author UnionFlow Team
 * @version 1.0
 * @since 2025-01-15
 */
@Path("/api/organisations")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Tag(name = "Organisations", description = "Gestion des organisations")
@Authenticated
public class OrganisationResource {

  private static final Logger LOG = Logger.getLogger(OrganisationResource.class);

  @Inject OrganisationService organisationService;

  @Inject KeycloakService keycloakService;

  /** Crée une nouvelle organisation */
  @POST
  @jakarta.annotation.security.PermitAll
  @Operation(
      summary = "Créer une nouvelle organisation",
      description = "Crée une nouvelle organisation dans le système")
  @APIResponses({
    @APIResponse(
        responseCode = "201",
        description = "Organisation créée avec succès",
        content =
            @Content(
                mediaType = MediaType.APPLICATION_JSON,
                schema = @Schema(implementation = OrganisationDTO.class))),
    @APIResponse(responseCode = "400", description = "Données invalides"),
    @APIResponse(responseCode = "409", description = "Organisation déjà existante"),
    @APIResponse(responseCode = "401", description = "Non authentifié"),
    @APIResponse(responseCode = "403", description = "Non autorisé")
  })
  public Response creerOrganisation(@Valid OrganisationDTO organisationDTO) {
    LOG.infof("Création d'une nouvelle organisation: %s", organisationDTO.getNom());

    try {
      Organisation organisation = organisationService.convertFromDTO(organisationDTO);
      Organisation organisationCreee = organisationService.creerOrganisation(organisation);
      OrganisationDTO dto = organisationService.convertToDTO(organisationCreee);

      return Response.created(URI.create("/api/organisations/" + organisationCreee.getId()))
          .entity(dto)
          .build();
    } catch (IllegalArgumentException e) {
      LOG.warnf("Erreur lors de la création de l'organisation: %s", e.getMessage());
      return Response.status(Response.Status.CONFLICT)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (Exception e) {
      LOG.errorf(e, "Erreur inattendue lors de la création de l'organisation");
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur interne du serveur"))
          .build();
    }
  }

  /** Récupère toutes les organisations actives */
  @GET
  @jakarta.annotation.security.PermitAll // ✅ Accès public pour inscription
  @Operation(
      summary = "Lister les organisations",
      description = "Récupère la liste des organisations actives avec pagination")
  @APIResponses({
    @APIResponse(
        responseCode = "200",
        description = "Liste des organisations récupérée avec succès",
        content =
            @Content(
                mediaType = MediaType.APPLICATION_JSON,
                schema = @Schema(type = SchemaType.ARRAY, implementation = OrganisationDTO.class))),
    @APIResponse(responseCode = "401", description = "Non authentifié"),
    @APIResponse(responseCode = "403", description = "Non autorisé")
  })
  public Response listerOrganisations(
      @Parameter(description = "Numéro de page (commence à 0)", example = "0")
          @QueryParam("page")
          @DefaultValue("0")
          int page,
      @Parameter(description = "Taille de la page", example = "20")
          @QueryParam("size")
          @DefaultValue("20")
          int size,
      @Parameter(description = "Terme de recherche (nom ou nom court)") @QueryParam("recherche")
          String recherche) {

    LOG.infof(
        "Récupération des organisations - page: %d, size: %d, recherche: %s",
        page, size, recherche);

    try {
      List<Organisation> organisations;

      if (recherche != null && !recherche.trim().isEmpty()) {
        organisations = organisationService.rechercherOrganisations(recherche.trim(), page, size);
      } else {
        organisations = organisationService.listerOrganisationsActives(page, size);
      }

      List<OrganisationDTO> dtos =
          organisations.stream()
              .map(organisationService::convertToDTO)
              .collect(Collectors.toList());

      return Response.ok(dtos).build();
    } catch (Exception e) {
      LOG.errorf(e, "Erreur lors de la récupération des organisations");
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur interne du serveur"))
          .build();
    }
  }

  /** Récupère une organisation par son ID */
  @GET
  @Path("/{id}")
  @jakarta.annotation.security.PermitAll
  @Operation(
      summary = "Récupérer une organisation",
      description = "Récupère une organisation par son ID")
  @APIResponses({
    @APIResponse(
        responseCode = "200",
        description = "Organisation trouvée",
        content =
            @Content(
                mediaType = MediaType.APPLICATION_JSON,
                schema = @Schema(implementation = OrganisationDTO.class))),
    @APIResponse(responseCode = "404", description = "Organisation non trouvée"),
    @APIResponse(responseCode = "401", description = "Non authentifié"),
    @APIResponse(responseCode = "403", description = "Non autorisé")
  })
  public Response obtenirOrganisation(
      @Parameter(description = "UUID de l'organisation", required = true) @PathParam("id") UUID id) {

    LOG.infof("Récupération de l'organisation ID: %d", id);

    return organisationService
        .trouverParId(id)
        .map(
            organisation -> {
              OrganisationDTO dto = organisationService.convertToDTO(organisation);
              return Response.ok(dto).build();
            })
        .orElse(
            Response.status(Response.Status.NOT_FOUND)
                .entity(Map.of("error", "Organisation non trouvée"))
                .build());
  }

  /** Met à jour une organisation */
  @PUT
  @Path("/{id}")
  @jakarta.annotation.security.PermitAll
  @Operation(
      summary = "Mettre à jour une organisation",
      description = "Met à jour les informations d'une organisation")
  @APIResponses({
    @APIResponse(
        responseCode = "200",
        description = "Organisation mise à jour avec succès",
        content =
            @Content(
                mediaType = MediaType.APPLICATION_JSON,
                schema = @Schema(implementation = OrganisationDTO.class))),
    @APIResponse(responseCode = "400", description = "Données invalides"),
    @APIResponse(responseCode = "404", description = "Organisation non trouvée"),
    @APIResponse(responseCode = "409", description = "Conflit de données"),
    @APIResponse(responseCode = "401", description = "Non authentifié"),
    @APIResponse(responseCode = "403", description = "Non autorisé")
  })
  public Response mettreAJourOrganisation(
      @Parameter(description = "UUID de l'organisation", required = true) @PathParam("id") UUID id,
      @Valid OrganisationDTO organisationDTO) {

    LOG.infof("Mise à jour de l'organisation ID: %s", id);

    try {
      Organisation organisationMiseAJour = organisationService.convertFromDTO(organisationDTO);
      Organisation organisation =
          organisationService.mettreAJourOrganisation(id, organisationMiseAJour, "system");
      OrganisationDTO dto = organisationService.convertToDTO(organisation);

      return Response.ok(dto).build();
    } catch (NotFoundException e) {
      return Response.status(Response.Status.NOT_FOUND)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (IllegalArgumentException e) {
      LOG.warnf("Erreur lors de la mise à jour de l'organisation: %s", e.getMessage());
      return Response.status(Response.Status.CONFLICT)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (Exception e) {
      LOG.errorf(e, "Erreur inattendue lors de la mise à jour de l'organisation");
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur interne du serveur"))
          .build();
    }
  }

  /** Supprime une organisation */
  @DELETE
  @Path("/{id}")
  @jakarta.annotation.security.PermitAll
  @Operation(
      summary = "Supprimer une organisation",
      description = "Supprime une organisation (soft delete)")
  @APIResponses({
    @APIResponse(responseCode = "204", description = "Organisation supprimée avec succès"),
    @APIResponse(responseCode = "404", description = "Organisation non trouvée"),
    @APIResponse(responseCode = "409", description = "Impossible de supprimer l'organisation"),
    @APIResponse(responseCode = "401", description = "Non authentifié"),
    @APIResponse(responseCode = "403", description = "Non autorisé")
  })
  public Response supprimerOrganisation(
      @Parameter(description = "UUID de l'organisation", required = true) @PathParam("id") UUID id) {

    LOG.infof("Suppression de l'organisation ID: %d", id);

    try {
      organisationService.supprimerOrganisation(id, "system");
      return Response.noContent().build();
    } catch (NotFoundException e) {
      return Response.status(Response.Status.NOT_FOUND)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (IllegalStateException e) {
      LOG.warnf("Erreur lors de la suppression de l'organisation: %s", e.getMessage());
      return Response.status(Response.Status.CONFLICT)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (Exception e) {
      LOG.errorf(e, "Erreur inattendue lors de la suppression de l'organisation");
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur interne du serveur"))
          .build();
    }
  }

  /** Recherche avancée d'organisations */
  @GET
  @Path("/recherche")
  @jakarta.annotation.security.PermitAll
  @Operation(
      summary = "Recherche avancée",
      description = "Recherche d'organisations avec critères multiples")
  @APIResponses({
    @APIResponse(
        responseCode = "200",
        description = "Résultats de recherche",
        content =
            @Content(
                mediaType = MediaType.APPLICATION_JSON,
                schema = @Schema(type = SchemaType.ARRAY, implementation = OrganisationDTO.class))),
    @APIResponse(responseCode = "401", description = "Non authentifié"),
    @APIResponse(responseCode = "403", description = "Non autorisé")
  })
  public Response rechercheAvancee(
      @Parameter(description = "Nom de l'organisation") @QueryParam("nom") String nom,
      @Parameter(description = "Type d'organisation") @QueryParam("type") String typeOrganisation,
      @Parameter(description = "Statut") @QueryParam("statut") String statut,
      @Parameter(description = "Ville") @QueryParam("ville") String ville,
      @Parameter(description = "Région") @QueryParam("region") String region,
      @Parameter(description = "Pays") @QueryParam("pays") String pays,
      @Parameter(description = "Numéro de page") @QueryParam("page") @DefaultValue("0") int page,
      @Parameter(description = "Taille de la page") @QueryParam("size") @DefaultValue("20")
          int size) {

    LOG.infof("Recherche avancée d'organisations avec critères multiples");

    try {
      List<Organisation> organisations =
          organisationService.rechercheAvancee(
              nom, typeOrganisation, statut, ville, region, pays, page, size);

      List<OrganisationDTO> dtos =
          organisations.stream()
              .map(organisationService::convertToDTO)
              .collect(Collectors.toList());

      return Response.ok(dtos).build();
    } catch (Exception e) {
      LOG.errorf(e, "Erreur lors de la recherche avancée");
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur interne du serveur"))
          .build();
    }
  }

  /** Active une organisation */
  @POST
  @Path("/{id}/activer")
  @jakarta.annotation.security.PermitAll
  @Operation(
      summary = "Activer une organisation",
      description = "Active une organisation suspendue")
  @APIResponses({
    @APIResponse(responseCode = "200", description = "Organisation activée avec succès"),
    @APIResponse(responseCode = "404", description = "Organisation non trouvée"),
    @APIResponse(responseCode = "401", description = "Non authentifié"),
    @APIResponse(responseCode = "403", description = "Non autorisé")
  })
  public Response activerOrganisation(
      @Parameter(description = "UUID de l'organisation", required = true) @PathParam("id") UUID id) {

    LOG.infof("Activation de l'organisation ID: %d", id);

    try {
      Organisation organisation = organisationService.activerOrganisation(id, "system");
      OrganisationDTO dto = organisationService.convertToDTO(organisation);
      return Response.ok(dto).build();
    } catch (NotFoundException e) {
      return Response.status(Response.Status.NOT_FOUND)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (Exception e) {
      LOG.errorf(e, "Erreur lors de l'activation de l'organisation");
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur interne du serveur"))
          .build();
    }
  }

  /** Suspend une organisation */
  @POST
  @Path("/{id}/suspendre")
  @jakarta.annotation.security.PermitAll
  @Operation(
      summary = "Suspendre une organisation",
      description = "Suspend une organisation active")
  @APIResponses({
    @APIResponse(responseCode = "200", description = "Organisation suspendue avec succès"),
    @APIResponse(responseCode = "404", description = "Organisation non trouvée"),
    @APIResponse(responseCode = "401", description = "Non authentifié"),
    @APIResponse(responseCode = "403", description = "Non autorisé")
  })
  public Response suspendreOrganisation(
      @Parameter(description = "UUID de l'organisation", required = true) @PathParam("id") UUID id) {

    LOG.infof("Suspension de l'organisation ID: %d", id);

    try {
      Organisation organisation = organisationService.suspendreOrganisation(id, "system");
      OrganisationDTO dto = organisationService.convertToDTO(organisation);
      return Response.ok(dto).build();
    } catch (NotFoundException e) {
      return Response.status(Response.Status.NOT_FOUND)
          .entity(Map.of("error", e.getMessage()))
          .build();
    } catch (Exception e) {
      LOG.errorf(e, "Erreur lors de la suspension de l'organisation");
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur interne du serveur"))
          .build();
    }
  }

  /** Obtient les statistiques des organisations */
  @GET
  @Path("/statistiques")
  @jakarta.annotation.security.PermitAll
  @Operation(
      summary = "Statistiques des organisations",
      description = "Récupère les statistiques globales des organisations")
  @APIResponses({
    @APIResponse(responseCode = "200", description = "Statistiques récupérées avec succès"),
    @APIResponse(responseCode = "401", description = "Non authentifié"),
    @APIResponse(responseCode = "403", description = "Non autorisé")
  })
  public Response obtenirStatistiques() {
    LOG.info("Récupération des statistiques des organisations");

    try {
      Map<String, Object> statistiques = organisationService.obtenirStatistiques();
      return Response.ok(statistiques).build();
    } catch (Exception e) {
      LOG.errorf(e, "Erreur lors de la récupération des statistiques");
      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
          .entity(Map.of("error", "Erreur interne du serveur"))
          .build();
    }
  }
}
