package com.gbcm.client.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.gbcm.server.api.dto.auth.LoginRequestDTO;
import com.gbcm.server.api.dto.auth.LoginResponseDTO;
import com.gbcm.server.api.dto.user.UserDTO;

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.ws.rs.client.Client;
import jakarta.ws.rs.client.ClientBuilder;
import jakarta.ws.rs.client.Entity;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;

/**
 * Client REST pour communiquer avec l'API GBCM Server
 * 
 * @author GBCM Team
 * @version 1.0.0
 * @since 2025-01-01
 */
@ApplicationScoped
public class GBCMServerClient {
    
    private static final Logger logger = LoggerFactory.getLogger(GBCMServerClient.class);
    
    private static final String BASE_URL = "http://localhost:8082/api";
    
    private final Client client;
    
    public GBCMServerClient() {
        this.client = ClientBuilder.newClient();
    }
    
    /**
     * Authentification utilisateur
     * 
     * @param loginRequest Données de connexion
     * @return Réponse d'authentification
     */
    public LoginResponseDTO login(LoginRequestDTO loginRequest) {
        try {
            logger.info("Tentative de connexion pour l'utilisateur: {}", loginRequest.getEmail());
            
            Response response = client
                .target(BASE_URL + "/auth/login")
                .request(MediaType.APPLICATION_JSON)
                .post(Entity.entity(loginRequest, MediaType.APPLICATION_JSON));
            
            if (response.getStatus() == 200) {
                LoginResponseDTO loginResponse = response.readEntity(LoginResponseDTO.class);
                logger.info("Connexion réussie pour l'utilisateur: {}", loginRequest.getEmail());
                return loginResponse;
            } else {
                logger.error("Échec de la connexion pour l'utilisateur: {}. Status: {}", 
                    loginRequest.getEmail(), response.getStatus());
                throw new RuntimeException("Échec de l'authentification: " + response.getStatus());
            }
        } catch (Exception e) {
            logger.error("Erreur lors de la connexion pour l'utilisateur: {}", loginRequest.getEmail(), e);
            throw new RuntimeException("Erreur de communication avec le serveur", e);
        }
    }
    
    /**
     * Déconnexion utilisateur
     * 
     * @param token Token JWT
     */
    public void logout(String token) {
        try {
            logger.info("Déconnexion de l'utilisateur");
            
            Response response = client
                .target(BASE_URL + "/auth/logout")
                .request(MediaType.APPLICATION_JSON)
                .header("Authorization", "Bearer " + token)
                .post(Entity.text(""));
            
            if (response.getStatus() == 200) {
                logger.info("Déconnexion réussie");
            } else {
                logger.warn("Problème lors de la déconnexion. Status: {}", response.getStatus());
            }
        } catch (Exception e) {
            logger.error("Erreur lors de la déconnexion", e);
        }
    }
    
    /**
     * Récupération du profil utilisateur
     * 
     * @param token Token JWT
     * @return Profil utilisateur
     */
    public UserDTO getUserProfile(String token) {
        try {
            logger.info("Récupération du profil utilisateur");
            
            Response response = client
                .target(BASE_URL + "/users/profile")
                .request(MediaType.APPLICATION_JSON)
                .header("Authorization", "Bearer " + token)
                .get();
            
            if (response.getStatus() == 200) {
                UserDTO user = response.readEntity(UserDTO.class);
                logger.info("Profil utilisateur récupéré: {}", user.getEmail());
                return user;
            } else {
                logger.error("Échec de la récupération du profil. Status: {}", response.getStatus());
                throw new RuntimeException("Impossible de récupérer le profil utilisateur");
            }
        } catch (Exception e) {
            logger.error("Erreur lors de la récupération du profil utilisateur", e);
            throw new RuntimeException("Erreur de communication avec le serveur", e);
        }
    }
    
    /**
     * Validation d'un token JWT
     * 
     * @param token Token à valider
     * @return true si le token est valide
     */
    public boolean validateToken(String token) {
        try {
            Response response = client
                .target(BASE_URL + "/auth/validate")
                .request(MediaType.APPLICATION_JSON)
                .header("Authorization", "Bearer " + token)
                .get();
            
            return response.getStatus() == 200;
        } catch (Exception e) {
            logger.error("Erreur lors de la validation du token", e);
            return false;
        }
    }
}
