package dev.lions.unionflow.server.resource;

import dev.lions.unionflow.server.api.dto.notification.NotificationDTO;
import dev.lions.unionflow.server.api.dto.notification.TemplateNotificationDTO;
import dev.lions.unionflow.server.service.NotificationService;
import jakarta.annotation.security.RolesAllowed;
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.util.List;
import java.util.Map;
import java.util.UUID;
import org.jboss.logging.Logger;

/**
 * Resource REST pour la gestion des notifications
 *
 * @author UnionFlow Team
 * @version 3.0
 * @since 2025-01-29
 */
@Path("/api/notifications")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@RolesAllowed({"ADMIN", "MEMBRE", "USER"})
public class NotificationResource {

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

  @Inject NotificationService notificationService;

  // ========================================
  // TEMPLATES
  // ========================================

  /**
   * Crée un nouveau template de notification
   *
   * @param templateDTO DTO du template à créer
   * @return Template créé
   */
  @POST
  @RolesAllowed({"ADMIN", "MEMBRE"})
  @Path("/templates")
  public Response creerTemplate(@Valid TemplateNotificationDTO templateDTO) {
    try {
      TemplateNotificationDTO result = notificationService.creerTemplate(templateDTO);
      return Response.status(Response.Status.CREATED).entity(result).build();
    } catch (IllegalArgumentException e) {
      return Response.status(Response.Status.BAD_REQUEST)
          .entity(new ErrorResponse(e.getMessage()))
          .build();
    } catch (Exception e) {
      LOG.errorf(e, "Erreur lors de la création du template");
      return Response.status(Response.Status.BAD_REQUEST)
          .entity(new ErrorResponse("Erreur lors de la création du template: " + e.getMessage()))
          .build();
    }
  }

  // ========================================
  // NOTIFICATIONS
  // ========================================

  /**
   * Crée une nouvelle notification
   *
   * @param notificationDTO DTO de la notification à créer
   * @return Notification créée
   */
  @POST
  @RolesAllowed({"ADMIN", "MEMBRE"})
  public Response creerNotification(@Valid NotificationDTO notificationDTO) {
    try {
      NotificationDTO result = notificationService.creerNotification(notificationDTO);
      return Response.status(Response.Status.CREATED).entity(result).build();
    } catch (Exception e) {
      LOG.errorf(e, "Erreur lors de la création de la notification");
      return Response.status(Response.Status.BAD_REQUEST)
          .entity(new ErrorResponse("Erreur lors de la création de la notification: " + e.getMessage()))
          .build();
    }
  }

  /**
   * Marque une notification comme lue
   *
   * @param id ID de la notification
   * @return Notification mise à jour
   */
  @POST
  @RolesAllowed({"ADMIN", "MEMBRE"})
  @Path("/{id}/marquer-lue")
  public Response marquerCommeLue(@PathParam("id") UUID id) {
    try {
      NotificationDTO result = notificationService.marquerCommeLue(id);
      return Response.ok(result).build();
    } catch (jakarta.ws.rs.NotFoundException e) {
      return Response.status(Response.Status.NOT_FOUND)
          .entity(new ErrorResponse("Notification non trouvée"))
          .build();
    } catch (Exception e) {
      LOG.errorf(e, "Erreur lors du marquage de la notification");
      return Response.status(Response.Status.BAD_REQUEST)
          .entity(new ErrorResponse("Erreur lors du marquage de la notification: " + e.getMessage()))
          .build();
    }
  }

  /**
   * Trouve une notification par son ID
   *
   * @param id ID de la notification
   * @return Notification
   */
  @GET
  @Path("/{id}")
  public Response trouverNotificationParId(@PathParam("id") UUID id) {
    try {
      NotificationDTO result = notificationService.trouverNotificationParId(id);
      return Response.ok(result).build();
    } catch (jakarta.ws.rs.NotFoundException e) {
      return Response.status(Response.Status.NOT_FOUND)
          .entity(new ErrorResponse("Notification non trouvée"))
          .build();
    } catch (Exception e) {
      LOG.errorf(e, "Erreur lors de la recherche de la notification");
      return Response.status(Response.Status.BAD_REQUEST)
          .entity(new ErrorResponse("Erreur lors de la recherche de la notification: " + e.getMessage()))
          .build();
    }
  }

