/**
 * capture.js — client-side session-context capture for the Feedback feature.
 *
 * Exposes window.FeedbackCapture with pure capture primitives (no network, no
 * app-specific closure state). The console wires these into its submit/flush
 * flow and pushes on-screen events into the ring buffer at its render points.
 *
 *   FeedbackCapture.sessionId          — stable per-tab session id
 *   FeedbackCapture.pushLog(entry)     — record one on-screen event
 *   FeedbackCapture.getLogJSON()       — serialize the buffer to a JSON string
 *   FeedbackCapture.clearLog()         — reset the buffer
 *   FeedbackCapture.buildSnapshot()    — Promise<Blob> single self-contained page
 *
 * Interaction log scope (FR-014): callers push ONLY content that is visible on
 * screen. This module never reads tokens, keys, or storage — it only holds what
 * it is handed.
 */
(function () {
  'use strict';

  var SESSION_KEY = 'feedback_session_id';
  var MAX_ENTRIES = 500; // bound memory for long / continuous sessions

  function _uuid() {
    try { return crypto.randomUUID(); }
    catch (_) { return 'sess-' + Date.now() + '-' + Math.random().toString(16).slice(2); }
  }

  var sessionId;
  try {
    sessionId = sessionStorage.getItem(SESSION_KEY) || _uuid();
    sessionStorage.setItem(SESSION_KEY, sessionId);
  } catch (_) {
    sessionId = _uuid();
  }

  var _buffer = [];

  /**
   * Record one on-screen event.
   * @param {{role?:string, kind?:string, text?:string}} entry
   *   role: 'user' | 'agent' | 'system'
   *   kind: 'input' | 'output' | 'progress' | 'step' | 'error'
   */
  function pushLog(entry) {
    entry = entry || {};
    var text = entry.text == null ? '' : String(entry.text);
    if (text.length > 4000) text = text.slice(0, 4000) + '…';
    _buffer.push({
      ts: new Date().toISOString(),
      role: entry.role || 'system',
      kind: entry.kind || 'output',
      text: text
    });
    if (_buffer.length > MAX_ENTRIES) _buffer.splice(0, _buffer.length - MAX_ENTRIES);
  }

  function getLogJSON() {
    return JSON.stringify(_buffer);
  }

  function getLogCount() {
    return _buffer.length;
  }

  function clearLog() {
    _buffer = [];
  }

  // Selectors whose content the console hides behind a click: collapsed finding
  // groups, unselected tab panes, and panels that only appear once a step
  // finishes. A snapshot exists to show a reviewer WHAT THE USER GOT, and the
  // generated artifacts — the findings by category, the refreshed post, the
  // before/after review — all live behind one of these. They are present in the
  // DOM either way, but a raw clone opens collapsed, so the reviewer sees an
  // empty shell and concludes nothing was generated.
  //
  // Each entry adds `cls` to every element matching `sel`, which is exactly what
  // the console's own click handlers do. Keep this list in sync with the CSS in
  // console.html (.out/.show, .fgroup/.open, .tabpane/.show, .intensity/.show).
  var EXPAND_RULES = [
    { sel: '.out', cls: 'show' },        // step panels (scan results, refine results, feedback)
    { sel: '.fgroup', cls: 'open' },     // finding groups: broken links, SEO, AEO, GEO, …
    { sel: '.tabpane', cls: 'show' },    // link swaps / refreshed post / full review
    { sel: '.intensity', cls: 'show' }
  ];

  // Elements the console toggles with an INLINE display:none. Cleared by id, not
  // blanket-cleared: #paywallModal is also inline-hidden and is a full-screen
  // fixed overlay — un-hiding that would black out the whole snapshot.
  var UNHIDE_IDS = ['postMd', 'postRender', 'refineTabs'];

  var SNAPSHOT_STYLE = [
    '/* injected by capture.js — force every collapsible open in the snapshot */',
    '.out,.tabpane,.intensity{display:block!important}',
    '.fgbody{display:block!important}',
    '.tabs{display:flex!important}',
    'details{display:block!important}',
    '.snapshot-banner{font:600 12px/1.5 system-ui,sans-serif;background:#1d3b12;',
    'color:#c8f560;padding:8px 14px;border-bottom:1px solid #2f5c1e}'
  ].join('\n');

  /**
   * Reveal, in the CLONE only, everything the live page keeps one click away.
   * Never touches the live DOM — the user's screen is left exactly as it was.
   */
  function _expandCollapsed(clone) {
    var i, els;

    for (i = 0; i < EXPAND_RULES.length; i++) {
      els = clone.querySelectorAll(EXPAND_RULES[i].sel);
      for (var j = 0; j < els.length; j++) els[j].classList.add(EXPAND_RULES[i].cls);
    }

    els = clone.querySelectorAll('details');
    for (i = 0; i < els.length; i++) els[i].setAttribute('open', '');

    for (i = 0; i < UNHIDE_IDS.length; i++) {
      var el = clone.querySelector('#' + UNHIDE_IDS[i]);
      if (el && el.style && el.style.display === 'none') el.style.display = '';
    }

    // A <select> serializes its current value only through the `selected`
    // ATTRIBUTE, and cloneNode copies attributes — not the user's live choice.
    // So the value must be read off the LIVE select: on the clone,
    // option.selected still reflects the markup default (ultra), which is how a
    // snapshot ends up claiming a rewrite intensity the user never picked.
    // Live and clone share document order.
    var liveSelects = document.querySelectorAll('select');
    var cloneSelects = clone.querySelectorAll('select');
    for (i = 0; i < cloneSelects.length && i < liveSelects.length; i++) {
      var chosen = liveSelects[i].selectedIndex;
      var opts = cloneSelects[i].options;
      for (var k = 0; k < opts.length; k++) {
        if (k === chosen) opts[k].setAttribute('selected', '');
        else opts[k].removeAttribute('selected');
      }
    }

    // Same reasoning for text inputs: `value` is a live property, and the
    // attribute a clone carries is the ORIGINAL one. Without this the snapshot
    // shows empty URL boxes for a scan that plainly ran.
    var liveInputs = document.querySelectorAll('input');
    var cloneInputs = clone.querySelectorAll('input');
    for (i = 0; i < cloneInputs.length && i < liveInputs.length; i++) {
      if (liveInputs[i].type === 'hidden') continue;   // e.g. the API key box
      cloneInputs[i].setAttribute('value', liveInputs[i].value || '');
    }
    var liveAreas = document.querySelectorAll('textarea');
    var cloneAreas = clone.querySelectorAll('textarea');
    for (i = 0; i < cloneAreas.length && i < liveAreas.length; i++) {
      cloneAreas[i].textContent = liveAreas[i].value || '';
    }

    // The refreshed post and the before/after review are rendered into iframes
    // whose srcdoc is assigned as a PROPERTY. That reflects to the attribute, so
    // a clone normally carries it — but this is the single most valuable thing
    // in the whole snapshot, so copy it across explicitly rather than trusting
    // reflection. Live and clone iframes are in the same document order.
    var live = document.querySelectorAll('iframe');
    var cloned = clone.querySelectorAll('iframe');
    for (i = 0; i < cloned.length && i < live.length; i++) {
      if (live[i].srcdoc) cloned[i].setAttribute('srcdoc', live[i].srcdoc);
    }

    var style = document.createElement('style');
    style.textContent = SNAPSHOT_STYLE;
    var head = clone.querySelector('head');
    if (head) head.appendChild(style);

    var body = clone.querySelector('body');
    if (body) {
      var banner = document.createElement('div');
      banner.className = 'snapshot-banner';
      banner.textContent = 'Snapshot — collapsed sections and hidden tabs were '
        + 'expanded at capture time, so every generated artifact is visible here '
        + 'even if the user never clicked into it.';
      body.insertBefore(banner, body.firstChild);
    }
  }

  function _blobToDataURL(blob) {
    return new Promise(function (resolve, reject) {
      var fr = new FileReader();
      fr.onload = function () { resolve(fr.result); };
      fr.onerror = reject;
      fr.readAsDataURL(blob);
    });
  }

  /**
   * Serialize the current page into ONE self-contained HTML file: clone the DOM,
   * expand everything the console keeps collapsed, drop scripts (so the snapshot
   * never re-runs or re-fetches), and inline external images as data: URIs.
   * Inline <style> and iframe srcdoc content are already self-contained.
   * Returns a text/html Blob that opens offline.
   *
   * Expanding BEFORE the scripts are stripped matters: with no JS in the
   * snapshot, nothing can open a collapsed group after the fact. Whatever is
   * closed at serialization time is unreadable forever.
   */
  async function buildSnapshot() {
    var clone = document.documentElement.cloneNode(true);

    _expandCollapsed(clone);

    // Remove scripts — a snapshot must be inert.
    var scripts = clone.querySelectorAll('script');
    for (var i = 0; i < scripts.length; i++) scripts[i].remove();

    // Inline external images as data URIs (best-effort; leave as-is on failure).
    var imgs = Array.prototype.slice.call(clone.querySelectorAll('img'));
    await Promise.all(imgs.map(async function (img) {
      var src = img.getAttribute('src');
      if (!src || src.indexOf('data:') === 0) return;
      try {
        var abs = new URL(src, document.baseURI).href;
        var resp = await fetch(abs);
        if (!resp.ok) return;
        var blob = await resp.blob();
        img.setAttribute('src', await _blobToDataURL(blob));
      } catch (_) { /* leave the original src */ }
    }));

    var html = '<!doctype html>\n' + clone.outerHTML;
    return new Blob([html], { type: 'text/html' });
  }

  window.FeedbackCapture = {
    sessionId: sessionId,
    pushLog: pushLog,
    getLogJSON: getLogJSON,
    getLogCount: getLogCount,
    clearLog: clearLog,
    buildSnapshot: buildSnapshot
  };
})();