import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs/promises';
import path from 'node:path';
import vm from 'node:vm';
import { fileURLToPath } from 'node:url';

const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)));

async function read(relativePath) {
  return fs.readFile(path.join(root, relativePath), 'utf8');
}

function fakeElement(id = '') {
  const listeners = {};
  const attributes = new Map();
  const classes = new Set();
  const node = {
    id,
    nodeType: 1,
    tagName: '',
    listeners,
    attributes,
    children: [],
    className: '',
    textContent: '',
    value: '',
    checked: false,
    disabled: false,
    open: false,
    options: [],
    selectedOptions: [],
    dataset: {},
    classList: {
      add: (...names) => names.forEach((name) => classes.add(name)),
      remove: (...names) => names.forEach((name) => classes.delete(name)),
      contains: (name) => classes.has(name),
      toggle: (name, force) => {
        const active = force === undefined ? !classes.has(name) : force;
        if (active) classes.add(name); else classes.delete(name);
        return active;
      }
    },
    addEventListener: (type, handler) => { listeners[type] = handler; },
    append(...children) { this.children.push(...children.flat()); },
    replaceChildren(...children) { this.children = children.flat(); },
    querySelectorAll: () => [],
    removeAttribute: (name) => attributes.delete(name),
    getAttribute: (name) => attributes.get(name) || null,
    setAttribute: (name, value) => attributes.set(name, value),
    showModal() { this.open = true; },
    close() { this.open = false; listeners.close?.(); },
    click() { return listeners.click?.({ preventDefault() {}, stopPropagation() {}, target: this }); }
  };
  return node;
}

function deferred() {
  let resolve;
  let reject;
  const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
  return { promise, resolve, reject };
}

function nodeText(node) {
  if (typeof node === 'string' || typeof node === 'number') return String(node);
  return `${node?.textContent || ''}${(node?.children || []).map(nodeText).join('')}`;
}

async function executeApp({ whatsappState = 'READY', statusResponses = [], qrResponses = [], get, post } = {}) {
  const elements = new Map();
  const timers = [];
  const gets = [];
  const posts = [];
  const element = (id) => {
    if (!elements.has(id)) elements.set(id, fakeElement(id));
    return elements.get(id);
  };
  const apiGet = async (url) => {
    gets.push(url);
    if (url === '/api/auth/me') return { user: { username: 'teste', role: 'admin' } };
    if (url === '/api/settings') return { settings: {} };
    if (url === '/api/outreach/templates') return { templates: [] };
    if (url === '/api/outreach/status') return { enviadosHoje: 0, mensagensPorDia: 10, ultimos: [] };
    if (url === '/api/outreach/opt-outs') return { optOuts: [] };
    if (url === '/api/whatsapp/status') return statusResponses.length ? statusResponses.shift() : { state: whatsappState };
    if (url === '/api/whatsapp/qr') return qrResponses.length ? qrResponses.shift() : { qr: 'data:image/png;base64,qr', expiresAt: null };
    if (get) return get(url);
    throw new Error(`GET inesperado: ${url}`);
  };
  const context = {
    API: {
      get: apiGet,
      post: async (url, body) => {
        posts.push({ url, body });
        if (post) return post(url, body);
        if (url === '/api/outreach/enviar-manual') return { ok: true, status: 'aceito' };
        return {};
      },
      put: async () => ({}),
      delete: async () => ({})
    },
    Captura: { init: async () => {} },
    Tratamento: { bindEvents() {}, ativar() {} },
    Campanhas: { bindEvents() {}, ativar() {} },
    // Mirrors public/js/api.js's comCarregando — app.js expects it as a
    // real global (plain <script> include order), but this sandbox only
    // loads app.js, so it must be provided here too.
    comCarregando: async (button, fn) => {
      if (!button) return fn();
      const jaCarregando = button.disabled;
      if (!jaCarregando) { button.disabled = true; button.classList.add('loading'); }
      try {
        return await fn();
      } finally {
        if (!jaCarregando) { button.disabled = false; button.classList.remove('loading'); }
      }
    },
    clearTimeout() {},
    dataBr: (value) => value,
    document: {
      querySelectorAll: () => [],
      querySelector: (selector) => selector === '#tabela-leads tbody' ? element('tabela-leads-tbody') : null
    },
    el: element,
    fmt: new Intl.NumberFormat('pt-BR'),
    h: (tag, attrs = {}, ...children) => {
      const node = fakeElement();
      node.tagName = tag.toUpperCase();
      for (const [key, value] of Object.entries(attrs)) {
        if (key === 'class') node.className = value;
        else if (key.startsWith('on')) node.addEventListener(key.slice(2), value);
        else if (value !== null && value !== undefined) node.setAttribute(key, value);
      }
      node.append(...children);
      return node;
    },
    setTimeout: (callback, delay) => {
      timers.push({ callback, delay });
      return timers.length;
    },
    toast() {},
    URLSearchParams,
    window: { Campanhas: { bindEvents() {}, ativar() {} }, confirm: () => true, location: {} }
  };
  vm.createContext(context);
  vm.runInContext(await read('public/js/app.js'), context);
  await new Promise((resolve) => setImmediate(resolve));
  return { context, element, elements, gets, posts, timers };
}