  /**
   * Liste toutes les notifications d'un membre
   *
   * @param membreId ID du membre
   * @return Liste des notifications
   */
  @GET
  @Path("/membre/{membreId}")
  public Response listerNotificationsParMembre(@PathParam("membreId") UUID membreId) {
    try {
      List<NotificationDTO> result = notificationService.listerNotificationsParMembre(membreId);
      return Response.ok(result).build();
    } catch (Exception e) {
      LOG.errorf(e, "Erreur lors de la liste des notifications");
      return Response.status(Response.Status.BAD_REQUEST)
          .entity(new ErrorResponse("Erreur lors de la liste des notifications: " + e.getMessage()))
          .build();
    }
  }

  /**
   * Liste les notifications non lues d'un membre
   *
   * @param membreId ID du membre
   * @return Liste des notifications non lues
   */
  @GET
  @Path("/membre/{membreId}/non-lues")
  public Response listerNotificationsNonLuesParMembre(@PathParam("membreId") UUID membreId) {
    try {
      List<NotificationDTO> result = notificationService.listerNotificationsNonLuesParMembre(membreId);
      return Response.ok(result).build();
    } catch (Exception e) {
      LOG.errorf(e, "Erreur lors de la liste des notifications non lues");
      return Response.status(Response.Status.BAD_REQUEST)
          .entity(
              new ErrorResponse(
                  "Erreur lors de la liste des notifications non lues: " + e.getMessage()))
          .build();
    }
  }

  /**
   * Liste les notifications en attente d'envoi
   *
   * @return Liste des notifications en attente
   */
  @GET
  @Path("/en-attente-envoi")
  public Response listerNotificationsEnAttenteEnvoi() {
    try {
      List<NotificationDTO> result = notificationService.listerNotificationsEnAttenteEnvoi();
      return Response.ok(result).build();
    } catch (Exception e) {
      LOG.errorf(e, "Erreur lors de la liste des notifications en attente");
      return Response.status(Response.Status.BAD_REQUEST)
          .entity(
              new ErrorResponse(
                  "Erreur lors de la liste des notifications en attente: " + e.getMessage()))
          .build();
    }
  }

  /**
   * Envoie des notifications groupées à plusieurs membres (WOU/DRY)
   *
   * @param request DTO contenant les IDs des membres, sujet, corps et canaux
   * @return Nombre de notifications créées
   */
  @POST
  @RolesAllowed({"ADMIN", "MEMBRE"})
  @Path("/groupees")
  public Response envoyerNotificationsGroupees(NotificationGroupeeRequest request) {
    try {
      int notificationsCreees =
          notificationService.envoyerNotificationsGroupees(
              request.membreIds, request.sujet, request.corps, request.canaux);
      return Response.ok(Map.of("notificationsCreees", notificationsCreees)).build();
    } catch (IllegalArgumentException e) {
      return Response.status(Response.Status.BAD_REQUEST)
          .entity(new ErrorResponse(e.getMessage()))
          .build();
    } catch (Exception e) {
      LOG.errorf(e, "Erreur lors de l'envoi des notifications groupées");
      return Response.status(Response.Status.BAD_REQUEST)
          .entity(
              new ErrorResponse(
                  "Erreur lors de l'envoi des notifications groupées: " + e.getMessage()))
          .build();
    }
  }

  /** Classe interne pour les réponses d'erreur */
  public static class ErrorResponse {
    public String error;

    public ErrorResponse(String error) {
      this.error = error;
    }
  }

  /** Classe interne pour les requêtes de notifications groupées (WOU/DRY) */
  public static class NotificationGroupeeRequest {
    public List<UUID> membreIds;
    public String sujet;
    public String corps;
    public List<String> canaux;

    public NotificationGroupeeRequest() {}
  }
}
