content.js

// Main content script - coordinates PII detection and highlighting

// Global service state
let serviceEnabled = false;
let siteProtectionEnabled = false;
let bulkActionsAllowedForSite = false;

// Track attached elements for cleanup
const attachedElements = new Set();

// Load initial service state
chrome.storage.local.get("serviceEnabled").then((result) => {
  serviceEnabled = result.serviceEnabled === true;
  if (!serviceEnabled) {
    // Remove all overlays if service is disabled
    for (const el of attachedElements) {
      removeOverlay(el);
    }
  }
});

// ---------------- ACTIVE TARGET logic ----------------
let activeEl = null;
let applying = false;
let bulkActionsPanel = null;
let bulkPanelRaf = null;
const bulkActionsAnchorMap = new WeakMap();

const BULK_ACTIONS_BOTTOM_INSET = 8;
const CONTROL_ROW_CLUSTER_TOLERANCE = 18;
const CONTROL_ROW_MAX_OFFSET = 140;
const COMPOSER_CONTROL_SELECTOR = [
  "button",
  "[role='button']",
  "[aria-label*='send' i]",
  "[aria-label*='attach' i]",
  "[aria-label*='file' i]",
  "[aria-label*='microphone' i]",
  "[aria-label*='voice' i]",
  "[data-testid*='send' i]",
  "[data-testid*='attach' i]",
  "[data-testid*='composer' i]",
].join(", ");

function setApplyingState(value) {
  applying = value;
  if (!bulkActionsPanel) return;
  const buttons = bulkActionsPanel.querySelectorAll("button");
  for (const btn of buttons) {
    btn.disabled = value;
  }
}

function getVisibleEntitiesFor(el) {
  if (!el) return [];
  const snapshot = getSnapshot(el);
  if (!snapshot?.entities?.length) return [];

  const ignored = getIgnoreSet(el);
  return snapshot.entities.filter((entity) => !ignored.has(ignoreKey(entity)));
}

function buildMaskedText(text, entities) {
  const sorted = [...entities].sort((a, b) => a.start - b.start);
  let out = "";
  let cursor = 0;

  for (const entity of sorted) {
    const start = Number(entity?.start);
    const end = Number(entity?.end);

    if (!Number.isFinite(start) || !Number.isFinite(end)) continue;
    if (start < cursor || end < start || end > text.length) continue;

    out += text.slice(cursor, start);
    out += `[${entity.type}]`;
    cursor = end;
  }

  out += text.slice(cursor);
  return out;
}

function ensureBulkActionsPanel() {
  if (bulkActionsPanel && document.documentElement.contains(bulkActionsPanel)) {
    return bulkActionsPanel;
  }

  // Clean up any stale/duplicate panels left behind by prior script runs.
  const stalePanels = document.querySelectorAll(".redactosaurus-bulk-actions");
  for (const stale of stalePanels) {
    stale.remove();
  }

  const panel = document.createElement("div");
  panel.className = "redactosaurus-bulk-actions";
  panel.innerHTML = `
    <button type="button" class="mask-all">Mask All</button>
    <button type="button" class="ignore-all">Ignore All</button>
  `;

  panel.querySelector(".mask-all").addEventListener("click", async () => {
    const el = activeEl;
    if (!el) return;

    const visible = getVisibleEntitiesFor(el);
    if (visible.length === 0) {
      updateBulkActionsPanel();
      return;
    }

    const snapshot = getSnapshot(el);
    const baseText = snapshot?.text ?? readText(el);
    const maskedText = buildMaskedText(baseText, visible);
    const ignoreSet = getIgnoreSet(el);

    for (const entity of visible) {
      ignoreSet.add(ignoreKey(entity));
    }

    hideGlobalTooltip();
    setApplyingState(true);
    try {
      writeReplace(el, maskedText);
      setSnapshot(el, { text: maskedText, entities: [] });
      await refreshOverlayFor(el);
    } finally {
      setApplyingState(false);
      updateBulkActionsPanel();
    }
  });

  panel.querySelector(".ignore-all").addEventListener("click", async () => {
    const el = activeEl;
    if (!el) return;

    const visible = getVisibleEntitiesFor(el);
    if (visible.length === 0) {
      updateBulkActionsPanel();
      return;
    }

    const ignoreSet = getIgnoreSet(el);
    for (const entity of visible) {
      ignoreSet.add(ignoreKey(entity));
    }

    const snapshot = getSnapshot(el);
    if (snapshot?.entities?.length) {
      snapshot.entities = snapshot.entities.filter(
        (entity) => !ignoreSet.has(ignoreKey(entity)),
      );
      snapshot.text = readText(el);
      setSnapshot(el, snapshot);
    }

    hideGlobalTooltip();
    await refreshOverlayFor(el);
    updateBulkActionsPanel();
  });

  document.documentElement.appendChild(panel);
  bulkActionsPanel = panel;
  return panel;
}

