// web_proxy toggle — service worker.
//
// Mantiene el estado del proxy en chrome.storage.local y lo aplica a la
// configuracion de red de Chromium con la API chrome.proxy. El popup solo
// escribe el estado; este worker reacciona a los cambios y reconfigura el
// proxy. Asi un unico punto aplica la configuracion (popup, arranque,
// instalacion).
//
// Modelo de estado (chrome.storage.local key "state"):
//   {
//     enabled:     boolean,        // captura ON/OFF
//     activeProxy: string,         // id del proxy activo
//     proxies: [
//       { id, name, scheme, host, port }   // proxy simple
//     ]
//   }
//
// Encadenacion de proxies (futuro): un proxy podra declarar
// `chain: [ {scheme,host,port}, ... ]` y se aplicara mediante un PAC script
// generado aqui. El modelo de lista ya lo permite sin migracion.

const DEFAULT_STATE = {
  enabled: false,
  activeProxy: "capture",
  proxies: [
    {
      id: "capture",
      name: "Captura web_proxy",
      scheme: "http",
      host: "127.0.0.1",
      port: 8889,
    },
  ],
};

async function getState() {
  const r = await chrome.storage.local.get("state");
  return r.state || DEFAULT_STATE;
}

async function setState(state) {
  await chrome.storage.local.set({ state });
}

function setBadge(on) {
  chrome.action.setBadgeText({ text: on ? "ON" : "" });
  chrome.action.setBadgeBackgroundColor({ color: on ? "#16a34a" : "#666666" });
}

// Aplica el proxy activo si la captura esta encendida; si no, limpia la
// configuracion para volver a la conexion directa del sistema.
async function applyProxy() {
  const st = await getState();

  if (!st.enabled) {
    await chrome.proxy.settings.clear({ scope: "regular" });
    setBadge(false);
    return;
  }

  const p =
    st.proxies.find((x) => x.id === st.activeProxy) || st.proxies[0] || null;
  if (!p) {
    await chrome.proxy.settings.clear({ scope: "regular" });
    setBadge(false);
    return;
  }

  // fixed_servers con un unico proxy. Sin "<-loopback>" en bypassList, de modo
  // que el trafico a loopback (incluida la propia UI del proxy) NO se proxea y
  // por tanto no se captura. El trafico a sitios externos si pasa por el proxy.
  const config = {
    mode: "fixed_servers",
    rules: {
      singleProxy: {
        scheme: p.scheme || "http",
        host: p.host,
        port: Number(p.port),
      },
    },
  };
  await chrome.proxy.settings.set({ value: config, scope: "regular" });
  setBadge(true);
}

// Sembrar el estado por defecto la primera vez y aplicar.
chrome.runtime.onInstalled.addListener(async () => {
  const r = await chrome.storage.local.get("state");
  if (!r.state) {
    await setState(DEFAULT_STATE);
  }
  applyProxy();
});

// Reaplicar al arrancar el navegador (la configuracion de proxy de la sesion
// no persiste entre arranques de Chromium).
chrome.runtime.onStartup.addListener(applyProxy);

// El popup escribe el estado; aqui se reconfigura el proxy en consecuencia.
chrome.storage.onChanged.addListener((changes, area) => {
  if (area === "local" && changes.state) {
    applyProxy();
  }
});