testes/src/services/authService.js

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

/**
 * 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 agora retorna { setores: [...], token: "..." }
        const { token, setores = [] } = 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
        };
        
        // Mapear setores para módulos e criar estrutura de tokens por módulo
        const tokensByModule = {};
        const setoresByModule = {};
        
        setores.forEach(setor => {
          const module = getModuleFromSetor(setor);
          if (module) {
            tokensByModule[module] = token;
            setoresByModule[module] = setor;
          }
        });
        
        // Retorna no formato esperado pelo hook
        // Mantém compatibilidade: retorna token principal e também tokens por módulo
        return { 
          token, // Token principal (compatibilidade)
          tokens: tokensByModule, // Tokens por módulo
          setores: setoresByModule, // Setores por módulo
          setoresList: setores, // Lista original de setores
          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).
   */
  loginMonitoramento: (email, password) => handleRequest({
    mockFn: () => authMock.authenticate(email, password),
    apiFn: async () => {
        const response = await api.post('/auth_pralog', {
          email,
          password
        });
        
        // Backend agora retorna { setores: [...], token: "..." }
        const { token, setores = [] } = 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: [], 
          authorizedEnvironments: { rh: true }
        };
        
        // Mapear setores para módulos e criar estrutura de tokens por módulo
        const tokensByModule = {};
        const setoresByModule = {};
        
        setores.forEach(setor => {
          const module = getModuleFromSetor(setor);
          if (module) {
            tokensByModule[module] = token;
            setoresByModule[module] = setor;
          }
        });
        
        // Retorna no formato esperado pelo hook
        return { 
          token, // Token principal (compatibilidade)
          tokens: tokensByModule, // Tokens por módulo
          setores: setoresByModule, // Setores por módulo
          setoresList: setores, // Lista original de setores
          user 
        };
    }
  }),

  /**
   * Autentica um usuário no sistema Oeste Pan.
   * Usa endpoint dedicado /auth_oestepan
   */
  loginOestePan: (email, password) => handleRequest({
    mockFn: () => authMock.authenticate(email, password),
    apiFn: async () => {
        const response = await api.post('/auth_oestepan', {
          email,
          password
        });
        
        const { token, setores = [] } = 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: [], 
          authorizedEnvironments: { auth_oestepan: true }
        };
        
        const tokensByModule = {};
        const setoresByModule = {};
        
        setores.forEach(setor => {
          const module = getModuleFromSetor(setor);
          if (module) {
            tokensByModule[module] = token;
            setoresByModule[module] = setor;
          }
        });
        
        return { 
          token,
          tokens: tokensByModule,
          setores: setoresByModule,
          setoresList: setores,
          user 
        };
    }
  }),

  /**
   * 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;
    }
  })
};