/**
 * Serviço KYC para validação de CPF via SmartCPF
 * Consome: GET https://api.smartcpf.com.br/v2/individuals/{cpf}?package=X
 * 
 * Package X = consulta completa (validação + dados cadastrais + situação cadastral)
 * Requer: token de acesso (x-api-key token) obtido em app.smartcpf.com.br
 */
const SMARTCP_BASE = 'https://api.smartcpf.com.br/v2';
const PACKAGE = 'X'; // package completo
/**
 * Valida CPF via SmartCPF com retry exponencial e tratamento de erros
 * @param {string} cpf - CPF apenas números (11 dígitos)
 * @param {string} token - x-api-key token da SmartCPF
 * @param {Object} options - Opções de retry/logging
 * @returns {Promise<Object>} Dados validados do CPF ou erro estruturado
 */
async function validarCPFSmartCPF(cpf, token, options = {}) {
  const {
    maxRetries = 3,
    baseDelayMs = 300,
    maxDelayMs = 5000,
    onRetry = () => {},
    onError = () => {},
    logger = console
  } = options;
  // Sanitiza CPF: remove formatação, valida 11 dígitos
  const cleanCpf = String(cpf).replace(/\D/g, '');
  if (!/^\d{11}$/.test(cleanCpf)) {
    throw new Error('CPF inválido: deve conter exatamente 11 dígitos numéricos');
  }
  const url = `${SMARTCP_BASE}/individuals/${cleanCpf}?package=${PACKAGE}`;
  const headers = {
    'Authorization': `x-api-key ${token}`,
    'Accept': 'application/json',
  };
  let attempt = 0;
  let lastError;
  while (attempt <= maxRetries) {
    attempt++;
    const startTime = Date.now();
    try {
      logger.info({ cpf: maskCpf(cleanCpf), attempt }, 'Consultando SmartCPF');
      const response = await fetch(url, { headers });
      const latencyMs = Date.now() - startTime;
      // Lê body uma única vez
      const data = await response.json();
      // Log de auditoria com consultId se disponível
      const consultId = data?.meta?.consultId;
      const balance = data?.meta?.balance;
      logger.info({ 
        cpf: maskCpf(cleanCpf), 
        consultId, 
        balance, 
        latencyMs, 
        status: response.status 
      }, 'Resposta SmartCPF recebida');
      // Sucesso HTTP mas erro de negócio (ex: CPF não encontrado, saldo zerado)
      if (!response.ok) {
        const error = new SmartCPFError(
          data?.message || `HTTP ${response.status}`,
          response.status,
          data?.errors,
          consultId
        );
        throw error;
      }
      // Sucesso: valida estrutura esperada
      if (!data?.success || !data?.result?.cpf) {
        throw new SmartCPFError('Resposta inválida da API: success=false ou result ausente', 502);
      }
      // Retorna dados normalizados para o domínio da fintech
      return normalizeKYCResponse(data, latencyMs);
    } catch (err) {
      lastError = err;
      
      // Erros não-retryáveis: 400, 401, 403, 404, 422
      if (err instanceof SmartCPFError && !err.isRetryable) {
        logger.warn({ cpf: maskCpf(cleanCpf), error: err.message, status: err.status }, 'Erro não-retryável');
        throw err;
      }
      // Última tentativa: propaga erro
      if (attempt > maxRetries) {
        logger.error({ cpf: maskCpf(cleanCpf), error: err.message, attempts: attempt }, 'Todas as tentativas esgotadas');
        throw new SmartCPFError(`Falha após ${attempt} tentativas: ${err.message}`, 502, null, null, err);
      }
      // Backoff exponencial com jitter
      const delay = Math.min(
        baseDelayMs * Math.pow(2, attempt - 1) + Math.random() * 200,
        maxDelayMs
      );
      
      logger.warn({ cpf: maskCpf(cleanCpf), attempt, delayMs: delay }, 'Retry agendado');
      onRetry({ attempt, delay, error: err.message });
      await sleep(delay);
    }
  }
  throw lastError;
}
/**
 * Normaliza resposta da SmartCPF para domínio KYC da fintech
 */
