package com.lions.dev.service;

import com.lions.dev.entity.friends.Friendship;
import com.lions.dev.entity.friends.FriendshipStatus;
import com.lions.dev.entity.users.Users;
import com.lions.dev.exception.FriendshipNotFoundException;
import com.lions.dev.exception.UserNotFoundException;
import com.lions.dev.repository.FriendshipRepository;
import com.lions.dev.repository.UsersRepository;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;
import java.util.List;
import java.util.Optional;
import java.util.UUID;

/**
 * Service de gestion des amitiés. Ce service gère l'envoi, l'acceptation, le rejet et la
 * suppression d'amitiés.
 */
@ApplicationScoped
public class FriendshipService {

  @Inject FriendshipRepository friendshipRepository;

  @Inject UsersRepository usersRepository;

  /**
   * Envoie une demande d'amitié entre deux utilisateurs.
   *
   * @param userId L'ID de l'utilisateur qui envoie la demande.
   * @param friendId L'ID de l'utilisateur qui reçoit la demande.
   * @return La relation d'amitié créée.
   * @throws UserNotFoundException Si l'un des utilisateurs n'est pas trouvé.
   */
  @Transactional
  public Friendship sendFriendRequest(UUID userId, UUID friendId) {
    System.out.println(
        "[LOG] Envoi de demande d'amitié de l'utilisateur "
            + userId
            + " à l'utilisateur "
            + friendId);

    Users user = usersRepository.findById(userId);
    Users friend = usersRepository.findById(friendId);

    if (user == null || friend == null) {
      System.out.println(
          "[ERROR] Utilisateur non trouvé pour l'ID : " + (user == null ? userId : friendId));
      throw new UserNotFoundException("L'utilisateur avec l'ID spécifié n'existe pas.");
    }

    Optional<Friendship> existingFriendship = friendshipRepository.findByUsers(user, friend);
    if (existingFriendship.isPresent()) {
      System.out.println("[ERROR] Une relation d'amitié existe déjà entre ces deux utilisateurs.");
      throw new IllegalArgumentException("Relation d'amitié déjà existante.");
    }

    Friendship friendship =
        Friendship.builder().user(user).friend(friend).status(FriendshipStatus.PENDING).build();

    friendshipRepository.persist(friendship);
    System.out.println(
        "[LOG] Demande d'amitié envoyée de " + user.getEmail() + " à " + friend.getEmail());

    return friendship;
  }

  /**
   * Accepte une demande d'amitié.
   *
   * @param friendshipId L'ID de la demande d'amitié.
   * @return La relation d'amitié acceptée.
   * @throws FriendshipNotFoundException Si la relation d'amitié n'est pas trouvée.
   */
  @Transactional
  public Friendship acceptFriendRequest(UUID friendshipId) {
    System.out.println("[LOG] Acceptation de la demande d'amitié avec l'ID : " + friendshipId);

    Friendship friendship =
        friendshipRepository
            .findById(friendshipId)
            .orElseThrow(() -> new FriendshipNotFoundException("Demande d'amitié introuvable."));

    if (friendship.getStatus() == FriendshipStatus.ACCEPTED) {
      System.out.println("[ERROR] La demande d'amitié a déjà été acceptée.");
      throw new IllegalArgumentException("Cette demande d'amitié a déjà été acceptée.");
    }

    friendship.setStatus(FriendshipStatus.ACCEPTED);
    friendshipRepository.persist(friendship);
    System.out.println(
        "[LOG] Demande d'amitié acceptée entre "
            + friendship.getUser().getEmail()
            + " et "
            + friendship.getFriend().getEmail());

    return friendship;
  }

  /**
   * Rejette une demande d'amitié.
   *
   * @param friendshipId L'ID de la demande d'amitié.
   * @throws FriendshipNotFoundException Si la relation d'amitié n'est pas trouvée.
   */
  @Transactional
  public void rejectFriendRequest(UUID friendshipId) {
    System.out.println("[LOG] Rejet de la demande d'amitié avec l'ID : " + friendshipId);

    Friendship friendship =
        friendshipRepository
            .findById(friendshipId)
            .orElseThrow(() -> new FriendshipNotFoundException("Demande d'amitié introuvable."));

    friendship.setStatus(FriendshipStatus.REJECTED);
    friendshipRepository.persist(friendship);
    System.out.println(
        "[LOG] Demande d'amitié rejetée entre "
            + friendship.getUser().getEmail()
            + " et "
            + friendship.getFriend().getEmail());
  }

  /**
   * Supprime une relation d'amitié.
   *
   * @param friendshipId L'ID de la relation d'amitié à supprimer.
   * @throws FriendshipNotFoundException Si la relation d'amitié n'est pas trouvée.
   */
  @Transactional
  public void removeFriend(UUID friendshipId) {
    System.out.println("[LOG] Suppression de la relation d'amitié avec l'ID : " + friendshipId);

    Friendship friendship =
        friendshipRepository
            .findById(friendshipId)
            .orElseThrow(() -> new FriendshipNotFoundException("Amitié introuvable."));

    friendshipRepository.deleteFriendship(friendship); // Appel à deleteFriendship
    System.out.println(
        "[LOG] Amitié supprimée entre "
        + friendship.getUser().getEmail()
        + " et "
        + friendship.getFriend().getEmail());
  }

  /**
   * Récupère la liste des amis d'un utilisateur avec pagination.
   *
   * @param userId L'ID de l'utilisateur.
   * @param page Le numéro de la page à récupérer.
   * @param size Le nombre d'éléments par page.
   * @return La liste paginée des relations d'amitié.
   * @throws UserNotFoundException Si l'utilisateur n'est pas trouvé.
   */
  public List<Friendship> listFriends(UUID userId, int page, int size) {
    System.out.println(
        "[LOG] Récupération de la liste paginée des amis pour l'utilisateur avec l'ID : " + userId);

    Users user = usersRepository.findById(userId);
    if (user == null) {
      System.out.println("[ERROR] Utilisateur non trouvé pour l'ID : " + userId);
      throw new UserNotFoundException("Utilisateur non trouvé.");
    }

    return friendshipRepository.findFriendsByUser(user, page, size);
  }

  /**
   * Récupère toutes les demandes d'amitié avec un statut spécifique.
   *
   * @param user L'utilisateur.
   * @param status Le statut des demandes d'amitié à récupérer (PENDING, ACCEPTED, REJECTED).
   * @param page Le numéro de la page à récupérer.
   * @param size Le nombre d'éléments par page.
   * @return La liste paginée des relations d'amitié avec le statut spécifié.
   */
  public List<Friendship> listFriendRequestsByStatus(Users user, FriendshipStatus status, int page, int size) {
    System.out.println("[LOG] Récupération des demandes d'amitié avec le statut : " + status);
    return friendshipRepository.findByUserAndStatus(user, status, page, size);
  }

}