function nextAncestorElement(el) {
  if (!el) return null;
  if (el.parentElement) return el.parentElement;
  const root = el.getRootNode?.();
  if (root?.host && root.host.nodeType === Node.ELEMENT_NODE) {
    return root.host;
  }
  return null;
}

function isDisplayedControl(el) {
  if (!el) return false;
  const cs = window.getComputedStyle(el);
  if (cs.display === "none" || cs.visibility === "hidden") return false;
  const rect = el.getBoundingClientRect();
  return rect.width >= 12 && rect.height >= 12;
}

function collectComposerControls(anchor, inputEl, inputRect) {
  const controlsInRow = [];
  const controls = anchor.querySelectorAll(COMPOSER_CONTROL_SELECTOR);

  for (const control of controls) {
    if (control.closest(".redactosaurus-bulk-actions")) continue;
    if (inputEl.contains(control)) continue;
    if (!isDisplayedControl(control)) continue;

    const r = control.getBoundingClientRect();
    const centerY = (r.top + r.bottom) / 2;

    // Prefer controls in the lower composer region (under/near the input).
    if (r.bottom < inputRect.bottom - 24) continue;
    if (centerY > inputRect.bottom + CONTROL_ROW_MAX_OFFSET) continue;

    controlsInRow.push({ el: control, rect: r, centerY });
  }

  return controlsInRow;
}

function resolveComposerControlRow(anchor, inputEl, inputRect) {
  const controls = collectComposerControls(anchor, inputEl, inputRect);
  if (controls.length === 0) return null;

  controls.sort((a, b) => a.centerY - b.centerY);

  const rows = [];
  for (const item of controls) {
    let row = rows.find(
      (candidate) =>
        Math.abs(candidate.centerY - item.centerY) <=
        CONTROL_ROW_CLUSTER_TOLERANCE,
    );

    if (!row) {
      row = {
        centerY: item.centerY,
        controls: [],
        minX: item.rect.left,
        maxX: item.rect.right,
      };
      rows.push(row);
    }

    row.controls.push(item);
    row.minX = Math.min(row.minX, item.rect.left);
    row.maxX = Math.max(row.maxX, item.rect.right);

    const count = row.controls.length;
    row.centerY = ((row.centerY * (count - 1)) + item.centerY) / count;
  }

  rows.sort((a, b) => {
    if (b.controls.length !== a.controls.length) {
      return b.controls.length - a.controls.length;
    }
    return (
      Math.abs(a.centerY - inputRect.bottom) -
      Math.abs(b.centerY - inputRect.bottom)
    );
  });

  return rows[0] || null;
}

function countComposerControls(anchor, inputEl, inputRect) {
  return collectComposerControls(anchor, inputEl, inputRect).length;
}

function clamp(value, min, max) {
  return Math.min(Math.max(value, min), max);
}

function resolveControlRowCenterX(row, anchorRect, panelWidth) {
  if (!row?.controls?.length) {
    return anchorRect.width / 2;
  }

  const controls = [...row.controls].sort((a, b) => a.rect.left - b.rect.left);

  let bestGap = 0;
  let bestCenter = anchorRect.width / 2;

  for (let i = 0; i < controls.length - 1; i++) {
    const gapStart = controls[i].rect.right;
    const gapEnd = controls[i + 1].rect.left;
    const gap = gapEnd - gapStart;

    if (gap <= bestGap) continue;
    bestGap = gap;
    bestCenter = (gapStart + gapEnd) / 2 - anchorRect.left;
  }

  // If controls are tightly packed, keep centered in composer.
  if (bestGap < panelWidth * 0.55) {
    bestCenter = anchorRect.width / 2;
  }

  const horizontalPadding = Math.min(10, panelWidth / 4);
  const minX = panelWidth / 2 + horizontalPadding;
  const maxX = anchorRect.width - panelWidth / 2 - horizontalPadding;
  return clamp(bestCenter, minX, maxX);
}

