import api from './api';
import { authMock } from './mocks/authMock';
import { handleRequest } from './serviceUtils';
import { extractUserFromToken } from '@/utils/jwtUtils';

/**
 * Serviço de autenticação para o Integra Finance (PRALOG).
 * Gerencia a comunicação com o endpoint /auth_pralog do backend.
 */
export const authService = {
  /**
   * Autentica um usuário no sistema Pralog.
   * 
   * @param {string} email - Email do usuário
   * @param {string} password - Senha do usuário
   * @returns {Promise<{token: string, user: Object}>} Token de autenticação e dados do usuário
   * 
   * @example
   * const { token, user } = await authService.authenticatePralog('admin@pralog.com', 'admin123');
   */
  authenticatePralog: (email, password) => handleRequest({
    mockFn: () => authMock.authenticate(email, password),
    apiFn: async () => {
      try {
        const response = await api.post('/auth_pralog', {
          email,
          password
        });
        
        // Data Mapping: Backend retorna apenas { token }
        // Precisamos criar o objeto user a partir do email fornecido
        const { token } = response.data;
        
        if (!token) {
          throw new Error('Token não retornado pelo servidor');
        }
        
        // Extrai informações do token JWT
        const tokenData = extractUserFromToken(token);
        
        // Criar objeto user com dados do token e do email fornecido
        const user = {
          id: null, // Backend não retorna ID na autenticação
          name: email.split('@')[0], // Extrai nome do email
          email: tokenData?.email || email,
          database: tokenData?.database || null, // Database do JWT
          role: 'user', // Role padrão
          permissions: [] // Permissões podem ser obtidas em outra rota
        };
        
        // Retorna no formato esperado pelo hook
        return { token, user };
      } catch (error) {
        // Tratamento de erros específicos
        if (error.response) {
          // Erro retornado pelo servidor
          const status = error.response.status;
          const message = error.response.data?.message || 'Erro ao autenticar';
          
          if (status === 401) {
            throw new Error('Credenciais inválidas. Verifique seu email e senha.');
          } else if (status === 403) {
            throw new Error('Acesso negado. Você não tem permissão para acessar este sistema.');
          } else if (status === 500) {
            throw new Error('Erro no servidor. Tente novamente mais tarde.');
          } else {
            throw new Error(message);
          }
        } else if (error.request) {
          // Requisição foi feita mas não houve resposta
          throw new Error('Não foi possível conectar ao servidor. Verifique sua conexão.');
        } else {
          // Erro na configuração da requisição
          throw new Error('Erro ao processar a requisição: ' + error.message);
        }
      }
    }
  }),

  /*
   * Autentica um usuário no sistema de Monitoramento de Frota (Pralog Frota).
   * 
   * @param {string} email - Email do usuário
   * @param {string} password - Senha do usuário
   * @returns {Promise<{token: string, user: Object}>} Token de autenticação e dados do usuário
   */
  loginMonitoramento: (email, password) => handleRequest({
    mockFn: () => authMock.authenticate(email, password),
    apiFn: async () => {
      try {
        const response = await api.post('/auth_pralog', {
          email,
          password
        });
        ///auth_monitoramento
        // Data Mapping: Backend retorna apenas { token } (assumindo mesmo padrão)
        const { token } = response.data;
        
        if (!token) {
          throw new Error('Token não retornado pelo servidor');
        }
        
        const tokenData = extractUserFromToken(token);
        
        const user = {
          id: null,
          name: email.split('@')[0], 
          email: tokenData?.email || email,
          database: tokenData?.database || null,
          role: 'user',
          permissions: ['fleet_access'], // Permissão específica para frota
          authorizedEnvironments: { fleet: true }
        };
        
        return { token, user };
      } catch (error) {
         if (error.response) {
          const status = error.response.status;
          const message = error.response.data?.message || 'Erro ao autenticar no Monitoramento';
          
          if (status === 401) {
            throw new Error('Credenciais inválidas para Monitoramento.');
          } else {
            throw new Error(message);
          }
        }
        throw new Error('Erro de conexão com o servidor de Monitoramento: ' + error.message);
      }
    }
  }),

  /**
   * Valida se um token ainda é válido.
   * 
   * @param {string} token - Token a ser validado
   * @returns {Promise<boolean>} True se o token é válido
   */
  validateToken: (token) => handleRequest({
    mockFn: async () => {
      // Mock sempre retorna válido se houver token
      return { valid: !!token };
    },
    apiFn: async () => {
      const response = await api.post('/auth_pralog/validate', { token });
      return response.data;
    }
  })
};
