ranking/frontend/src/services/api.js

import axios from 'axios';

const api = axios.create({
  baseURL: '/api/v1',
  headers: {
    'Content-Type': 'application/json',
  },
  timeout: 180000,
});

export const rankingService = {
  async getRanking(page = 1, size = 100, selos = []) {
    const params = { page, size };
    if (selos && selos.length > 0) {
      const normalizados = selos
        .map((s) => String(s || '').trim().toUpperCase())
        .filter(Boolean);
      if (normalizados.length > 0) {
        params.selos = normalizados.join(',');
      }
    }
    const response = await api.get('/ranking/paginado', { params });
    const data = response.data;

    const hoje = new Date();

    const consultores = (data.consultores || []).map((c) => {
      const anos = Number(c.anos_atuacao || 0);
      const consultoria = c.consultoria || {};
      const primeiroEvento = consultoria.inicio
        ? new Date(consultoria.inicio)
        : (() => {
            const d = new Date(hoje);
            d.setFullYear(d.getFullYear() - Math.floor(anos));
            return d;
          })();

      const mapPeriodo = (item) => ({
        inicio: item.inicio || item.periodo?.inicio || null,
        fim: item.fim || item.periodo?.fim || null,
      });

      const coordenacoesCapes = (c.coordenacoes_capes || []).map((coord) => ({
        ...coord,
        periodo: mapPeriodo(coord),
      }));

      return {
        id_pessoa: c.id_pessoa,
        nome: c.nome,
        rank: c.posicao,
        posicao: c.posicao,
        pontuacao_total: c.pontuacao_total,
        bloco_a: c.bloco_a,
        bloco_b: c.bloco_b,
        bloco_c: c.bloco_c,
        bloco_d: c.bloco_d,
        bloco_e: c.bloco_e || 0,
        ativo: c.ativo,
        anos_atuacao: anos,
        veterano: anos >= 10,
        tipos_atuacao: c.tipos_atuacao || [],
        coordenador_ppg: Boolean(c.coordenador_ppg),
        pontuacao: c.pontuacao || {
          pontuacao_total: c.pontuacao_total,
          bloco_a: { total: c.bloco_a, atuacoes: [] },
          bloco_b: { total: c.bloco_b, atuacoes: [] },
          bloco_c: { total: c.bloco_c, atuacoes: [] },
          bloco_d: { total: c.bloco_d, atuacoes: [] },
          bloco_e: { total: c.bloco_e || 0, atuacoes: [] },
        },
        consultoria: {
          codigo: consultoria.codigo || null,
          situacao: consultoria.situacao || null,
          inicio: consultoria.inicio || primeiroEvento.toISOString(),
          fim: consultoria.fim || null,
          areas: consultoria.areas || [],
          anos_consecutivos: consultoria.anos_consecutivos || 0,
          retornos: consultoria.retornos || 0,
          vinculos: (consultoria.vinculos || []).map((v) => ({
            periodo: {
              inicio: v.inicio || v.periodo?.inicio || null,
              fim: v.fim || v.periodo?.fim || null,
              ativo: v.ativo ?? v.periodo?.ativo ?? !v.fim,
            },
            ies: v.ies || null,
            situacao: v.situacao || '',
          })),
        },
        coordenacoes_capes: coordenacoesCapes,
        inscricoes: c.inscricoes || [],
        avaliacoes_comissao: c.avaliacoes_comissao || [],
        premiacoes: c.premiacoes || [],
        bolsas_cnpq: c.bolsas_cnpq || [],
        participacoes: c.participacoes || [],
        orientacoes: c.orientacoes || [],
        membros_banca: c.membros_banca || [],
        idiomas: c.idiomas || [],
        titulacao: c.titulacao || '',
        lattes: c.lattes || null,
      };
    });

    return {
      total: data.total,
      total_pages: data.total_pages,
      page: data.page ?? page,
      size: data.size ?? size,
      consultores,
    };
  },

  async getConsultor(idPessoa) {
    const response = await api.get(`/consultor/${idPessoa}`);
    return response.data;
  },

  async getHealth() {
    const response = await api.get('/health');
    return response.data;
  },

  async searchConsultor(nome, limit = 5) {
    const response = await api.get('/ranking/busca', { params: { nome, limit } });
    return response.data;
  },

  async processarRanking(limpar_antes = true) {
    const response = await api.post('/ranking/processar', { limpar_antes });
    return response.data;
  },

  async getStatus() {
    const response = await api.get('/ranking/status');
    return response.data;
  },

  async getSelos() {
    const response = await api.get('/ranking/selos');
    return response.data.selos;
  },

  async getConsultorRaw(idPessoa) {
    const response = await api.get(`/consultor/${idPessoa}/raw`);
    return response.data;
  },

  async downloadFichaPDF(idPessoa, nomeConsultor = '') {
    const response = await api.get(`/consultor/${idPessoa}/pdf`, {
      responseType: 'blob',
    });

    const blob = new Blob([response.data], { type: 'application/pdf' });
    const url = window.URL.createObjectURL(blob);
    const link = document.createElement('a');
    link.href = url;

    const nomeSanitizado = nomeConsultor
      .replace(/[^a-zA-Z0-9\s\-_]/g, '')
      .substring(0, 30)
      .trim();
    const dataAtual = new Date().toISOString().split('T')[0].replace(/-/g, '');
    link.download = `ficha_consultor_${idPessoa}_${nomeSanitizado}_${dataAtual}.pdf`;

    document.body.appendChild(link);
    link.click();
    document.body.removeChild(link);
    window.URL.revokeObjectURL(url);
  },

  async sugerirConsultores(tema, areaAvaliacao = null, apenasAtivos = true, quantidade = 20) {
    const params = { tema, apenas_ativos: apenasAtivos, quantidade };
    if (areaAvaliacao) {
      params.area_avaliacao = areaAvaliacao;
    }
    const response = await api.get('/consultores/sugerir', { params });
    return response.data;
  },

  async getAreasAvaliacao() {
    const response = await api.get('/consultores/areas-avaliacao');
    return response.data;
  },

  async getLattes(idPessoa) {
    const response = await api.get(`/consultor/${idPessoa}/lattes`);
    return response.data;
  },
};

export default api;