content.js

let isolationEnabled = false;
let scrubInterval = null;

// --- SIDEBAR COLLAPSE ---
const SIDEBAR_COLLAPSE_SVG_PATHS = [
  "M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z",
  "15.41 7.41 14 6 8 12 14 18 15.41 16.59 10.83 12",
];
const SIDEBAR_COLLAPSE_ARIA_HINTS = ["collapse side panel", "hide side panel"];
const SIDEBAR_COLLAPSE_ICON_CODEPOINTS = ["\uE5DE"];
const SIDEBAR_LEFTMOST_THRESHOLD_PX = 8;
const SIDEBAR_ENFORCE_INTERVAL_MS = 1000;

function isVisibleElement(el) {
  return !!(el && el.offsetParent !== null);
}

function isSidebarCollapseIcon(svg) {
  const html = svg && svg.innerHTML;
  if (!html) return false;
  return SIDEBAR_COLLAPSE_SVG_PATHS.some((sig) => html.includes(sig));
}

function isLeftMostButton(btn) {
  try {
    const rect = btn.getBoundingClientRect();
    return rect.left <= SIDEBAR_LEFTMOST_THRESHOLD_PX;
  } catch {
    return false;
  }
}

function isAnyVisibleButtonAtLeftMost(buttons) {
  return buttons.some((btn) => isVisibleElement(btn) && isLeftMostButton(btn));
}

function clickFirstVisibleButton(buttons) {
  for (const btn of buttons) {
    if (!isVisibleElement(btn)) continue;
    btn.click();
    return true;
  }
  return false;
}

function findButtonsByIconCodepoint() {
  const nodes = Array.from(document.querySelectorAll("button, span, i, div"));
  return nodes
    .filter((el) => {
      const text = (el.textContent || "").trim();
      if (!text) return false;
      return SIDEBAR_COLLAPSE_ICON_CODEPOINTS.some((cp) => text.includes(cp));
    })
    .map((el) => (el.tagName === "BUTTON" ? el : el.closest("button")))
    .filter(Boolean);
}

function nativelyCollapseSidebar() {
  try {
    const codepointButtons = findButtonsByIconCodepoint();
    if (isAnyVisibleButtonAtLeftMost(codepointButtons)) return true;
    if (clickFirstVisibleButton(codepointButtons)) return true;

    const iconButtons = Array.from(document.querySelectorAll("svg"))
      .filter(isSidebarCollapseIcon)
      .map((svg) => svg.closest("button"))
      .filter(Boolean);

    if (isAnyVisibleButtonAtLeftMost(iconButtons)) return true;
    if (clickFirstVisibleButton(iconButtons)) return true;

    const ariaButtons = Array.from(document.querySelectorAll("button")).filter((btn) => {
      const label = (btn.getAttribute("aria-label") || "").toLowerCase();
      return SIDEBAR_COLLAPSE_ARIA_HINTS.some((hint) => label.includes(hint));
    });

    if (isAnyVisibleButtonAtLeftMost(ariaButtons)) return true;
    if (clickFirstVisibleButton(ariaButtons)) return true;
  } catch {}
  return false;
}

let collapseAttempts = 0;
let collapseInterval = null;
let lastSidebarEnforceAt = 0;

function attemptSidebarCollapse() {
  if (collapseInterval) clearInterval(collapseInterval);
  collapseAttempts = 0;
  
  collapseInterval = setInterval(() => {
    collapseAttempts++;
    if (nativelyCollapseSidebar() || collapseAttempts > 15) {
      clearInterval(collapseInterval);
    }
  }, 200);
}

function enforceSidebarClosed() {
  const now = Date.now();
  if (now - lastSidebarEnforceAt < SIDEBAR_ENFORCE_INTERVAL_MS) return;
  lastSidebarEnforceAt = now;
  nativelyCollapseSidebar();
}

// --- SESSION STATE ---
const SESSION_FLAG = "__sv_iso_enabled__";

function setSessionFlag(on) {
  try {
    if (on) sessionStorage.setItem(SESSION_FLAG, "1");
    else sessionStorage.removeItem(SESSION_FLAG);
  } catch {}
}

// --- HOVER SUPPRESSION ---
let hoverSuppressInstalled = false;
let isDragging = false;

function _isOverCanvas(x, y) {
  try {
    const els = document.elementsFromPoint(x, y) || [];
    return els.some((el) => el && el.tagName === "CANVAS");
  } catch {
    return true;
  }
}