function resolveBulkActionsAnchor(inputEl) {
  const cached = bulkActionsAnchorMap.get(inputEl);
  if (
    cached &&
    document.documentElement.contains(cached) &&
    document.documentElement.contains(inputEl) &&
    cached.contains(inputEl)
  ) {
    return cached;
  }

  const fallback = inputEl.parentElement;
  const inputRect = inputEl.getBoundingClientRect();

  let best = null;
  let current = fallback;
  let depth = 0;

  while (
    current &&
    current !== document.body &&
    current !== document.documentElement &&
    depth < 10
  ) {
    const rect = current.getBoundingClientRect();
    const extendsBelowInput = rect.bottom - inputRect.bottom >= 18;
    const controlCount = extendsBelowInput
      ? countComposerControls(current, inputEl, inputRect)
      : 0;

    if (controlCount >= 2) {
      best = current;
      break;
    }

    current = nextAncestorElement(current);
    depth++;
  }

  const anchor = best || fallback;
  if (anchor) {
    bulkActionsAnchorMap.set(inputEl, anchor);
  }
  return anchor;
}

function positionBulkActionsPanel(panel, el) {
  if (!panel || !el) return false;
  const anchor = resolveBulkActionsAnchor(el);
  if (!anchor) return false;
  if (!document.documentElement.contains(anchor)) return false;
  const inputRect = el.getBoundingClientRect();
  const row = resolveComposerControlRow(anchor, el, inputRect);

  // Attach inside composer container so editor internal scrolling does not move the panel.
  if (panel.parentElement !== anchor) {
    anchor.appendChild(panel);
  }

  // Absolute child needs a positioned container.
  if (window.getComputedStyle(anchor).position === "static") {
    anchor.style.position = "relative";
  }

  const anchorRect = anchor.getBoundingClientRect();
  const panelWidth = Math.max(panel.offsetWidth || 0, 120);

  if (row) {
    const x = resolveControlRowCenterX(row, anchorRect, panelWidth);
    const y = clamp(row.centerY - anchorRect.top, 0, anchorRect.height);

    panel.style.left = `${x}px`;
    panel.style.top = `${y}px`;
    panel.style.bottom = "auto";
    panel.style.right = "auto";
    panel.style.transform = "translate(-50%, -50%)";
    return true;
  }

  // Fallback when a control row cannot be detected.
  panel.style.left = "50%";
  panel.style.right = "auto";
  panel.style.top = "auto";
  panel.style.bottom = `${BULK_ACTIONS_BOTTOM_INSET}px`;
  panel.style.transform = "translateX(-50%)";
  return true;
}

function scheduleBulkActionsPanelUpdate() {
  if (bulkPanelRaf != null) return;
  bulkPanelRaf = requestAnimationFrame(() => {
    bulkPanelRaf = null;
    updateBulkActionsPanel();
  });
}

function updateBulkActionsPanel() {
  const panel = ensureBulkActionsPanel();

  if (!serviceEnabled || !activeEl || !isVisible(activeEl)) {
    panel.style.display = "none";
    panel.style.visibility = "";
    return;
  }

  if (!bulkActionsAllowedForSite) {
    panel.style.display = "none";
    panel.style.visibility = "";
    return;
  }

  if (readText(activeEl).trim().length === 0) {
    panel.style.display = "none";
    panel.style.visibility = "";
    return;
  }

  const visible = getVisibleEntitiesFor(activeEl);
  if (visible.length === 0) {
    panel.style.display = "none";
    panel.style.visibility = "";
    return;
  }

  panel.style.visibility = "hidden";
  panel.style.display = "flex";
  if (!positionBulkActionsPanel(panel, activeEl)) {
    panel.style.display = "none";
    panel.style.visibility = "";
    return;
  }
  panel.style.visibility = "visible";
}

function setActiveEl(el) {
  const candidate = resolveCandidateInput(el);
  if (!candidate || !isVisible(candidate)) return;
  if (activeEl === candidate) return;

  // Hide tooltips on previous active element
  if (activeEl) {
    hideGlobalTooltip();
  }

  activeEl = candidate;
  scheduleBulkActionsPanelUpdate();
}

// Bind tooltip buttons with callbacks that need access to module state
bindGlobalTooltipButtonsOnce(getIgnoreSet, (val) => {
  setApplyingState(val);
});