function normalizeKYCResponse(data, latencyMs) {
  const { meta, result } = data;
  return {
    // Dados de identidade validados
    cpf: result.cpf,                    // "111.111.111-11" (formatado)
    nome: result.name,                  // "João da Silva"
    dataNascimento: result.birthDate,   // "10/09/1992"
    idade: result.age,                  // 33
    nomeMae: result.motherName,         // "Maria da Silva"
    sexo: result.gender,                // "M" ou "F"
    
    // Metadados de auditoria e controle
    consultId: meta.consultId,          // UUID v4 para auditoria BC
    consultDate: meta.date,             // ISO 8601: "2025-01-15T14:32:10.123Z"
    executionTimeMs: meta.executionTimeMs, // Latência API: 74.1
    balance: meta.balance,              // Créditos restantes: 9.77
    apiVersion: meta.apiVersion,        // "v2"
    searchType: meta.searchType,        // "CPF C"
    
    // Metadados internos
    latencyMs,                          // Latência total (rede + API)
    consultedAt: new Date().toISOString()
  };
}
/**
 * Erro tipado da SmartCPF com flag de retry
 */
class SmartCPFError extends Error {
  constructor(message, status, errors = null, consultId = null, cause = null) {
    super(message);
    this.name = 'SmartCPFError';
    this.status = status;
    this.errors = errors;
    this.consultId = consultId;
    this.cause = cause;
    // Erros 4xx não são retryáveis (exceto 429); 5xx e rede são
    this.isRetryable = status === 429 || status >= 500 || !status;
  }
}
/**
 * Utilitários
 */
function maskCpf(cpf) {
  return cpf.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, '$1.$2.$3-**');
}
function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}
/**
 * Exemplo de uso no fluxo de onboarding
 */
async function exemploOnboarding() {
  const TOKEN = process.env.SMARTCP_TOKEN; // Configure via env
  const cpfUsuario = '11111111111'; // CPF do usuário no formulário
  try {
    const kycData = await validarCPFSmartCPF(cpfUsuario, TOKEN, {
      maxRetries: 3,
      baseDelayMs: 300,
      logger: {
        info: (meta, msg) => console.log(`[INFO] ${msg}`, meta),
        warn: (meta, msg) => console.warn(`[WARN] ${msg}`, meta),
        error: (meta, msg) => console.error(`[ERROR] ${msg}`, meta)
      },
      onRetry: ({ attempt, delay }) => {
        console.log(`Tentativa ${attempt} falhou, aguardando ${delay}ms...`);
      }
    });
    console.log('✅ KYC validado com sucesso:', {
      cpf: kycData.cpf,
      nome: kycData.nome,
      idade: kycData.idade,
      consultId: kycData.consultId,
      balance: kycData.balance
    });
    // Próximos passos do onboarding:
    // 1. Salvar kycData.consultId no banco para auditoria BC
    // 2. Verificar kycData.balance < 100 → alerta de recarga
    // 3. Cruzar kycData.nomeMae / kycData.dataNascimento com documento enviado
    // 4. Consultar listas PEP/sanções (fora do escopo da SmartCPF)
    // 5. Prosseguir para abertura de conta
    return kycData;
  } catch (err) {
    if (err instanceof SmartCPFError) {
      switch (err.status) {
        case 401:
          console.error('Token inválido ou expirado — verifique SMARTCP_TOKEN');
          break;
        case 403:
          console.error('Token sem permissão para este package — verifique plano');
          break;
        case 404:
          console.error('CPF não encontrado na base da Receita Federal');
          break;
        case 422:
          console.error('CPF inválido (dígito verificador ou formatação)');
          break;
        case 429:
          console.error('Rate limit excedido — implemente fila com backoff');
          break;
        default:
          console.error('Erro na validação KYC:', err.message);
      }
    } else {
      console.error('Erro inesperado:', err);
    }
    throw err;
  }
}
// Executa se rodado diretamente
if (require.main === module) {
  exemploOnboarding().catch(() => process.exit(1));
}
module.exports = { validarCPFSmartCPF, SmartCPFError, normalizeKYCResponse };

{
  "meta": {
    "searchType": "CPF C",
    "consultId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "user": "Minha Fintech LTDA",
    "message": "CPF encontrado com sucesso",
    "ip": "203.0.113.45",
    "success": true,
    "apiVersion": "v2",
    "date": "2025-01-15T14:32:10.123Z",
    "executionTimeMs": 74.1,
    "balance": 9.77
  },
  "result": {
    "cpf": "111.111.111-11",
    "name": "João da Silva",
    "birthDate": "10/09/1992",
    "age": 33,
    "motherName": "Maria da Silva",
    "gender": "M"
  },
  "success": true,
  "errors": []
}