/**
 * Cliente SmartCPF v2 - Consulta de CPF com tratamento de erro robusto
 * Documentação: https://api.smartcpf.com.br/docs
 */

const fetch = require('node-fetch');

class SmartCPFClient {
  constructor(apiKey, baseUrl = 'https://api.smartcpf.com.br/v2') {
    this.apiKey = apiKey;
    this.baseUrl = baseUrl;
    this.maxRetries = 3;
    this.baseDelayMs = 500;
  }

  /**
   * Consulta CPF com pacote de dados completo (package=individuals)
   * @param {string} cpf - CPF apenas números (11 dígitos)
   * @returns {Promise<Object>} Resposta parseada da API
   */
  async consultarCPF(cpf) {
    // Validação básica antes de chamar a API
    if (!cpf || !/^\d{11}$/.test(cpf)) {
      throw new Error('CPF inválido: deve conter 11 dígitos numéricos');
    }

    const url = `${this.baseUrl}/individuals/${cpf}?package=individuals`;
    const headers = {
      'x-api-key': `${this.apiKey}`,
      'Accept': 'application/json',
    };

    let lastError;

    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
      try {
        const response = await fetch(url, { headers });

        // Tratamento por código de status HTTP
        switch (response.status) {
          case 200:
            return await response.json();

          case 401:
            throw new Error('API Key inválida ou expirada (401)');

          case 402:
            throw new Error('Créditos insuficientes — recarregue na dashboard (402)');

          case 404:
            // CPF não encontrado na base — não é erro de integração
            const notFound = await response.json();
            return { success: false, cpf, ...notFound, errors: ['CPF não encontrado na base'] };

          case 422:
            const validationError = await response.json();
            throw new Error(`CPF malformado: ${validationError.message || 'formato inválido'}`);

          case 429:
            // Rate limit — respeita Retry-After se houver
            const retryAfter = response.headers.get('Retry-After');
            const waitMs = retryAfter ? parseInt(retryAfter) * 1000 : this.baseDelayMs * Math.pow(2, attempt);
            console.warn(`Rate limit (429). Tentativa ${attempt}/${this.maxRetries}. Aguardando ${waitMs}ms...`);
            await this.sleep(waitMs);
            continue; // Retry no loop

          case 500:
          case 502:
          case 503:
            // Erro de servidor — retrykey com backoff exponencial
            lastError = new Error(`Erro do servidor (${response.status})`);
            break;

          default:
            lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);
        }
      } catch (err) {
        lastError = err;
        // Erros de rede/timeout também entram no retry
        if (err.code === 'ECONNREFUSED' || err.code === 'ETIMEDOUT') {
          console.warn(`Erro de rede: ${err.message}. Tentativa ${attempt}/${this.maxRetries}`);
        } else {
          // Erros de validação (401, 402, 422) não devem retry
          throw err;
        }
      }

      // Backoff exponencial com jitter
      if (attempt < this.maxRetries) {
        const delay = this.baseDelayMs * Math.pow(2, attempt - 1) + Math.random() * 200;
        await this.sleep(delay);
      }
    }

    throw new Error(`Falha após ${this.maxRetries} tentativas: ${lastError.message}`);
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// Exemplo de uso
async function main() {
  const client = new SmartCPFClient(process.env.SMARTCPF_API_KEY);

  try {
    const resultado = await client.consultarCPF('11111111111');
    
    if (resultado.success && resultado.result) {
      console.log('✅ Consulta bem-sucedida:');
      console.log(`   Nome: ${resultado.result.name}`);
      console.log(`   CPF: ${resultado.result.cpf}`);
      console.log(`   Nascimento: ${resultado.result.birthDate} (${resultado.result.age} anos)`);
      console.log(`   Mãe: ${resultado.result.motherName}`);
      console.log(`   Gênero: ${resultado.result.gender}`);
      console.log(`   ConsultId: ${resultado.meta.consultId}`);
      console.log(`   Saldo restante: ${resultado.meta.balance} créditos`);
      console.log(`   Tempo de execução: ${resultado.meta.executionTimeMs}ms`);
    } else {
      console.log('⚠️ CPF não encontrado ou erro:', resultado.errors);
    }
  } catch (err) {
    console.error('❌ Erro na consulta:', err.message);
    process.exit(1);
  }
}

if (require.main === module) {
  main();
}

module.exports = SmartCPFClient;

{
  "meta": {
    "searchType": "CPF C",
    "consultId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "user": "Desenvolvedor SmartCPF",
    "message": "CPF encontrado com sucesso",
    "ip": "127.0.0.1",
    "success": true,
    "apiVersion": "v2",
    "date": "2026-01-15T14:32:10.123Z",
    "executionTimeMs": 74.1,
    "balance": 987.50
  },
  "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": []
}