const HERESY_PORT_DEFAULT = 3000;
const PORT_SCAN_RANGE = 20; // varre 3000..3019

// ── Idiomas ───────────────────────────────────────────────────────────────────
// O app tem EN/PT/ES; a extensão seguia só em português. Guarda a escolha em
// chrome.storage (sincroniza entre popups) e cai no idioma do navegador na 1a vez.
const I18N = {
  pt: {
    sub: 'Ponte de cookies do Eldorado',
    conn_checking: 'Procurando o Heresy Lister...',
    conn_ok: 'Heresy Lister conectado',
    conn_off: 'Heresy Lister não encontrado',
    conn_off_sub: 'Abra o app e tente de novo',
    conn_port: 'porta {p} (detectada sozinha)',
    token_label: 'Token',
    token_ph: 'Cole o token aqui...',
    token_hint: 'Conta → <b>Extensão</b> → copie o token.',
    save: 'Salvar',
    sync: 'Sincronizar Agora',
    syncing: 'Sincronizando...',
    footer: 'Sincroniza <b>automaticamente</b> a cada 30s<br>quando o Eldorado estiver aberto.',
    err_no_token: 'Cole o token do Heresy Lister.',
    ok_saved: 'Token salvo! Clique em Sincronizar para testar.',
    err_no_cookies: 'Nenhum cookie do Eldorado. Faça login em eldorado.gg primeiro.',
    err_incomplete: 'Login incompleto em eldorado.gg (faltando {x}). Faça login novamente.',
    err_notfound: 'Heresy Lister não encontrado. Verifique se o app está aberto.',
    ok_connected: '✓ Conectado como {n}',
    ok_cf: 'Cookies salvos (o Cloudflare bloqueou a validação — reinicie o Lister se as chamadas continuarem falhando)',
    err_generic: 'Erro: {x}',
    err_send: 'Falha ao enviar os cookies: {x}',
  },
  en: {
    sub: 'Eldorado cookie bridge',
    conn_checking: 'Looking for Heresy Lister...',
    conn_ok: 'Heresy Lister connected',
    conn_off: 'Heresy Lister not found',
    conn_off_sub: 'Open the app and try again',
    conn_port: 'port {p} (auto-detected)',
    token_label: 'Token',
    token_ph: 'Paste your token here...',
    token_hint: 'Account → <b>Extension</b> → copy the token.',
    save: 'Save',
    sync: 'Sync Now',
    syncing: 'Syncing...',
    footer: 'Syncs <b>automatically</b> every 30s<br>while Eldorado is open.',
    err_no_token: 'Paste your Heresy Lister token.',
    ok_saved: 'Token saved! Hit Sync to test it.',
    err_no_cookies: 'No Eldorado cookies. Log in at eldorado.gg first.',
    err_incomplete: 'Incomplete eldorado.gg login (missing {x}). Please log in again.',
    err_notfound: 'Heresy Lister not found. Make sure the app is running.',
    ok_connected: '✓ Connected as {n}',
    ok_cf: 'Cookies saved (Cloudflare blocked validation — restart the Lister if API calls keep failing)',
    err_generic: 'Error: {x}',
    err_send: 'Failed to send cookies: {x}',
  },
  es: {
    sub: 'Puente de cookies de Eldorado',
    conn_checking: 'Buscando el Heresy Lister...',
    conn_ok: 'Heresy Lister conectado',
    conn_off: 'Heresy Lister no encontrado',
    conn_off_sub: 'Abre la app e inténtalo de nuevo',
    conn_port: 'puerto {p} (detectado solo)',
    token_label: 'Token',
    token_ph: 'Pega el token aquí...',
    token_hint: 'Cuenta → <b>Extensión</b> → copia el token.',
    save: 'Guardar',
    sync: 'Sincronizar ahora',
    syncing: 'Sincronizando...',
    footer: 'Sincroniza <b>automáticamente</b> cada 30s<br>mientras Eldorado esté abierto.',
    err_no_token: 'Pega el token del Heresy Lister.',
    ok_saved: '¡Token guardado! Pulsa Sincronizar para probar.',
    err_no_cookies: 'No hay cookies de Eldorado. Inicia sesión en eldorado.gg primero.',
    err_incomplete: 'Login incompleto en eldorado.gg (falta {x}). Inicia sesión de nuevo.',
    err_notfound: 'Heresy Lister no encontrado. Verifica que la app esté abierta.',
    ok_connected: '✓ Conectado como {n}',
    ok_cf: 'Cookies guardadas (Cloudflare bloqueó la validación — reinicia el Lister si las llamadas siguen fallando)',
    err_generic: 'Error: {x}',
    err_send: 'No pude enviar las cookies: {x}',
  },
};
let _lang = 'pt';
function t(k, vars) {
  let s = (I18N[_lang] || I18N.pt)[k] || (I18N.en[k] || k);
  if (vars) for (const v in vars) s = s.split('{' + v + '}').join(vars[v]);
  return s;
}
function aplicarIdioma() {
  document.documentElement.lang = _lang;
  document.querySelectorAll('[data-i18n]').forEach(el => { el.textContent = t(el.dataset.i18n); });
  // textos com <b> dentro: só entram como HTML porque são strings NOSSAS, do dicionário
  // acima — nada aqui vem do servidor ou do usuário.
  document.querySelectorAll('[data-i18n-html]').forEach(el => { el.innerHTML = t(el.dataset.i18nHtml); });
  document.querySelectorAll('[data-i18n-ph]').forEach(el => { el.placeholder = t(el.dataset.i18nPh); });
  document.querySelectorAll('#langs button').forEach(b => b.classList.toggle('on', b.dataset.lang === _lang));
}
async function definirIdioma(l, salvar) {
  _lang = I18N[l] ? l : 'pt';
  aplicarIdioma();
  if (salvar) { try { await chrome.storage.local.set({ heresy_lang: _lang }); } catch (e) {} }
}