async function renderTreatment(app, rows) {
  app.context.API.get = async (url) => {
    if (url === '/api/leads/facets') return { ufs: [], interesses: [], produtos: [], segmentos: [], cidades: [] };
    if (url.startsWith('/api/dashboard/summary')) return {
      total: rows.length, com_whatsapp: rows.length, p1: rows.length, p2: 0, p3: 0, p4: 0,
      potencial_pct: 100, cobertura_pct: 0, exportados: 0, disponiveis: rows.length,
      p1_pct: 100, p2_pct: 0, p3_pct: 0, p4_pct: 0, meta_diaria: 10,
      meta_pct: 0, hoje_exportados: 0, dias_estimados: 1
    };
    if (url.startsWith('/api/dashboard/evolution')) return { evolution: [] };
    if (url.startsWith('/api/dashboard/oportunidade')) return { oportunidade: null };
    if (url.startsWith('/api/dashboard/rankings')) return { ranking: [] };
    if (url.startsWith('/api/leads?')) return { rows, total: rows.length, page: 1, pageSize: 50 };
    if (url === '/api/exports?limit=12') return { exports: [] };
    if (/^\/api\/leads\/\d+$/.test(url)) return rows.find((lead) => url.endsWith(`/${lead.id}`));
    if (url === '/api/settings') return { settings: {} };
    if (url === '/api/outreach/templates') return { templates: [] };
    if (url === '/api/outreach/status') return { enviadosHoje: 0, mensagensPorDia: 10, ultimos: [] };
    if (url === '/api/outreach/opt-outs') return { optOuts: [] };
    if (url === '/api/whatsapp/status') return { state: 'READY' };
    throw new Error(`GET inesperado no tratamento: ${url}`);
  };
  vm.runInContext(await read('public/js/tratamento.js'), app.context);
  await app.context.window.Tratamento.ativar();
  return app.element('tabela-leads-tbody');
}

test('interface e arquivos operacionais usam somente a identidade pessoal', async () => {
  const files = await Promise.all([
    'public/index.html',
    'public/login.html',
    'public/js/app.js',
    'public/js/tratamento.js',
    'public/css/app.css',
    '.env.example',
    'README.md',
    'launcher/Program.cs',
    'scripts/build-launcher.ps1'
  ].map(read));
  const operationalText = files.join('\n');

  assert.match(operationalText, /Máquina Comercial Pessoal/);
  assert.doesNotMatch(operationalText, /Grupo GTI|GTI-|GTI_|Z-PRO|ZPRO|WABA|GChat/i);
  await assert.rejects(fs.access(path.join(root, 'public', 'img', 'logo-gti.png')));
  await assert.rejects(fs.access(path.join(root, 'logo-gti-256x256.png')));
  await assert.rejects(fs.access(path.join(root, 'INICIAR-GTI.bat')));
  await fs.access(path.join(root, 'INICIAR-MAQUINA-PESSOAL.bat'));
  await fs.access(path.join(root, 'launcher', 'Maquina-Comercial-Pessoal.csproj'));
});

test('runtime pessoal usa cookie, IDs e variavel de ambiente pessoais', async () => {
  const runtimeText = (await Promise.all([
    'src/server/session.mjs',
    'src/lead-engine.mjs',
    'src/scoring.mjs',
    'src/sources/common.mjs'
  ].map(read))).join('\n');

  assert.match(runtimeText, /maquina_pessoal_session/);
  assert.match(runtimeText, /PERSONAL_COMMERCIAL_WHATSAPP/);
  assert.match(runtimeText, /MCP-/);
  assert.doesNotMatch(runtimeText, /Grupo GTI|GTI-|GTI_/i);
});