document.addEventListener(
  "focusin",
  (ev) => {
    if (!serviceEnabled || !siteProtectionEnabled) return;

    const candidate = resolveCandidateInput(ev.target);
    if (!candidate) return;
    attach(candidate);
    setActiveEl(candidate);
  },
  true,
);

document.addEventListener(
  "pointerdown",
  (ev) => {
    if (!serviceEnabled || !siteProtectionEnabled) return;

    const path = ev.composedPath?.() || [];
    let candidate = null;

    for (const node of path) {
      candidate = resolveCandidateInput(node);
      if (candidate) break;
    }

    if (!candidate) {
      candidate = resolveCandidateInput(ev.target);
    }
    if (!candidate) return;

    attach(candidate);
    setActiveEl(candidate);
  },
  true,
);

// ---------------- main attachment ----------------
const attached = new WeakSet();

const MUTATION_INIT_DEBOUNCE_MS = 400;
let initRunning = false;
let initQueued = false;
let mutationInitTimer = null;

const TARGET_SELECTORS = [
  "textarea",
  "input[type='text']",
  "input[type='search']",
  "input[type='email']",
  "input[type='url']",
  "input[type='tel']",
  "input:not([type])",
  "[contenteditable='true']",
  "[contenteditable='plaintext-only']",
  "[role='textbox']",
  "[aria-multiline='true']",
  ".ProseMirror",
  ".ql-editor",
  "[data-lexical-editor='true']",
  "[data-slate-editor='true']",
  "[data-testid*='prompt']",
  "[data-testid*='composer']",
  "[aria-label*='prompt' i]",
  "[aria-label*='message' i]",
  "[placeholder*='ask' i]",
  "[placeholder*='message' i]",
  "[placeholder*='prompt' i]",
].join(", ");

function findTargets() {
  const targets = [];
  const seen = new Set();

  for (const el of document.querySelectorAll(TARGET_SELECTORS)) {
    const candidate = resolveCandidateInput(el);
    if (!candidate || !isVisible(candidate)) continue;
    if (seen.has(candidate)) continue;

    // Skip Google AI Search chat elements
    if (isGoogleAISearch(candidate)) continue;

    // Skip Meta AI elements
    if (isMetaAI(candidate)) continue;

    // Skip DeepSeek elements
    if (isDeepSeek(candidate)) continue;

    seen.add(candidate);
    targets.push(candidate);
  }

  return targets;
}

async function runInitCycle() {
  if (initRunning) {
    initQueued = true;
    return;
  }

  initRunning = true;
  try {
    await init();
  } catch (err) {
    console.warn("[Redactosaurus] init failed:", err);
  } finally {
    initRunning = false;
    if (initQueued) {
      initQueued = false;
      void runInitCycle();
    }
  }
}

function requestInit() {
  void runInitCycle();
}

function requestInitFromMutation() {
  clearTimeout(mutationInitTimer);
  mutationInitTimer = setTimeout(() => {
    mutationInitTimer = null;
    requestInit();
  }, MUTATION_INIT_DEBOUNCE_MS);
}

async function refreshOverlayFor(el) {
  // Check global service state first
  if (!serviceEnabled) {
    removeOverlay(el);
    updateBulkActionsPanel();
    return;
  }

  const s = await getSiteSettings();
  bulkActionsAllowedForSite = s.source === "allowlist";
  if (!s.enabled) {
    removeOverlay(el);
    updateBulkActionsPanel();
    return;
  }

  if (activeEl && el !== activeEl) {
    updateBulkActionsPanel();
    return;
  }

  const obj = ensureOverlay(el);
  const text = readText(el);
  const snapshot = getSnapshot(el);
  const entities = snapshot?.entities || [];
  const ignored = getIgnoreSet(el);

  renderUnderlineOverlay(text, entities, obj.overlay, ignored);
  obj.syncScroll();

  // Always rebind events with fresh entities to handle text edits
  bindOverlayEvents(obj.overlay, el, entities, ignored);
  updateBulkActionsPanel();
}

async function clearDetectionsFor(el) {
  if (!el) return;
  const text = readText(el);
  setSnapshot(el, { text, entities: [] });
  await refreshOverlayFor(el);
  updateBulkActionsPanel();
}