function _onPointerDown(e) {
  if (!isolationEnabled) return;
  isDragging = true;
}

function _onPointerUp(e) {
  if (!isolationEnabled) return;
  isDragging = false;
}

function _onPointerMove(e) {
  if (!isolationEnabled) return;
  if (isDragging) return;
  if (!e || typeof e.clientX !== "number") return;
  if (!_isOverCanvas(e.clientX, e.clientY)) return;
  e.stopImmediatePropagation();
  e.stopPropagation();
  e.preventDefault();
}

function installHoverSuppressor() {
  if (hoverSuppressInstalled) return;
  hoverSuppressInstalled = true;
  const opts = { capture: true, passive: false };
  window.addEventListener("pointerdown", _onPointerDown, opts);
  window.addEventListener("pointerup", _onPointerUp, opts);
  window.addEventListener("pointercancel", _onPointerUp, opts);
  window.addEventListener("pointermove", _onPointerMove, opts);
  window.addEventListener("mousemove", _onPointerMove, opts);
  window.addEventListener("touchmove", _onPointerMove, opts);
}

function uninstallHoverSuppressor() {
  if (!hoverSuppressInstalled) return;
  hoverSuppressInstalled = false;
  const opts = { capture: true };
  window.removeEventListener("pointerdown", _onPointerDown, opts);
  window.removeEventListener("pointerup", _onPointerUp, opts);
  window.removeEventListener("pointercancel", _onPointerUp, opts);
  window.removeEventListener("pointermove", _onPointerMove, opts);
  window.removeEventListener("mousemove", _onPointerMove, opts);
  window.removeEventListener("touchmove", _onPointerMove, opts);
  isDragging = false;
}

// --- ICON PATCH ---
const TRANSPARENT_DATA_URI =
  "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMB/6X+oQAAAABJRU5ErkJggg==";

let iconPatchInstalled = false;
let originalImageSrcDesc = null;

function shouldBlankIconUrl(url) {
  if (!url || typeof url !== "string") return false;
  return (
    url.includes("maps.gstatic.com/mapfiles/") ||
    url.includes("gstatic.com/mapfiles/") ||
    url.includes("/mapfiles/")
  );
}

function installIconPatch() {
  if (iconPatchInstalled) return;
  try {
    originalImageSrcDesc = Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, "src");
    if (!originalImageSrcDesc || !originalImageSrcDesc.set) return;

    Object.defineProperty(HTMLImageElement.prototype, "src", {
      get: originalImageSrcDesc.get,
      set: function (v) {
        if (shouldBlankIconUrl(v)) {
          return originalImageSrcDesc.set.call(this, TRANSPARENT_DATA_URI);
        }
        return originalImageSrcDesc.set.call(this, v);
      }
    });

    iconPatchInstalled = true;
  } catch {}
}

function uninstallIconPatch() {
  if (!iconPatchInstalled) return;
  try {
    if (originalImageSrcDesc) {
      Object.defineProperty(HTMLImageElement.prototype, "src", originalImageSrcDesc);
    }
  } catch {}
  iconPatchInstalled = false;
  originalImageSrcDesc = null;
}

// --- CSS ALLOW-LIST & LAYOUT FIX ---
const ISO_CLASS = "sv-iso-on";
const KEEP_CLASS = "sv-iso-keep";
const STYLE_ID = "__sv_iso_style__";

function ensureIsoStyle() {
  let st = document.getElementById(STYLE_ID);
  if (!st) {
    st = document.createElement("style");
    st.id = STYLE_ID;
    document.documentElement.appendChild(st);
  }
  return st;
}

function setIsoCss(enabled) {
  const st = ensureIsoStyle();
  st.textContent = enabled
    ? `
      html, body { background: #000 !important; }
      html.${ISO_CLASS},
      html.${ISO_CLASS} body {
        margin: 0 !important;
        width: 100vw !important;
        height: 100vh !important;
        overflow: hidden !important;
      }

      /* Hide everything in this frame */
      html.${ISO_CLASS} * {
        visibility: hidden !important;
        opacity: 0 !important;
        pointer-events: none !important;
      }

      /* Allow-list: only elements we mark as keep */
      html.${ISO_CLASS} .${KEEP_CLASS} {
        visibility: visible !important;
        opacity: 1 !important;
        pointer-events: auto !important;
      }

      /* THE FIX: Detach canvas from ghost layouts and stretch it */
      html.${ISO_CLASS} canvas.${KEEP_CLASS} {
        visibility: visible !important;
        opacity: 1 !important;
        pointer-events: auto !important;
        background: #000 !important;
        position: fixed !important;
        top: 0 !important;
        left: 0 !important;
        width: 100vw !important;
        height: 100vh !important;
        z-index: 999999 !important;
        margin: 0 !important;
        padding: 0 !important;
        object-fit: cover !important; 
      }
    `
    : "";
}