test('catalogo de campanhas limita a identidade Grupo GTI aos produtos aprovados', async () => {
  const catalogText = await read('src/outreach/campaign-catalog.mjs');
  assert.match(catalogText, /Grupo GTI/);
  assert.match(catalogText, /GTI Vendas/);
  assert.match(catalogText, /G-Delivery/);
  assert.doesNotMatch(catalogText, /Z-PRO|ZPRO|WABA|GChat/i);
});

test('fontes usam os nomes de ambiente documentados', async () => {
  const envText = await read('src/env.mjs');
  const placesText = await read('src/sources/google-places.mjs');
  assert.match(envText, /process\.env\.CNPJ_BASE_DIR/);
  assert.doesNotMatch(envText, /APP_CNPJ_BASE_DIR/);
  assert.match(placesText, /process\.env\.GOOGLE_PLACES_API_KEY/);
  assert.doesNotMatch(placesText, /GOOGLE_MAPS_API_KEY/);
});

test('catalogo preserva segmentos com um servico neutro por segmento', async () => {
  const config = JSON.parse(await read('prospeccao/config.json'));
  assert.ok(config.segments.length > 0);
  for (const segment of config.segments) {
    assert.deepEqual(segment.products, [{ nome: 'Meu serviço', estrelas: 3 }]);
  }
});

test('comando npm do launcher contorna somente a politica local de scripts', async () => {
  const pkg = JSON.parse(await read('package.json'));
  assert.match(pkg.scripts['build:launcher'], /-ExecutionPolicy Bypass -File scripts\/build-launcher\.ps1/);
  const buildScript = await read('scripts/build-launcher.ps1');
  assert.match(buildScript, /Get-Command dotnet -ErrorAction SilentlyContinue/);
});

test('launcher carrega APP_PORT do .env do root sem sobrescrever ambiente real', async () => {
  const source = await read('launcher/Program.cs');
  assert.match(source, /LoadDotEnv\(root\)/);
  assert.match(source, /BaseUrl\(root\)/);
  assert.match(source, /Environment\.GetEnvironmentVariable\(key\)/);
  assert.match(source, /StartsWith\("#"\)/);
});

test('tratamento separa validade do telefone da verificacao de WhatsApp', async () => {
  const html = await read('public/index.html');
  const treatment = await read('public/js/tratamento.js');

  assert.match(html, /Telefone: todos/);
  assert.match(html, /Com telefone/);
  assert.match(html, /Sem telefone/);
  assert.match(html, /<th>Telefone<\/th>/);
  assert.match(html, /empresa, CNPJ ou telefone/i);
  assert.doesNotMatch(treatment, /WhatsApp v[aá]lido/i);
  assert.doesNotMatch(treatment, /não tem WhatsApp cadastrado/i);
  assert.match(treatment, /whatsapp_status/);
  assert.match(treatment, /whatsapp_numero_resolvido/);
  assert.match(treatment, /whatsapp_checked_at/);
  for (const label of ['Não consultado', 'Confirmado', 'Não cadastrado', 'Erro temporário']) {
    assert.match(treatment, new RegExp(label));
  }
});

test('configuracoes mantem polling rapido em transicao e lento em estado estavel', async () => {
  const transitional = await executeApp({ whatsappState: 'RECONNECTING' });
  await transitional.elements.get('btn-settings').click();
  assert.equal(transitional.timers.at(-1)?.delay, 1000);

  const stable = await executeApp({ whatsappState: 'READY' });
  await stable.elements.get('btn-settings').click();
  assert.equal(stable.timers.at(-1)?.delay, 5000);
  await stable.timers.at(-1).callback();
  assert.equal(stable.timers.at(-1)?.delay, 5000);
});

test('resultado de poll antigo nao sobrescreve uma acao WhatsApp mais nova', async () => {
  const oldPoll = deferred();
  const app = await executeApp({
    statusResponses: [{ state: 'READY' }, oldPoll.promise],
    post: async (url) => {
      assert.equal(url, '/api/whatsapp/disconnect');
      return { status: { state: 'STOPPED' } };
    }
  });
  await app.element('btn-settings').click();
  const poll = app.timers.at(-1).callback();
  await Promise.resolve();
  await app.element('btn-whatsapp-disconnect').click();

  oldPoll.resolve({ state: 'QR_REQUIRED' });
  await poll;

  assert.equal(app.element('whatsapp-state').textContent, 'Parado');
  assert.equal(app.element('whatsapp-qr').getAttribute('src'), null);
});