function attach(el) {
  if (attached.has(el)) return;
  if (!siteProtectionEnabled) return;

  // Skip Google AI Search chat elements
  if (isGoogleAISearch(el)) return;

  // Skip Meta AI elements
  if (isMetaAI(el)) return;

  // Skip DeepSeek elements
  if (isDeepSeek(el)) return;

  attached.add(el);
  attachedElements.add(el); // Track for cleanup

  el.addEventListener("focus", () => setActiveEl(el), true);

  let lastDetectedText = "";
  let detectTimer = null;
  let nextInputForceDetect = false;
  let detectRevision = 0;

  function scheduleClearIfEmpty() {
    setTimeout(() => {
      const text = readText(el);
      if (text.trim().length !== 0) return;

      detectRevision++;
      clearTimeout(detectTimer);
      lastDetectedText = "";
      void clearDetectionsFor(el);
    }, 0);
  }

  async function queueDetection(forceDetect = false) {
    const revision = ++detectRevision;

    if (applying) return;

    // Check global service state
    if (!serviceEnabled) {
      removeOverlay(el);
      return;
    }

    const s = await getSiteSettings();
    bulkActionsAllowedForSite = s.source === "allowlist";
    if (!s.enabled) {
      removeOverlay(el);
      return;
    }

    const text = readText(el);
    await clearDetectionsFor(el);

    clearTimeout(detectTimer);
    if (text.trim().length === 0) {
      lastDetectedText = "";
      return;
    }

    detectTimer = setTimeout(async () => {
      if (revision !== detectRevision) return;

      const latestText = readText(el);
      if (latestText.trim().length === 0) {
        if (revision !== detectRevision) return;
        lastDetectedText = "";
        await clearDetectionsFor(el);
        return;
      }

      // Skip detection if text hasn't changed
      if (!forceDetect && latestText === lastDetectedText) return;
      lastDetectedText = latestText;

      const resp = await requestDetect(latestText);
      if (revision !== detectRevision) return;
      if (!resp?.ok) return;

      const snapshot = { text: latestText, entities: resp.result?.entities || [] };
      setSnapshot(el, snapshot);

      await refreshOverlayFor(el);
      updateBulkActionsPanel();
    }, forceDetect ? 120 : 500);
  }

  el.addEventListener("beforeinput", (ev) => {
    const inputType = ev?.inputType || "";
    if (inputType === "insertFromPaste" || inputType === "insertFromDrop") {
      nextInputForceDetect = true;
    }
    if (inputType.startsWith("delete") || inputType === "deleteByCut") {
      scheduleClearIfEmpty();
    }
  });

  el.addEventListener("paste", () => {
    nextInputForceDetect = true;
    setTimeout(() => {
      void queueDetection(true);
    }, 0);
  });

  el.addEventListener("drop", () => {
    nextInputForceDetect = true;
    setTimeout(() => {
      void queueDetection(true);
    }, 0);
  });

  el.addEventListener("cut", () => {
    scheduleClearIfEmpty();
  });

  el.addEventListener("input", () => {
    const forceDetect = nextInputForceDetect;
    nextInputForceDetect = false;
    void queueDetection(forceDetect);
  });
}

async function init() {
  const s = await getSiteSettings();
  siteProtectionEnabled = !!s.enabled;
  bulkActionsAllowedForSite = s.source === "allowlist";

  if (!s.enabled) {
    for (const el of attachedElements) {
      removeOverlay(el);
    }
    updateBulkActionsPanel();
    return;
  }

  const targets = findTargets();
  for (const el of targets) attach(el);

  const focused = resolveCandidateInput(document.activeElement);
  if (focused && isVisible(focused)) {
    attach(focused);
    setActiveEl(focused);
  }

  updateBulkActionsPanel();
}

chrome.runtime.onMessage.addListener((msg) => {
  if (msg?.type === "PII_SITE_SETTINGS_UPDATED") {
    requestInit();
  }

  if (msg?.type === "SERVICE_STATE_CHANGED") {
    serviceEnabled = msg.enabled;
    if (!serviceEnabled) {
      // Remove all overlays when service is disabled
      for (const el of attachedElements) {
        removeOverlay(el);
      }
      // Also hide any open tooltips
      hideGlobalTooltip();
      updateBulkActionsPanel();
    } else {
      // Re-initialize when service is enabled
      requestInit();
    }
  }
});

const obs = new MutationObserver(() => {
  if (!serviceEnabled || !siteProtectionEnabled) return;
  requestInitFromMutation();
});
obs.observe(document.documentElement, { childList: true, subtree: true });

window.addEventListener("resize", scheduleBulkActionsPanelUpdate, {
  passive: true,
});

requestInit();