background.js

// background.js - OdooDevTools

/* ══════════════════════════════════════
   Hash fragment helpers
══════════════════════════════════════ */
function parseHash(url) {
  try {
    const hash = new URL(url).hash.replace(/^#/, "");
    if (!hash) return {};
    return Object.fromEntries(
      hash.split("&")
        .filter((s) => s.includes("="))
        .map((s) => s.split("=").map(decodeURIComponent))
    );
  } catch { return {}; }
}

function setHashParam(url, key, value) {
  try {
    const u      = new URL(url);
    const params = parseHash(url);
    params[key]  = value;
    delete params["_company_switching"];
    u.hash = Object.entries(params)
      .map(([k, v]) => `${k}=${encodeURIComponent(v)}`)
      .join("&");
    return u.toString();
  } catch { return url; }
}

function deleteHashParam(url, key) {
  try {
    const u      = new URL(url);
    const params = parseHash(url);
    delete params[key];
    delete params["_company_switching"];
    const entries = Object.entries(params);
    u.hash = entries.length
      ? entries.map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&")
      : "";
    return u.toString();
  } catch { return url; }
}

/* ══════════════════════════════════════
   Storage
══════════════════════════════════════ */
async function getStorage() {
  return new Promise((resolve) => {
    chrome.storage.sync.get({ domains: [], companies: [], clientMode: false }, resolve);
  });
}

/* Odoo 19 guarda las compañías activas en la cookie "cids". A diferencia
   de Odoo 14-18, no refleja ese estado en la URL /odoo/... . */
chrome.runtime.onMessage.addListener((msg, _sender, sendResponse) => {
  if (msg.type !== "setOdoo19Companies") return;

  chrome.cookies.set({
    url: `${msg.origin}/`,
    name: "cids",
    value: String(msg.cids),
    path: "/",
    expirationDate: Math.floor(Date.now() / 1000) + (60 * 60 * 24 * 30),
  }, () => {
    if (chrome.runtime.lastError) {
      sendResponse({ ok: false, error: chrome.runtime.lastError.message });
    } else {
      sendResponse({ ok: true });
    }
  });
  return true;
});

/* ══════════════════════════════════════
   Matching
══════════════════════════════════════ */
function matchEntry(url, entries) {
  try {
    const { hostname, host } = new URL(url);
    return entries.find((e) => {
      const clean = e.domain.replace(/^https?:\/\//, "").replace(/\/$/, "");
      if (clean.includes(":")) return host === clean;
      return hostname === clean;
    }) || null;
  } catch { return null; }
}

function isLoginPage(url) {
  try {
    const { pathname } = new URL(url);
    return pathname === "/web/login" || pathname.startsWith("/web/login/");
  } catch { return true; }
}

function isCompanySwitching(url) {
  try {
    const parsed = new URL(url);
    return parseHash(url)["_company_switching"] === "1" || parsed.searchParams.get("_company_switching") === "1";
  } catch { return false; }
}

/* Rutas del backend (/web... y /odoo...): ahí un ?lang= suelto provoca
   "Invalid language code", así que se elimina. */
function isBackendPath(pathname) {
  return pathname === "/web" || pathname.startsWith("/web/") ||
         pathname === "/odoo" || pathname.startsWith("/odoo/");
}

function isNewRouter(pathname) {
  return pathname === "/odoo" || pathname.startsWith("/odoo/");
}

function alreadyUpToDate(url, entry) {
  try {
    const searchParams = new URL(url).searchParams;
    const hashParams   = parseHash(url);
    const debugOk = searchParams.get("debug") === (entry.mode || "1");
    const isOdoo19 = new URL(url).pathname === "/odoo" || new URL(url).pathname.startsWith("/odoo/");
    // En Odoo 19 la empresa activa está en la cookie "cids", no en la URL.
    const cidsOk  = isOdoo19 || !entry.cid || hashParams["cids"] === String(entry.cid);
    const u = new URL(url);
    // Odoo 18+ (/odoo): el idioma va por RPC, nunca por URL.
    // Odoo ≤17 (/web): ?lang= como siempre; sin idioma elegido no debe quedar ninguno.
    const langOk = isNewRouter(u.pathname)
      ? !searchParams.has("lang")
      : entry.lang
        ? searchParams.get("lang") === entry.lang
        : !(isBackendPath(u.pathname) && searchParams.has("lang"));
    return debugOk && langOk && cidsOk;
  } catch { return false; }
}

function buildDebugUrl(url, entry) {
  let result = url;
  const u = new URL(result);
  u.searchParams.set("debug", entry.mode || "1");
  if (!isNewRouter(u.pathname) && entry.lang) u.searchParams.set("lang", entry.lang);
  else if (isBackendPath(u.pathname))          u.searchParams.delete("lang");
  result = u.toString();
  if (entry.cid && !(u.pathname === "/odoo" || u.pathname.startsWith("/odoo/"))) {
    result = setHashParam(result, "cids", String(entry.cid));
  }
  return result;
}

function getDebugUrl(url, entries) {
  if (!url.startsWith("http")) return null;
  if (isLoginPage(url)) return null;
  if (isCompanySwitching(url)) return null;
  if (!entries.length) return null;
  const entry = matchEntry(url, entries);
  if (!entry) return null;
  if (alreadyUpToDate(url, entry)) return null;
  return buildDebugUrl(url, entry);
}

/* ══════════════════════════════════════
   Badge
══════════════════════════════════════ */
async function updateBadge(tabId, url) {
  if (!url || !url.startsWith("http")) {
    chrome.action.setBadgeText({ text: "", tabId });
    return;
  }
  const { domains, clientMode } = await getStorage();

  // Modo cliente activo → badge gris con ojo
  if (clientMode) {
    const entry = matchEntry(url, domains);
    if (entry) {
      chrome.action.setBadgeText({ text: "👁", tabId });
      chrome.action.setBadgeBackgroundColor({ color: "#f59e0b", tabId });
      return;
    }
  }

  const entry = matchEntry(url, domains);
  if (!entry) {
    chrome.action.setBadgeText({ text: "", tabId });
    return;
  }

  let debugVal = null;
  try { debugVal = new URL(url).searchParams.get("debug"); } catch {}

  const setBadgeTextColor = chrome.action.setBadgeTextColor
      ? (opts) => chrome.action.setBadgeTextColor(opts)
      : () => {};

  if (debugVal === "1") {
    chrome.action.setBadgeText({ text: "1", tabId });
    chrome.action.setBadgeBackgroundColor({ color: "#22c55e", tabId });
    chrome.action.setBadgeTextColor({ color: "#ffffff", tabId });
  } else if (debugVal === "assets") {
    chrome.action.setBadgeText({ text: "A", tabId });
    chrome.action.setBadgeBackgroundColor({ color: "#f59e0b", tabId });
    chrome.action.setBadgeTextColor({ color: "#ffffff", tabId });
  } else {
    chrome.action.setBadgeText({ text: "·", tabId });
    chrome.action.setBadgeBackgroundColor({ color: "#6b7280", tabId });
    chrome.action.setBadgeTextColor({ color: "#ffffff", tabId });
  }
}

chrome.tabs.onActivated.addListener(async ({ tabId }) => {
  try {
    const tab = await chrome.tabs.get(tabId);
    updateBadge(tabId, tab.url || "");
  } catch {}
});

chrome.tabs.onUpdated.addListener((tabId, changeInfo) => {
  if (changeInfo.url) updateBadge(tabId, changeInfo.url);
});

chrome.storage.onChanged.addListener(async (changes) => {
  if (!changes.domains && !changes.clientMode) return;
  try {
    const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
    if (tab) updateBadge(tab.id, tab.url || "");
  } catch {}
});

/* ══════════════════════════════════════
   Detección de POST — evita redirigir durante
   todo el flujo POST → 302 → página final,
   preservando mensajes flash del servidor
══════════════════════════════════════ */
const postTabs = new Set();

chrome.webRequest.onBeforeRequest.addListener(
  (details) => {
    if (details.type === "main_frame" && details.method === "POST") {
      postTabs.add(details.tabId);
    }
  },
  { urls: ["<all_urls>"] }
);

chrome.webNavigation.onCompleted.addListener((details) => {
  if (details.frameId === 0) postTabs.delete(details.tabId);
});

chrome.webNavigation.onErrorOccurred.addListener((details) => {
  if (details.frameId === 0) postTabs.delete(details.tabId);
});

chrome.tabs.onRemoved.addListener((tabId) => postTabs.delete(tabId));

/* ══════════════════════════════════════
   Navegación — respeta modo cliente
══════════════════════════════════════ */
chrome.webNavigation.onBeforeNavigate.addListener(async (details) => {
  if (details.frameId !== 0) return;
  const { domains, clientMode } = await getStorage();
  if (clientMode) return; // no interceptar en modo cliente
  if (postTabs.has(details.tabId)) return;
  const debugUrl = getDebugUrl(details.url, domains);
  if (debugUrl) chrome.tabs.update(details.tabId, { url: debugUrl });
});

chrome.webNavigation.onCommitted.addListener(async (details) => {
  if (details.frameId !== 0) return;
  const qualifies =
    (details.transitionQualifiers && details.transitionQualifiers.includes("server_redirect")) ||
    details.transitionType === "form_submit";
  if (!qualifies) return;
  const { domains, clientMode } = await getStorage();
  if (clientMode) return; // no interceptar en modo cliente
  if (postTabs.has(details.tabId)) return;
  const debugUrl = getDebugUrl(details.url, domains);
  if (debugUrl) chrome.tabs.update(details.tabId, { url: debugUrl });
});

/* ══════════════════════════════════════
   Borrar action temporal creado por openModel
   El popup se cierra al navegar, así que el
   unlink lo ejecuta el background que permanece vivo
══════════════════════════════════════ */
chrome.runtime.onMessage.addListener((msg) => {
  if (msg.type !== "unlinkAction") return;
  const { origin, actionId } = msg;

  // Esperar a que Odoo haya cargado el action en cliente antes de borrarlo
  setTimeout(async () => {
    try {
      await fetch(`${origin}/web/dataset/call_kw`, {
        method:  "POST",
        headers: { "Content-Type": "application/json" },
        credentials: "include",
        body: JSON.stringify({
          jsonrpc: "2.0", method: "call", id: 1,
          params: {
            model:  "ir.actions.act_window",
            method: "unlink",
            args:   [[actionId]],
            kwargs: {}
          }
        })
      });
    } catch {}
  }, 3000);
});