test('QR antigo nao reaparece depois de uma acao informar READY', async () => {
  const oldQr = deferred();
  const app = await executeApp({
    statusResponses: [{ state: 'QR_REQUIRED' }],
    qrResponses: [oldQr.promise],
    post: async () => ({ status: { state: 'READY' } })
  });
  const opening = app.element('btn-settings').click();
  await Promise.resolve();
  await Promise.resolve();
  await app.element('btn-whatsapp-connect').click();

  oldQr.resolve({ qr: 'data:image/png;base64,antigo', expiresAt: '2026-07-29T12:00:00Z' });
  await opening;

  assert.equal(app.element('whatsapp-state').textContent, 'Conectado');
  assert.equal(app.element('whatsapp-qr').getAttribute('src'), null);
  assert.equal(app.element('whatsapp-qr').classList.contains('hidden'), true);
});

test('resultado de acao antiga nao sobrescreve uma acao posterior', async () => {
  const oldAction = deferred();
  const app = await executeApp({
    post: async (url) => url === '/api/whatsapp/connect'
      ? oldAction.promise
      : { status: { state: 'STOPPED' } }
  });
  await app.element('btn-settings').click();
  const connecting = app.element('btn-whatsapp-connect').click();
  await Promise.resolve();
  await app.element('btn-whatsapp-disconnect').click();

  const getCount = app.gets.length;
  oldAction.resolve({});
  await connecting;

  assert.equal(app.element('whatsapp-state').textContent, 'Parado');
  assert.equal(app.element('whatsapp-qr').classList.contains('hidden'), true);
  assert.equal(app.gets.length, getCount);
});

test('fechar configuracoes invalida consulta de status em andamento', async () => {
  const oldStatus = deferred();
  const app = await executeApp({ statusResponses: [oldStatus.promise] });
  const opening = app.element('btn-settings').click();
  await Promise.resolve();
  app.element('modal-settings').close();

  oldStatus.resolve({ state: 'QR_REQUIRED' });
  await opening;

  assert.equal(app.element('modal-settings').open, false);
  assert.equal(app.element('whatsapp-state').textContent, '');
  assert.equal(app.timers.length, 0);
});

test('limpar contexto preserva destino e mensagem digitados', async () => {
  const { context, element } = await executeApp();
  const numero = element('manual-numero');
  const mensagem = element('manual-mensagem');
  numero.value = '5575999999999';
  mensagem.value = 'Mensagem revisada';
  context.window.MaquinaSelecionarLeadManual({ id: 8, empresa: 'Empresa teste' });

  assert.equal(typeof context.window.MaquinaLimparLeadManual, 'function');
  context.window.MaquinaLimparLeadManual();

  assert.equal(numero.value, '5575999999999');
  assert.equal(mensagem.value, 'Mensagem revisada');
  assert.equal(element('manual-lead-context').textContent, 'Envio avulso, sem lead selecionado.');
});

test('envio manual usa edicoes visiveis e mantem o lead somente como contexto', async () => {
  const { context, element, posts } = await executeApp();
  context.window.MaquinaSelecionarLeadManual({ id: 8, empresa: 'Empresa teste', whatsapp: '5575111111111' });
  element('manual-numero').value = '5575222222222';
  element('manual-mensagem').value = 'Texto final do operador';

  await element('btn-enviar-manual').click();

  assert.deepEqual(JSON.parse(JSON.stringify(posts[0])), {
    url: '/api/outreach/enviar-manual',
    body: {
      numero: '5575222222222',
      mensagem: 'Texto final do operador',
      leadId: 8,
      lead: { id: 8, empresa: 'Empresa teste', whatsapp: '5575111111111' }
    }
  });
  assert.equal(posts.some(({ url }) => url.includes('check-number')), false);
});

test('envio manual mostra aviso quando o resultado da entrega e desconhecido', async () => {
  const app = await executeApp({
    post: async (url) => {
      assert.equal(url, '/api/outreach/enviar-manual');
      return {
        ok: false,
        status: 'resultado_desconhecido',
        aviso: 'O envio pode ter sido aceito. Nao reenvie sem confirmar no celular.'
      };
    }
  });

  app.element('manual-numero').value = '5575222222222';
  app.element('manual-mensagem').value = 'Texto final';
  await app.element('btn-enviar-manual').click();

  assert.match(app.element('manual-status').textContent, /nao reenvie/i);
  assert.equal(app.element('manual-status').classList.contains('status-error'), true);
  assert.equal(app.element('manual-status').classList.contains('status-ok'), false);
});