// ── Porta: sempre automática ──────────────────────────────────────────────────
// O campo manual saiu da tela. O app sobe na 3000 e, se estiver ocupada, pega a
// próxima livre — então varremos 3000..3019 e guardamos a que respondeu, para a
// próxima abertura já acertar de primeira. Uma porta digitada errada só gerava
// "não conectou" sem explicação.
async function discoverPort(preferred) {
  const tryPort = async (p) => {
    try {
      const r = await fetch('http://127.0.0.1:' + p + '/eldorado/api/ext/ping', { method: 'GET', cache: 'no-store' });
      if (!r.ok) return false;
      const j = await r.json();
      return j && j.app === 'heresy-lister';
    } catch { return false; }
  };
  if (preferred && await tryPort(preferred)) return preferred;
  for (let i = 0; i < PORT_SCAN_RANGE; i++) {
    const p = HERESY_PORT_DEFAULT + i;
    if (p === preferred) continue;
    if (await tryPort(p)) {
      await chrome.storage.local.set({ heresy_port: p });
      return p;
    }
  }
  return null;
}

function showStatus(msg, type) {
  const el = document.getElementById('status');
  el.textContent = msg;
  el.className = 'status ' + type;
  el.style.display = 'block';
}

function setConn(estado, porta) {
  const box = document.getElementById('conn');
  const txt = document.getElementById('connTxt');
  const sub = document.getElementById('connSub');
  box.className = 'conn ' + estado;
  if (estado === 'ok') { txt.textContent = t('conn_ok'); sub.textContent = t('conn_port', { p: porta }); }
  else if (estado === 'off') { txt.textContent = t('conn_off'); sub.textContent = t('conn_off_sub'); }
  else { txt.textContent = t('conn_checking'); sub.textContent = ''; }
}

async function checarConexao() {
  setConn('busca');
  const cfg = await chrome.storage.local.get(['heresy_port']);
  const p = await discoverPort(cfg.heresy_port || HERESY_PORT_DEFAULT);
  setConn(p ? 'ok' : 'off', p);
  return p;
}

async function load() {
  const cfg = await chrome.storage.local.get(['heresy_token', 'heresy_lang']);
  const nav = (navigator.language || 'pt').slice(0, 2).toLowerCase();
  await definirIdioma(cfg.heresy_lang || (I18N[nav] ? nav : 'pt'), false);
  if (cfg.heresy_token) document.getElementById('tokenInput').value = cfg.heresy_token;
  checarConexao();
}

async function saveToken() {
  const token = document.getElementById('tokenInput').value.trim();
  if (!token) { showStatus(t('err_no_token'), 'err'); return; }
  await chrome.storage.local.set({ heresy_token: token });
  showStatus(t('ok_saved'), 'ok');
}

async function syncNow() {
  const btn = document.getElementById('syncBtn');
  const restaurar = () => { btn.disabled = false; btn.innerHTML = '<span>&#10227;</span> <span>' + t('sync') + '</span>'; };
  btn.disabled = true;
  btn.innerHTML = '<span>&#10227;</span> <span>' + t('syncing') + '</span>';

  const cfg = await chrome.storage.local.get(['heresy_token', 'heresy_port']);
  const token = cfg.heresy_token;
  if (!token) { showStatus(t('err_no_token'), 'err'); restaurar(); return; }

  const cookies = await chrome.cookies.getAll({ domain: 'eldorado.gg' });
  if (!cookies.length) { showStatus(t('err_no_cookies'), 'err'); restaurar(); return; }

  const hasIdToken = cookies.some(c => c.name === '__Host-EldoradoIdToken');
  const hasRefresh = cookies.some(c => c.name === '__Host-EldoradoRefreshToken');
  if (!hasIdToken || !hasRefresh) {
    showStatus(t('err_incomplete', { x: !hasIdToken ? 'IdToken' : 'RefreshToken' }), 'err');
    restaurar(); return;
  }

  const cookieStr = cookies.map(c => c.name + '=' + c.value).join('; ');
  const userAgent = navigator.userAgent;

  setConn('busca');
  const port = await discoverPort(cfg.heresy_port || HERESY_PORT_DEFAULT);
  if (!port) { setConn('off'); showStatus(t('err_notfound'), 'err'); restaurar(); return; }
  setConn('ok', port);

  try {
    const extVersion = (chrome.runtime.getManifest && chrome.runtime.getManifest().version) || '';
    const r = await fetch('http://127.0.0.1:' + port + '/eldorado/api/ext/cookies', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ cookies: cookieStr, token, userAgent, version: extVersion }),
    });
    const data = await r.json();
    if (data.ok) {
      showStatus(data.warning === 'cf_challenge' ? t('ok_cf') : t('ok_connected', { n: data.nick || '?' }), 'ok');
    } else {
      showStatus(t('err_generic', { x: data.error || '?' }), 'err');
    }
  } catch (e) {
    showStatus(t('err_send', { x: e.message }), 'err');
  }
  restaurar();
}

document.addEventListener('DOMContentLoaded', () => {
  load();
  document.getElementById('saveBtn').addEventListener('click', saveToken);
  document.getElementById('syncBtn').addEventListener('click', syncNow);
  document.querySelectorAll('#langs button').forEach(b => {
    b.addEventListener('click', () => definirIdioma(b.dataset.lang, true));
  });
});