function clearKeepMarks() {
  document.querySelectorAll(`.${KEEP_CLASS}`).forEach((el) => el.classList.remove(KEEP_CLASS));
}

function markKeepChain(canvas) {
  clearKeepMarks();
  let el = canvas;
  while (el) {
    el.classList.add(KEEP_CLASS);
    if (el === document.body) break;
    el = el.parentElement || (el.getRootNode() instanceof ShadowRoot ? el.getRootNode().host : null);
  }
}

// --- CANVAS SELECTION ---
function isLargeCanvas(c) {
  const r = c.getBoundingClientRect();
  return r.width > 300 && r.height > 300;
}

function isWebGLCanvas(c) {
  try { return !!(c.getContext("webgl2") || c.getContext("webgl")); } 
  catch { return false; }
}

function getBestCanvasFromCenterStack() {
  const cx = Math.floor(window.innerWidth / 2);
  const cy = Math.floor(window.innerHeight / 2);
  let stack = [];
  try { stack = document.elementsFromPoint(cx, cy) || []; } 
  catch { stack = []; }

  const canvases = stack.filter((el) => el && el.tagName === "CANVAS" && isLargeCanvas(el));
  if (!canvases.length) return null;

  for (let i = canvases.length - 1; i >= 0; i--) {
    if (isWebGLCanvas(canvases[i])) return canvases[i];
  }
  return canvases[canvases.length - 1];
}

function getBestCanvasByArea() {
  const canvases = Array.from(document.querySelectorAll("canvas"))
    .filter(isLargeCanvas)
    .map((c) => ({ c, r: c.getBoundingClientRect(), webgl: isWebGLCanvas(c) }));

  if (!canvases.length) return null;
  const list = canvases.filter((o) => o.webgl).length ? canvases.filter((o) => o.webgl) : canvases;
  list.sort((a, b) => b.r.width * b.r.height - a.r.width * a.r.height);
  return list[0].c;
}

function getBestCanvas() {
  return getBestCanvasFromCenterStack() || getBestCanvasByArea();
}

// --- SCRUB LOGIC ---
function performScrub() {
  if (!isolationEnabled) return;
  installIconPatch();
  document.documentElement.classList.add(ISO_CLASS);
  setIsoCss(true);
  enforceSidebarClosed();

  const canvas = getBestCanvas();
  if (!canvas) return;
  markKeepChain(canvas);
}

function startScrubbing() {
  if (scrubInterval) clearInterval(scrubInterval);
  lastSidebarEnforceAt = 0;
  attemptSidebarCollapse();
  performScrub();
  installHoverSuppressor();
  scrubInterval = setInterval(performScrub, 120);
}

function stopScrubbing() {
  if (scrubInterval) clearInterval(scrubInterval);
  if (collapseInterval) clearInterval(collapseInterval);
  lastSidebarEnforceAt = 0;

  isolationEnabled = false;
  uninstallHoverSuppressor();
  uninstallIconPatch();
  clearKeepMarks();
  document.documentElement.classList.remove(ISO_CLASS);
  setIsoCss(false);
}

// --- MESSAGES ---
chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
  if (msg.type === "SET_ISOLATION") {
    if (msg.enabled) {
      isolationEnabled = true;
      setSessionFlag(true);
      startScrubbing();
      sendResponse({ ok: true, enabled: true });
    } else {
      stopScrubbing();
      setSessionFlag(false);
      sendResponse({ ok: true, enabled: false });
    }
    return;
  }
  if (msg.type === "GET_ISOLATION_STATE") {
    sendResponse({ ok: true, enabled: isolationEnabled });
    return;
  }
});

// --- AUTO-REAPPLY AFTER REFRESH ---
try {
  if (sessionStorage.getItem(SESSION_FLAG) === "1") {
    isolationEnabled = true;
    startScrubbing();
  }
} catch {}

try {
  chrome.runtime.sendMessage({ type: "HELLO_ISO" }, (resp) => {
    if (resp && resp.ok && resp.enabled) {
      isolationEnabled = true;
      startScrubbing();
    }
  });
} catch {}