test('envio manual aceito mostra aviso de cache com destaque de alerta', async () => {
  const app = await executeApp({
    post: async (url) => {
      assert.equal(url, '/api/outreach/enviar-manual');
      return {
        ok: true,
        status: 'aceito',
        messageId: 'aceita-1',
        aviso: 'Nao foi possivel atualizar a verificacao local. Nao reenvie a mensagem por esse motivo.'
      };
    }
  });

  app.element('manual-numero').value = '5575222222222';
  app.element('manual-mensagem').value = 'Texto final';
  await app.element('btn-enviar-manual').click();

  assert.match(app.element('manual-status').textContent, /nao reenvie/i);
  assert.equal(app.element('manual-status').classList.contains('status-error'), true);
  assert.equal(app.element('manual-status').classList.contains('status-ok'), false);
});

test('envio manual aceito sem aviso preserva confirmacao normal', async () => {
  const app = await executeApp();
  app.element('manual-numero').value = '5575222222222';
  app.element('manual-mensagem').value = 'Texto final';

  await app.element('btn-enviar-manual').click();

  assert.match(app.element('manual-status').textContent, /Aceito pelo WhatsApp/i);
  assert.equal(app.element('manual-status').classList.contains('status-ok'), true);
  assert.equal(app.element('manual-status').classList.contains('status-error'), false);
});

test('acao real da tabela preenche envio e preserva edicao visivel com contexto do lead', async () => {
  const app = await executeApp();
  const lead = {
    id: 8, empresa: 'Empresa teste', legal_name: 'Empresa Teste Ltda', whatsapp: '5575111111111',
    cidade: 'Salvador', uf: 'BA', segmento: 'tecnologia', segmento_label: 'Tecnologia', cnpj: '123',
    whatsapp_status: 'confirmado', whatsapp_numero_resolvido: '5575111111111', whatsapp_checked_at: '2026-07-29T12:00:00Z',
    prioridade: 1, score: 90, classificacao: 'excelente', produto_principal: 'Meu serviço', afinidade: 'alta', exported_at: null
  };
  const tbody = await renderTreatment(app, [lead]);
  const action = tbody.children[0].children[0].children[0];

  await action.click();
  await app.timers.find(({ delay }) => delay === 250).callback();

  assert.match(app.element('manual-lead-context').textContent, /Lead: Empresa teste/);
  assert.equal(app.element('manual-numero').value, '5575111111111');
  assert.equal(app.element('manual-mensagem').value, 'Olá! Encontrei a Empresa teste em Salvador e gostaria de apresentar meu serviço. Podemos conversar?');

  app.element('manual-numero').value = '5575222222222';
  await app.element('btn-enviar-manual').click();
  const sent = app.posts.find(({ url }) => url === '/api/outreach/enviar-manual');
  assert.equal(sent.body.numero, '5575222222222');
  assert.equal(sent.body.leadId, 8);
  assert.equal(sent.body.lead.empresa, 'Empresa teste');
  assert.equal(app.posts.some(({ url }) => url.includes('check-number')), false);
});

test('status de verificacao mostra numero e data validos sem depender de title', async () => {
  const app = await executeApp();
  const base = {
    empresa: 'Empresa', whatsapp: '5575111111111', cidade: 'Salvador', segmento: 'tecnologia',
    prioridade: 1, score: 90, classificacao: 'excelente', produto_principal: '', afinidade: 'alta', exported_at: null,
    whatsapp_status: 'confirmado', whatsapp_numero_resolvido: '5575111111111'
  };
  const tbody = await renderTreatment(app, [
    { ...base, id: 1, whatsapp_checked_at: '2026-07-29T12:00:00Z' },
    { ...base, id: 2, whatsapp_checked_at: 'data-invalida' }
  ]);

  const validStatus = tbody.children[0].children[3];
  const invalidStatus = tbody.children[1].children[3];
  assert.match(nodeText(validStatus), /Confirmado/);
  assert.match(nodeText(validStatus), /5575111111111/);
  assert.match(nodeText(validStatus), /2026-07-29T12:00:00Z/);
  assert.doesNotMatch(nodeText(invalidStatus), /data-invalida/);
});

test('controle de limpar contexto e um botao acessivel', async () => {
  const html = await read('public/index.html');
  assert.match(html, /<button[^>]+id="btn-limpar-lead-manual"[^>]+type="button"[^>]*>\s*Limpar contexto do lead\s*<\/button>/i);
  assert.match(html, /id="whatsapp-state"[^>]+role="status"[^>]+aria-live="polite"/i);
});