/**
 * ═══════════════════════════════════════════════════════════════════════
 * CORREÇÕES HF SPACES - DNS E CONEXÃO WHATSAPP (HARD PATCH)
 * ═══════════════════════════════════════════════════════════════════════
 * Corrige erro: queryA ENODATA / ENOTFOUND web.whatsapp.com
 * Solução: Override direto do dns.lookup para ignorar resolvedor do sistema
 * ═══════════════════════════════════════════════════════════════════════
 */

const dns = require('dns');
const https = require('https');

// ═══════════════════════════════════════════════════════════════════════
// 1. LISTA COMPLETA DE IPs WHATSAPP/GOOGLE EDGE (FALLBACK)
// ═══════════════════════════════════════════════════════════════════════
const WHATSAPP_IPS = [
  '142.250.180.14',  // Google/WA Edge
  '142.250.187.238',
  '142.250.79.0',
  '172.217.173.238',
  '172.217.28.0',
  '108.177.14.0',
  '142.250.64.110',
  '142.250.191.110',
  '142.250.190.14',
  '142.250.187.206',
  '172.217.169.78',
  '31.13.92.52',     // Meta Edge
  '157.240.226.60'   // Meta Edge
];

/**
 * Retorna um IP aleatório da lista para balanceamento
 */
function getWhatsAppIP() {
  const index = Math.floor(Math.random() * WHATSAPP_IPS.length);
  return WHATSAPP_IPS[index];
}

// ═══════════════════════════════════════════════════════════════════════
// 2. PATCH CRÍTICO DE DNS (HARD OVERRIDE)
// ═══════════════════════════════════════════════════════════════════════

/**
 * Sobrescreve a função dns.lookup nativa do Node.js.
 * Isso intercepta as chamadas do Baileys antes que elas toquem na rede.
 */
function patchGlobalDNS() {
  const originalLookup = dns.lookup;

  dns.lookup = (hostname, options, callback) => {
    // Normaliza argumentos (options é opcional no Node.js)
    if (typeof options === 'function') {
      callback = options;
      options = {};
    }

    // Intercepta domínios do WhatsApp
    if (hostname === 'web.whatsapp.com' || hostname === 'whatsapp.com' || hostname === 'wss.whatsapp.net') {
      const directIP = getWhatsAppIP();
      // Retorna sucesso imediatamente com o IP fixo (Family 4 = IPv4)
      // console.log(`🛡️ [DNS-PATCH] Redirecionando ${hostname} -> ${directIP}`);
      return callback(null, directIP, 4);
    }

    // Para qualquer outro domínio (deepgram, google, etc), usa o DNS normal
    return originalLookup(hostname, options, callback);
  };

  console.log('✅ DNS Hard-Patch aplicado: web.whatsapp.com forçado para IPs diretos');
}

// ═══════════════════════════════════════════════════════════════════════
// 3. AGENTE HTTP OTIMIZADO PARA HF SPACES
// ═══════════════════════════════════════════════════════════════════════

function createHFAgent() {
  try {
    // Verifica proxy
    const proxy = process.env.HTTPS_PROXY || process.env.HTTP_PROXY || process.env.https_proxy;
    
    if (proxy) {
      const { HttpsProxyAgent } = require('https-proxy-agent');
      console.log('🔌 Usando proxy detectado:', proxy.substring(0, 20) + '...');
      return new HttpsProxyAgent(proxy);
    }
    
    // Sem proxy: Agente otimizado
    return new https.Agent({
      keepAlive: true,
      keepAliveMsecs: 30000,
      timeout: 60000,
      maxSockets: 100,
      maxFreeSockets: 20,
      // CRÍTICO: rejectUnauthorized: false permite conexão SSL direta no IP
      // sem validar se o certificado bate com o "IP" (já que o cert é para o domínio)
      rejectUnauthorized: false 
    });
  } catch (error) {
    console.warn('⚠️ Erro ao criar agente HTTP:', error.message);
    return undefined;
  }
}

// ═══════════════════════════════════════════════════════════════════════
// 4. OPÇÕES DE WEBSOCKET (HEADERS ESSENCIAIS)
// ═══════════════════════════════════════════════════════════════════════

function createWebSocketOptions() {
  return {
    // Headers necessários para enganar o servidor já que estamos conectando via IP
    headers: {
      'Origin': 'https://web.whatsapp.com',
      'Host': 'web.whatsapp.com', // O servidor precisa disso para rotear corretamente (SNI)
      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36',
      'Accept': '*/*',
      'Accept-Language': 'pt-BR,pt;q=0.9,en;q=0.8',
      'Sec-WebSocket-Extensions': 'permessage-deflate; client_max_window_bits',
      'Sec-WebSocket-Version': '13',
    },
    handshakeTimeout: 60000, // Timeout aumentado
    timeout: 60000,
  };
}

// ═══════════════════════════════════════════════════════════════════════
// 5. VERIFICAÇÃO DE REDE (DUMMY/PASS-THROUGH)
// ═══════════════════════════════════════════════════════════════════════

async function verifyHFNetwork() {
  // Com o patch de DNS aplicado, a verificação de rede tradicional é irrelevante
  // e pode falhar falsamente. Retornamos true para não bloquear o boot.
  console.log('🌐 Patch de rede ativo. Ignorando teste de DNS convencional.');
  return true;
}

// ═══════════════════════════════════════════════════════════════════════
// EXPORTAÇÕES
// ═══════════════════════════════════════════════════════════════════════

module.exports = {
  configureDNS: () => {
    // Configura o patch imediatamente ao ser chamado
    const dns = require('dns');
    // Força ordem IPv4
    if (dns.setDefaultResultOrder) {
      dns.setDefaultResultOrder('ipv4first');
    }
    // Aplica o override
    patchGlobalDNS();
  },
  
  getWhatsAppIP,
  createHFAgent,
  createWebSocketOptions,
  verifyHFNetwork
};