/**
 * index.js - Popup logic for the Goon Plugin.
 * Runs inside the popup; scans the current window's tabs for videos
 * and stores the results for the viewer to consume.
 */

const STORAGE_KEY = 'goon_videos';
const TAGGED_KEY = 'goon_tagged';

// Set to true to enable verbose console output in the popup.
const DEBUG = true;  // TEMP: enabled for debugging — revert to false when done

function log(...args) { if (DEBUG) console.log('[goon]', ...args); }
function warn(...args) { if (DEBUG) console.warn('[goon]', ...args); }

/** Log a message to the active tab's page console (visible to the user in DevTools). */
async function logToPage(msg) {
  if (!DEBUG) return;
  try {
    const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
    if (!tab) return;
    await chrome.scripting.executeScript({
      target: { tabId: tab.id },
      func: (m) => { console.log('[goon-page]', m); },
      args: [msg],
    });
  } catch { /* ignore — tab may have navigated away */ }
}

// UI references
const findBtn = document.getElementById('find-btn');
const clearBtn = document.getElementById('clear-btn');
const openBtn = document.getElementById('open-btn');
const statusEl = document.getElementById('status');
const listEl = document.getElementById('video-list');
const btnRow = document.getElementById('btn-row');

listEl.style.wordBreak = 'break-word';
listEl.style.whiteSpace = 'pre-wrap';

/* ======================================================================== */
/* UI helpers                                                               */
/* ======================================================================== */

function setStatus(msg) {
  statusEl.textContent = msg;
  log(msg);
}

/** Load the current video list and tags from storage. */
function loadVideos() {
  return chrome.storage.local.get([STORAGE_KEY, TAGGED_KEY]).then(data => ({
    videos: data[STORAGE_KEY] || [],
    tags: data[TAGGED_KEY] || [],
  }));
}

/** Render the video list UI from stored video entries. */
function renderList(videos) {
  listEl.innerHTML = '';
  if (!videos || videos.length === 0) {
    listEl.style.display = 'none';
    return;
  }
  listEl.style.display = 'block';

  for (const video of videos) {
    const link = document.createElement('a');
    link.className = 'video-item';
    link.href = video.src || video.url || '';
    link.textContent = video.label ? `${video.label}: ${link.href}` : link.href;
    link.target = '_blank';
    listEl.appendChild(link);
  }

  // Copy all URLs button
  const copyBtn = document.createElement('button');
  copyBtn.className = 'copy-btn';
  copyBtn.textContent = 'Copy All URLs';
  copyBtn.addEventListener('click', () => {
    const urls = videos.map(v => v.src || v.url);
    navigator.clipboard.writeText(urls.join('\n')).then(() => {
      copyBtn.textContent = 'Copied!';
      setTimeout(() => { copyBtn.textContent = 'Copy All URLs'; }, 1500);
    });
  });
  listEl.appendChild(copyBtn);
}

/** Show the main button row and render saved videos. */
function showActions() {
  btnRow.style.display = 'flex';
  loadVideos().then(({ videos, tags }) => {
    if (videos.length > 0) {
      const items = videos.map((video, i) => ({
        src: video.src || video.url || '',
        label: tags[i],
      }));
      renderList(items);
      setStatus(`Using ${videos.length} video(s) from last search.`);
    } else {
      setStatus('');
    }
  });
}

/* ======================================================================== */
/* HLS deep probe - runs in target page context via executeScript           */
/* ======================================================================== */

/**
 * Deep probe a page for HLS manifest URLs.
 * Walks known player objects, video elements, inline scripts, config globals,
 * and interceptor-collected data.
 * Returns an array of { url, player } objects.
 */
function m3u8DeepProbeFn() {
  const manifests = [];
  const seen = new Set();

  // DEBUG: Log probe activity to console
  function probeLog(...args) {
    try { console.log('[goon-probe]', ...args); } catch(e) {}
  }
  probeLog('Deep probe started on:', window.location.href, 'World:', typeof chrome !== 'undefined' ? 'ISOLATED' : 'MAIN');

  // Helpers available in the MAIN world context
  function resolveUrl(url) {
    if (!url) return null;
    try {
      if (url.startsWith('//')) return 'https:' + url;
      if (url.startsWith('http')) return url;
      return new URL(url, window.location.origin).href;
    } catch { return null; }
  }

  function isManifestUrl(url) {
    if (!url) return false;
    const u = url.toLowerCase();
    return u.includes('.m3u8') || u.includes('.hlsvod') ||
           (u.includes('/hls/') && u.includes('http')) ||
           (u.includes('/playlist') && u.includes('http')) ||
           (u.includes('/manifest') && u.includes('http'));
  }

  function walk(obj, path, depth) {
    if (depth > 5) return;
    if (typeof obj === 'string') {
      const match = obj.match(/https?:\/\/[^"'`\s)]+?(?:\.m3u8|\.hlsvod|\/hls\/|\/playlist[^"'`\s]*|\/manifest[^"'`\s]*)[^"'`\s)]*/gi);
      if (match) {
        for (const u of match) {
          const resolved = resolveUrl(u);
          if (resolved && isManifestUrl(resolved) && !seen.has(resolved)) {
            seen.add(resolved); manifests.push({ url: resolved, player: path });
          }
        }
      }
      return;
    }
    if (!obj || typeof obj !== 'object') return;
    try {
      for (const k of Object.keys(obj)) {
        walk(obj[k], `${path}.${k}`, depth + 1);
      }
    } catch { /* avoid circular ref errors */ }
  }

  // Standard <video> element attributes — skip these when scanning for custom
  // HLS player properties. Define here so it's available for Strategy A2 onward.
  const STANDARD_VIDEO_ATTRS = new Set([
    'src', 'srcObject', 'crossOrigin', 'preload', 'autoplay', 'muted',
    'defaultMuted', 'loop', 'controls', 'controlsList', 'disableRemotePlayback',
    'volume', 'playbackRate', 'defaultPlaybackRate', 'playbackState',
    'currentTime', 'startTime', 'duration', 'buffered', 'seekable',
    'played', 'seeking', 'ended', 'readyState', 'networkState',
    'videoWidth', 'videoHeight', 'error', 'textTracks', 'videoTracks',
    'audioTracks', 'loadingBeganAt', 'label', 'id', 'className',
    'classList', 'style', 'attributes', 'dataset', 'innerHTML', 'textContent',
    'outerHTML', 'outerText', 'slot', 'accessKey', 'draggable', 'hidden',
    'lang', 'spellcheck', 'tabIndex', 'title', 'translate',
    'width', 'height', 'poster', 'referrerPolicy',
  ]);

  // Strategy A: Known player globals (shallow + deep)
  const playerGlobals = [
    'hls', 'Hls', 'videojs', 'Video', 'flowplayer', 'jwplayer',
    '__hls', '__hls_player', 'player', 'videoPlayer', 'mainPlayer',
    'fhplayer', '__pj', 'playerInstance',
    'PHPlayer', 'fh', '__phPlayer', '__ph', 'phPlayer', 'phPlayerInstance',
    'bitgravity', 'bgPlayer', 'FG', 'Fhls',
  ];
  let strategyACount = 0;
  for (const name of playerGlobals) {
    const obj = window[name];
    if (!obj || typeof obj === 'function') continue;
    probeLog('Strategy A: found global', name, '(not function)');
    for (const key of ['url', '_url', 'src', 'manifestUrl', 'hlsUrl', 'playlistUrl', 'hls_url', 'mp4_url']) {
      if (typeof obj[key] === 'string' && isManifestUrl(obj[key])) {
        const resolved = resolveUrl(obj[key]);
        if (resolved && !seen.has(resolved)) { seen.add(resolved); manifests.push({ url: resolved, player: `${name}.${key}` }); strategyACount++; }
      }
    }
    walk(obj, name, 0);
  }
  probeLog('Strategy A (player globals): found', strategyACount, 'new manifests');

  // Strategy A2: Hls instances — iterate all video elements and check if any
  // HLS player instance (created via new Hls()) is bound to them. Even if our
  // attachMedia patch missed the call (timing race), the player object still
  // exists on the video element with a .url property.
  let strategyA2Count = 0;
  try {
    for (const v of document.querySelectorAll('video')) {
      // Check all custom properties on the video for HLS-like instances
      for (const key of Object.keys(v)) {
        if (STANDARD_VIDEO_ATTRS.has(key)) continue;
        const obj = v[key];
        if (!obj || typeof obj !== 'object') continue;
        // HLS instances have .url, .media, .config, .networkControls, etc.
        if (typeof obj.url === 'string' && isManifestUrl(obj.url)) {
          const resolved = resolveUrl(obj.url);
          if (resolved && !seen.has(resolved)) {
            seen.add(resolved);
            manifests.push({ url: resolved, player: `video.${key}.url (Hls instance)` });
            strategyA2Count++;
            probeLog('Strategy A2: found Hls instance on video.', key, '- url:', obj.url.substring(0, 100));
          }
        }
      }
    }
  } catch(e) { /* ignore */ }
  probeLog('Strategy A2 (Hls instances on video): found', strategyA2Count, 'new manifests');

  // Strategy B: Video element HLS instances
  // B1: Scan video elements for HLS instance references stored by players.
  // NOTE: Hls.cast() in hls.js is a TypeScript type-cast utility (identity function),
  // NOT a reverse-lookup. It returns its input unchanged — Hls.cast(video) just
  // returns the <video> element with no .url property. Real players store the
  // HLS instance directly on the video element as a custom property.
  // Only check non-standard properties (skip built-in <video> attributes).
  const allVideos = document.querySelectorAll('video');
  probeLog('Strategy B: found', allVideos.length, '<video> elements');
  let strategyBCount = 0;
  for (const v of allVideos) {
    for (const key of Object.keys(v)) {
      if (STANDARD_VIDEO_ATTRS.has(key)) continue;
      const obj = v[key];
      if (!obj || typeof obj !== 'object') continue;
      // Check for common HLS instance patterns on video elements
      if (typeof obj === 'object' && typeof obj.url === 'string' && isManifestUrl(obj.url)) {
        probeLog('Strategy B1: found HLS instance on video.', key, '- url:', obj.url.substring(0, 100));
        const resolved = resolveUrl(obj.url);
        if (resolved && !seen.has(resolved)) { seen.add(resolved); manifests.push({ url: resolved, player: `video.${key}.url` }); strategyBCount++; }
      }
      // Walk deep into player objects attached to video elements
      walk(obj, `video.${key}`, 0);
    }
  }
  probeLog('Strategy B1 (video custom props): found', strategyBCount, 'new manifests');

  // B2: Check interceptor-set manifest annotation on video elements
  let strategyB2Count = 0;
  for (const v of document.querySelectorAll('video')) {
    if (v._goon_hls_manifest && !seen.has(v._goon_hls_manifest)) {
      seen.add(v._goon_hls_manifest);
      manifests.push({ url: v._goon_hls_manifest, player: 'video._goon_hls_manifest' });
      strategyB2Count++;
      probeLog('Strategy B2: found _goon_hls_manifest on video:', v._goon_hls_manifest.substring(0, 100));
    }
  }
  probeLog('Strategy B2 (interceptor annotation): found', strategyB2Count, 'new manifests');

  // Strategy C: Inline scripts
  let strategyCCount = 0;
  for (const script of document.querySelectorAll('script:not([src])')) {
    const text = script.textContent || '';
    const matches = text.match(/https?:\/\/[^"'\s]+.(m3u8|hlsvod)[^"'\s]*/gi);
    if (matches) {
      for (const u of matches) {
        if (!seen.has(u)) { seen.add(u); manifests.push({ url: u, player: 'inline-script' }); strategyCCount++; }
      }
    }
  }
  probeLog('Strategy C (inline scripts): found', strategyCCount, 'new manifests');

  // Strategy D: Config globals
  const configKeys = ['__dataLayer', '__INITIAL_STATE__', 'config', '__NEXT_DATA__', '__PRELOADED_STATE__', 'appData', 'pageData', '__data'];
  let preDCount = manifests.length;
  for (const name of configKeys) {
    const obj = window[name];
    if (obj && typeof obj === 'object') {
      probeLog('Strategy D: walking config global', name);
      walk(obj, name, 0);
    }
  }
  probeLog('Strategy D (config globals): found', manifests.length - preDCount, 'new manifests');

  // Strategy E: Interceptor-collected manifests — the most reliable source.
  // The main-world interceptors (injected at document_start) capture .m3u8 URLs
  // from XHR, fetch, and Hls.prototype.loadSource/attachMedia calls, and store
  // them in window.__goon_plugin_data.manifests[]. This was the original
  // Strategy 3/6 on master that was accidentally dropped during refactoring.
  // For dynamic playlists, the interceptors also poll Hls instances via Hls.cast()
  // and extract internal state (levels, url) — these URLs may not end in .m3u8.
  let preECount = manifests.length;
  if (window.__goon_plugin_data && Array.isArray(window.__goon_plugin_data.manifests)) {
    probeLog('Strategy E: __goon_plugin_data has', window.__goon_plugin_data.manifests.length, 'interceptor manifests');
    for (const url of window.__goon_plugin_data.manifests) {
      if (url && typeof url === 'string' && !seen.has(url)) {
        seen.add(url);
        manifests.push({ url, player: '__goon_plugin_data' });
      }
    }
  } else {
    probeLog('Strategy E: __goon_plugin_data missing or has no manifests array', {
      hasData: !!window.__goon_plugin_data,
      hasArray: window.__goon_plugin_data ? Array.isArray(window.__goon_plugin_data.manifests) : false,
    });
  }
  probeLog('Strategy E (interceptor data): found', manifests.length - preECount, 'new manifests');

  // Strategy F: Dynamic playlist fallback — scan video elements for Hls-like
  // instances and extract ANY URL, not just .m3u8. Sites like Pornhub use
  // HLS.js dynamic playlists where the "manifest" is generated in-memory,
  // so the URL might be a blob:, CDN endpoint, or data URI.
  let strategyFCount = 0;
  try {
    for (const v of document.querySelectorAll('video')) {
      for (const key of Object.keys(v)) {
        if (STANDARD_VIDEO_ATTRS.has(key)) continue;
        const obj = v[key];
        if (!obj || typeof obj !== 'object') continue;
        // Look for Hls-like objects: have .url, .levels, .attachMedia, etc.
        const isHlsLike = (typeof obj.url === 'string' && obj.url.length > 5) ||
                          (obj.levels && Array.isArray(obj.levels)) ||
                          (typeof obj.attachMedia === 'function') ||
                          (typeof obj.loadSource === 'function');
        if (!isHlsLike) continue;
        // Extract URL without isManifestUrl filter
        if (typeof obj.url === 'string' && obj.url.length > 5 && !seen.has(obj.url)) {
          const resolved = resolveUrl(obj.url) || obj.url;
          // Skip obvious media segments
          const u = resolved.toLowerCase();
          if (u.includes('.ts') || u.includes('.m4s') || u.includes('.aac')) continue;
          seen.add(resolved);
          manifests.push({ url: resolved, player: `video.${key}.url (dynamic HLS)` });
          strategyFCount++;
          probeLog('Strategy F: found dynamic HLS URL on video.', key, ':', resolved.substring(0, 150));
        }
        // Extract level URIs from levels array
        if (obj.levels && Array.isArray(obj.levels)) {
          for (let li = 0; li < obj.levels.length; li++) {
            const lvl = obj.levels[li];
            if (lvl && lvl.uri && !seen.has(lvl.uri)) {
              const resolved = resolveUrl(lvl.uri) || lvl.uri;
              seen.add(resolved);
              manifests.push({ url: resolved, player: `video.${key}.levels[${li}].uri (dynamic)` });
              strategyFCount++;
              probeLog('Strategy F: found level URI:', resolved.substring(0, 120));
            }
            // Also check details.uri (populated after playlist load)
            if (lvl && lvl.details && lvl.details.uri && !seen.has(lvl.details.uri)) {
              const resolved = resolveUrl(lvl.details.uri) || lvl.details.uri;
              seen.add(resolved);
              manifests.push({ url: resolved, player: `video.${key}.levels[${li}].details.uri (dynamic)` });
              strategyFCount++;
              probeLog('Strategy F: found level details.uri:', resolved.substring(0, 120));
            }
          }
        }
      }
    }
  } catch(e) { /* ignore */ }
  probeLog('Strategy F (dynamic HLS fallback): found', strategyFCount, 'new manifests');

  // Strategy G: Non-enumerable + Symbol property detection on video elements.
  // Object.keys() only returns enumerable string properties. Players like es6player
  // hide instances via Object.defineProperty(enumerable:false) or Symbol keys.
  // This runs in main-world via executeScript, so getOwnPropertyNames/Symbols work.
  let strategyGCount = 0;
  try {
    for (const v of document.querySelectorAll('video')) {
      // Non-enumerable string properties
      const nonEnumProps = Object.getOwnPropertyNames(v);
      for (const key of nonEnumProps) {
        if (STANDARD_VIDEO_ATTRS.has(key)) continue;
        try {
          const obj = v[key];
          if (!obj || typeof obj !== 'object') continue;

          // Check if this object looks like an HLS instance (same heuristics as interceptors)
          const isHlsLike = typeof obj.url === 'string' && obj.url.length > 5 ||
                            (obj.levels && Array.isArray(obj.levels)) ||
                            typeof obj.attachMedia === 'function' ||
                            typeof obj.loadSource === 'function' ||
                            typeof obj.getConfig === 'function' ||
                            typeof obj.detachMedia === 'function' ||
                            typeof obj.destroy === 'function' ||
                            (obj.networkControls && typeof obj.networkControls === 'object');

          if (isHlsLike) {
            probeLog('Strategy G: found HLS-like object on video via non-enumerable prop', key);
            // Extract URL from non-enumerable property
            if (typeof obj.url === 'string' && obj.url.length > 5) {
              const resolved = resolveUrl(obj.url);
              if (resolved && !seen.has(resolved)) {
                seen.add(resolved);
                manifests.push({ url: resolved, player: `video[G].${key}.url` });
                strategyGCount++;
              }
            }
            // Extract level URIs
            if (obj.levels && Array.isArray(obj.levels)) {
              for (let gi = 0; gi < obj.levels.length; gi++) {
                const lvl = obj.levels[gi];
                if (lvl && lvl.uri && !seen.has(lvl.uri)) {
                  const resolved = resolveUrl(lvl.uri) || lvl.uri;
                  seen.add(resolved);
                  manifests.push({ url: resolved, player: `video[G].${key}.levels[${gi}].uri` });
                  strategyGCount++;
                }
              }
            }
          } else {
            // Also deep-walk nested objects for URL-like values (even without HLS signatures)
            if (typeof obj === 'object' && obj !== null) {
              walk(obj, `video[G].${key}`, 0);
            }
          }
        } catch(e) { /* circular or inaccessible */ }
      }

      // Symbol properties
      const symbolProps = Object.getOwnPropertySymbols(v);
      for (const symKey of symbolProps) {
        try {
          const symObj = v[symKey];
          if (!symObj || typeof symObj !== 'object') continue;
          probeLog('Strategy G: video has Symbol prop', symKey.toString());

          // Check HLS signatures on symbols too
          if (typeof symObj.url === 'string' && symObj.url.length > 5) {
            const resolved = resolveUrl(symObj.url);
            if (resolved && !seen.has(resolved)) {
              seen.add(resolved);
              manifests.push({ url: resolved, player: `video[G].${symKey.toString()}.url` });
              strategyGCount++;
            }
          }
          if (symObj.levels && Array.isArray(symObj.levels)) {
            for (let gi = 0; gi < symObj.levels.length; gi++) {
              const lvl = symObj.levels[gi];
              if (lvl && lvl.uri && !seen.has(lvl.uri)) {
                const resolved = resolveUrl(lvl.uri) || lvl.uri;
                seen.add(resolved);
                manifests.push({ url: resolved, player: `video[G].${symKey.toString()}.levels[${gi}].uri` });
                strategyGCount++;
              }
            }
          }
          // Deep-walk nested objects
          walk(symObj, `video[G].${symKey.toString()}`, 0);
        } catch(e) { /* inaccessible */ }
      }
    }
  } catch(e) { /* ignore */ }
  probeLog('Strategy G (non-enumerable/Symbol props): found', strategyGCount, 'new manifests');

  // Strategy H: Full window global scan — enumerate ALL objects on window, not just
  // known player names. Filter out built-ins and walk any object that looks like a
  // player container (.url, .levels, .config with HLS keys, .media reference).
  let strategyHCount = 0;
  try {
    const windowKeys = Object.keys(window);
    for (const key of windowKeys) {
      const val = window[key];
      // Skip primitives
      if (typeof val === 'function' || typeof val === 'string' ||
          typeof val === 'number' || typeof val === 'boolean' ||
          val === null || val === undefined) continue;
      // Skip DOM elements directly on window
      if (val && typeof val.nodeType === 'number') continue;
      if (typeof val !== 'object') continue;

      // Quick check: does this object have any player-like keys?
      let hasPlayerKey = false;
      try {
        const subKeys = Object.keys(val).slice(0, 50); // limit scan depth for performance
        hasPlayerKey = subKeys.some(k => {
          const lk = k.toLowerCase();
          return lk.includes('hls') || lk.includes('player') || lk.includes('video') ||
                 lk.includes('manifest') || lk.includes('source') || lk.includes('level') ||
                 lk.includes('playlist') || lk.includes('stream') || lk === 'url' ||
                 lk === 'config' || lk === 'media' || lk === 'levels' ||
                 lk === 'width' || lk === 'height' || lk === 'volume';
        });
      } catch { hasPlayerKey = false; }
      if (!hasPlayerKey) continue;

      probeLog('Strategy H: window global', key, 'has player-like keys');
      // Deep-walk this object for HLS instances and manifest URLs
      walk(val, `window[H].${key}`, 0);
      if (typeof val.url === 'string' && isManifestUrl(val.url)) {
        const resolved = resolveUrl(val.url);
        if (resolved && !seen.has(resolved)) {
          seen.add(resolved);
          manifests.push({ url: resolved, player: `window[H].${key}.url` });
          strategyHCount++;
        }
      }
    }
  } catch(e) { /* ignore */ }
  probeLog('Strategy H (full window scan): found', strategyHCount, 'new manifests');

  probeLog('Deep probe complete. Total unique manifests found:', manifests.length);
  if (manifests.length > 0) {
    probeLog('Manifest summary:', JSON.stringify(manifests.map(m => ({ url: m.url.substring(0, 100), player: m.player }))));
  }
  return manifests;
}

/* ======================================================================== */
/* Video scraper - runs in target page context via executeScript            */
/* ======================================================================== */

/**
 * Scrape visible video elements from the current frame.
 * Returns at most one video entry (the largest visible one).
 * @param {Array} hlsManifests - manifests found by the deep probe
 * @returns {{ videos: Array, videoCount: number, hlsManifest: string|null }}
 */
function scrapeFn(hlsManifests) {
  const allVideos = Array.from(document.querySelectorAll('video'))
    .filter(v => {
      const style = window.getComputedStyle(v);
      return style.display !== 'none' && v.clientWidth > 0 && v.clientHeight > 0;
    })
    .map(v => {
      const area = v.clientWidth * v.clientHeight;
      const rawSrc = v.currentSrc || v.src || '';
      const poster = v.poster || v.getAttribute('data-poster') || null;

      let hlsManifest = null;
      let mediaType = 'video';
      let src = rawSrc;

      // Priority 1: Direct .m3u8 source (rare but possible)
      if (rawSrc.includes('.m3u8') && rawSrc.startsWith('http')) {
        hlsManifest = rawSrc;
        mediaType = 'hls';
      }
      // Priority 2: Interceptor annotation — Hls.attachMedia() patched by interceptors
      else if (v._goon_hls_manifest) {
        hlsManifest = v._goon_hls_manifest;
        mediaType = 'hls';
        src = hlsManifest;
      }
      // Priority 3: Scan video element custom properties for HLS instance references.
      // Only check non-standard (custom) properties — skip built-in <video> attrs.
      if (!hlsManifest) {
        const stdAttrs = new Set([
          'src', 'srcObject', 'crossOrigin', 'preload', 'autoplay', 'muted',
          'defaultMuted', 'loop', 'controls', 'controlsList', 'disableRemotePlayback',
          'volume', 'playbackRate', 'defaultPlaybackRate', 'playbackState',
          'currentTime', 'startTime', 'duration', 'buffered', 'seekable',
          'played', 'seeking', 'ended', 'readyState', 'networkState',
          'videoWidth', 'videoHeight', 'error', 'textTracks', 'videoTracks',
          'audioTracks', 'loadingBeganAt', 'label', 'id', 'className',
          'classList', 'style', 'attributes', 'dataset', 'innerHTML', 'textContent',
          'outerHTML', 'outerText', 'slot', 'accessKey', 'draggable', 'hidden',
          'lang', 'spellcheck', 'tabIndex', 'title', 'translate',
          'width', 'height', 'poster', 'referrerPolicy',
        ]);
        for (const key of Object.keys(v)) {
          if (stdAttrs.has(key)) continue;
          const obj = v[key];
          if (obj && typeof obj === 'object' && typeof obj.url === 'string') {
            const u = obj.url.toLowerCase();
            if (u.includes('.m3u8') || u.includes('.hlsvod') || u.includes('/hls/') || u.includes('/playlist')) {
              hlsManifest = obj.url;
              mediaType = 'hls';
              src = hlsManifest;
              break;
            }
          }
        }
      }
      // Priority 4: Direct HTTP source (non-blob)
      if (!hlsManifest && rawSrc.startsWith('http') && !rawSrc.startsWith('blob:')) {
        mediaType = 'video';
      }
      // Priority 5: Deep probe fallback — use manifests found by scanning page globals/scripts
      // and interceptor-collected manifests. This is the most reliable fallback because
      // interceptors catch HLS activity at the network layer regardless of player type.
      if (!hlsManifest && hlsManifests && hlsManifests.length > 0) {
        // Prefer interceptor-collected manifests over script-scrapped ones
        const interceptManifest = hlsManifests.find(m => m.player === '__goon_plugin_data') ||
                                  hlsManifests.find(m => m.player === 'content-script-intercept') ||
                                  hlsManifests.find(m => m.player !== 'inline-script') ||
                                  hlsManifests[0];
        hlsManifest = interceptManifest.url || interceptManifest;
        mediaType = 'hls';
        src = hlsManifest;
      }

      return { src, poster, area, width: v.clientWidth, height: v.clientHeight, mediaType, hlsManifest };
    });

  allVideos.sort((a, b) => b.area - a.area);

  // Filter: only keep entries with a real playable source
  const playable = allVideos.filter(v => {
    const srcOk = v.src && (v.src.startsWith('http://') || v.src.startsWith('https://'));
    const hlsOk = v.hlsManifest && (v.hlsManifest.startsWith('http://') || v.hlsManifest.startsWith('https://'));
    return srcOk || hlsOk;
  });

  // Dedup: if multiple videos share the same HLS manifest, keep only the largest
  const seen = new Map();
  const unique = [];
  for (const v of playable) {
    const key = (v.hlsManifest || v.src || '') + '||' + (v.poster || '');
    if (!seen.has(key)) {
      seen.set(key, v);
      unique.push(v);
    }
  }

  const largest = unique.length > 0 ? unique[0] : null;
  return {
    videos: largest ? [largest] : [],
    videoCount: largest ? 1 : 0,
    hlsManifest: largest?.hlsManifest || null,
  };
}

/* ======================================================================== */
/* Scan pipeline                                                            */
/* ======================================================================== */

/** URLs that should not be scanned. */
const SYSTEM_PREFIXES = ['chrome://', 'chrome-extension://', 'edge://', 'about:', 'view-source:'];

/** Filter out system/browser pages from the tab list. */
function filterValidTabs(tabs) {
  return tabs.filter(t =>
    t.url && !SYSTEM_PREFIXES.some(prefix => t.url.startsWith(prefix))
  );
}

/**
 * Probe all frames in a tab for HLS manifests.
 * Runs in the MAIN world so strategies that depend on page globals work:
 *   - window.__goon_plugin_data.manifests (set by main-world interceptors)
 *   - window.Hls / Hls.cast (page's hls.js global)
 *   - player globals (PHPlayer, flowplayer, etc.)
 *   - config globals (__NEXT_DATA__, appData, etc.)
 *
 * The default isolated world cannot see these — only DOM properties like
 * video._goon_hls_manifest cross the boundary.
 * @param {number} tabId
 * @returns {Promise<Array>} array of { url, player } or empty on error
 */
async function probeHlsManifests(tabId) {
  try {
    log('probeHlsManifests: executing deep probe on tab', tabId);
    const raw = await chrome.scripting.executeScript({
      target: { tabId, allFrames: true },
      func: m3u8DeepProbeFn,
    });
    // When allFrames is true, destroyed / sandboxed frames may return null entries.
    // Guard: ensure raw is an array, then filter to objects with a defined .result.
    const manifests = Array.isArray(raw)
      ? raw.filter(r => r != null && typeof r === 'object' && 'result' in r)
           .flatMap(r => Array.isArray(r.result) ? r.result : [])
      : [];
    log('probeHlsManifests: tab', tabId, 'returned', manifests.length, 'manifests from', Array.isArray(raw) ? raw.length : '?', 'frame results');
    return manifests;
  } catch(e) {
    warn('probeHlsManifests: tab', tabId, 'error:', e && e.message ? e.message : e);
    return [];
  }
}

/**
 * Aggregate and deduplicate HLS manifests across frames for one tab.
 * Prefers manifests from known players/interceptors over inline-script scraping.
 * @param {Array} allManifests
 * @returns {Array}
 */
function dedupManifests(allManifests) {
  const seenUrls = new Set();
  const unique = allManifests.filter(m => {
    if (seenUrls.has(m.url)) return false;
    seenUrls.add(m.url);
    return true;
  });
  // Sort: prefer interceptor-collected > player globals > config > inline-script
  const playerRank = {
    '__goon_plugin_data': 0,
    'content-script-intercept': 0,
    'webRequest': 1,
    'phncdn_reconstructed': 2,
    'video._goon_hls_manifest': 3,
    'inline-script': 99,
  };
  unique.sort((a, b) => {
    const aRank = playerRank[a.player] ?? 50;
    const bRank = playerRank[b.player] ?? 50;
    return aRank - bRank;
  });
  return unique;
}

/**
 * Query the content script for poster URLs, intercepted manifests, and video metadata.
 * @param {number} tabId
 * @returns {Promise<Object|null>} content script response or null on error/timeout
 */
async function queryContentScript(tabId) {
  try {
    return await chrome.tabs.sendMessage(tabId, { type: 'GOON_GET_VIDEO_DATA' });
  } catch {
    return null;
  }
}

/**
 * Query the service worker for webRequest-captured HLS manifests.
 * The service worker listens to chrome.webRequest.onBeforeRequest and
 * records all .m3u8 / HLS manifest URLs per tab. This works at the
 * network level — no world or timing issues.
 * @param {number} tabId
 * @returns {Promise<Array>} array of manifest URLs
 */
async function queryWebRequestManifests(tabId) {
  try {
    const resp = await chrome.runtime.sendMessage({
      type: 'GOON_GET_WEBREQUEST_MANIFESTS',
      tabId: tabId,
    });
    return resp?.manifests || [];
  } catch {
    return [];
  }
}

/**
 * Query the service worker for all phncdn.com requests captured by Strategy 8.
 * Returns segments + reconstructed manifest URLs from segment patterns.
 * @param {number} tabId
 * @returns {Promise<{segments: Array, reconstructedManifests: Array, totalRequests: number}>}
 */
async function queryPhncdnRequests(tabId) {
  try {
    const resp = await chrome.runtime.sendMessage({
      type: 'GOON_GET_PHNCDN_REQUESTS',
      tabId: tabId,
    });
    return resp || { segments: [], reconstructedManifests: [], totalRequests: 0 };
  } catch {
    return { segments: [], reconstructedManifests: [], totalRequests: 0 };
  }
}

/**
 * Scrape video elements from ALL frames in a tab.
 * On sites like Pornhub, the video player lives inside an iframe — main-frame-only
 * scraping sees zero <video> elements. Running allFrames catches them.
 *
 * Runs in the MAIN world so it can see page globals:
 *   - Hls.cast(video) — the official hls.js API to get bound instances
 *   - window.__goon_plugin_data (interceptor-collected manifests)
 *
 * The default isolated world would miss all of these, causing the same
 * "does not detect any videos" failure kfj001 reported.
 * @param {number} tabId
 * @param {Array} manifests - HLS manifests found by probing
 * @returns {Promise<Object|null>} scrape result or null on error
 */
async function scrapeTab(tabId, manifests) {
  try {
    const raw = await chrome.scripting.executeScript({
      target: { tabId, allFrames: true },
      func: scrapeFn,
      args: [manifests],
    });
    // When allFrames is true, destroyed / sandboxed frames may return null entries.
    // Guard: ensure raw is an array, then filter to objects with a defined .result.
    const frameResults = Array.isArray(raw)
      ? raw.filter(r => r != null && typeof r === 'object' && 'result' in r)
           .map(r => r.result)
      : [];
    const valid = frameResults.filter(r => r && r.videos && r.videos.length > 0);
    if (valid.length === 0) {
      const firstWithResult = frameResults.find(r => r != null);
      return firstWithResult || null;
    }
    valid.sort((a, b) => {
      const aArea = a.videos[0]?.area || 0;
      const bArea = b.videos[0]?.area || 0;
      return bArea - aArea;
    });
    return valid[0];
  } catch(e) {
    warn('scrapeTab: tab', tabId, 'error:', e && e.message ? e.message : e);
    return null;
  }
}

/**
 * Filter intercepted URLs to prefer actual HLS manifests over segment files.
 * Interceptors capture both .m3u8 manifests and .ts segment URLs (any URL
 * matching /hls/ is intercepted). When building video entries from intercept
 * data alone (no visible <video> elements), we need to filter out segments
 * and reconstruct manifest URLs from segment paths when needed.
 *
 * @param {Array} manifests - array of { url, player } from probing/interception
 * @returns {Array} filtered { url } entries with only manifest URLs
 */
function filterManifests(manifests) {
  if (!manifests || manifests.length === 0) return [];

  // Separate manifests (.m3u8, .hlsvod) from segments (.ts)
  const actualManifests = manifests.filter(m => {
    const u = m.url.toLowerCase();
    return u.includes('.m3u8') || u.includes('.hlsvod') ||
           (u.includes('/master') && u.includes('.m3u')) ||
           (u.includes('/playlist') && !u.endsWith('.ts'));
  });

  // Reject fake reconstructed manifest paths.
  // Real manifests are under /hls/videos/{year}/{subdir}/{videoId}/...
  // Fakes look like: phncdn.com/videos/{id}/playlist.m3u8 or .../master.m3u8 (no /hls/)
  const valid = actualManifests.filter(m => {
    const u = m.url.toLowerCase();
    try {
      const urlObj = new URL(u);
      // phncdn URLs must have /hls/ in the path — fake reconstructed paths lack it
      if (u.includes('phncdn') || u.includes('pornhubcdn')) {
        if (!urlObj.pathname.includes('/hls/') && !u.includes('?h=')) {
          return false; // Fake: phncdn URL without /hls/ or auth query param
        }
      }
    } catch {}
    return true;
  });

  // If we have actual (non-fake) manifests, use them directly
  if (valid.length > 0) {
    return valid.map(m => ({ url: m.url }));
  }

  // No .m3u8 found — interceptors only captured .ts segments.
  // Reconstruct the parent manifest URL from segment paths.
  // Segment: https://ev-h.phncdn.com/hls/videos/202008/01/338337051/720P_4000K_338337051.mp4/seg-1-v1-a1.ts?h=tmrD...&e=1786932752&f=1
  // Manifest: https://ev-h.phncdn.com/hls/videos/202008/01/338337051/720P_4000K_338337051.mp4/master.m3u8?h=tmrD...&e=1786932752&f=1
  //
  // Auth tokens (h, e, f or validfrom, validto, hash) are extracted from segment query params
  // and reapplied to the reconstructed manifest URL. This is critical because CDN domains
  // require auth — a path-only URL will be rejected with 403.
  const seen = new Set();
  const reconstructed = [];

  for (const m of manifests) {
    const u = m.url.toLowerCase();
    if (!u.includes('/hls/videos/') || !/\/seg-\d+/.test(u)) continue;
    try {
      const urlObj = new URL(m.url);
      // Skip non-phncdn hosts — we only reconstruct for known video CDNs
      const host = urlObj.host.toLowerCase();
      if (!host.includes('phncdn')) continue;

      const pathParts = urlObj.pathname.split('/');
      // Find the /hls/ marker and extract: hls/videos/{year}/{subdir}/{videoId}/{variant}/...
      const hlsIdx = pathParts.findIndex(p => p === 'hls');
      if (hlsIdx === -1 || hlsIdx + 5 >= pathParts.length) continue;
      // Reconstruct with BOTH "hls" prefix AND variant directory included:
      // segment: /hls/videos/202008/01/338337051/720P_4000K_338337051.mp4/seg-1.ts
      // manifest: /hls/videos/202008/01/338337051/720P_4000K_338337051.mp4/master.m3u8
      const year    = pathParts[hlsIdx + 2];    // e.g. 2020
      const subDir  = pathParts[hlsIdx + 3];    // e.g. 01
      const videoId = pathParts[hlsIdx + 4];    // e.g. 338337051
      const variant = pathParts[hlsIdx + 5];    // e.g. 720P_4000K_338337051.mp4

      // Extract auth params from segment query string — different CDN variants use different keys:
      // ev-h/validfrom/validto/hash  vs  hv-h/h/e/f
      const authParts = [];
      for (const [key, val] of urlObj.searchParams) {
        if (['h', 'e', 'f', 'validfrom', 'validto', 'hash'].includes(key)) {
          authParts.push(`${key}=${val}`);
        }
      }
      const authStr = authParts.length > 0 ? '?' + authParts.join('&') : '';

      // Build manifest URL: include hls prefix AND variant directory
      const manifestUrl = `${urlObj.protocol}//${urlObj.host}/${pathParts[hlsIdx]}/${pathParts[hlsIdx + 1]}/${year}/${subDir}/${videoId}/${variant}/master.m3u8${authStr}`;
      if (!seen.has(manifestUrl)) {
        seen.add(manifestUrl);
        reconstructed.push({ url: manifestUrl });
      }
    } catch { /* skip malformed URLs */ }
  }
  return reconstructed;
}

/**
 * Validate that a manifest URL uses a real phncdn.com path structure.
 * Rejects fake paths like /videos/{id}/playlist.m3u8 — real manifests use
 * /hls/videos/{year}/{subdir}/{videoId}/master.m3u8 or similar /hls/ paths.
 */
function isValidManifestUrl(url) {
  if (!url || typeof url !== 'string') return false;
  // Real phncdn HLS manifest: must contain /hls/videos/ with sufficient path depth
  const hlsIdx = url.indexOf('/hls/videos/');
  if (hlsIdx === -1) {
    // Not phncdn — could be a different CDN, allow it
    if (!url.includes('phncdn') && !url.includes('pornhubcdn')) return true;
    // phncdn without /hls/ prefix is invalid for manifests
    return false;
  }
  // Check there are at least {year}/{subdir}/{videoId} after /hls/videos/
  const after = url.substring(hlsIdx + '/hls/videos/'.length);
  if (after.indexOf('/') === -1) return false; // need at least one more segment
  return true;
}

/**
 * Build a normalized video entry from a scraped video object.
 * Validates manifest URLs to prevent storing fake paths like /videos/{id}/playlist.m3u8.
 * @param {{ src: string, poster: string|null, mediaType: string, hlsManifest: string|null }} video
 * @param {string} tabTitle
 * @param {string|null} posterFromContent - poster URL from content script (OG image, etc.)
 * @returns {{ src: string, poster: string|null, tab: string, mediaType: string, hlsManifest?: string }}
 */
function makeVideoEntry(video, tabTitle, posterFromContent) {
  const entry = {
    src: video.hlsManifest || video.src || '',
    poster: video.poster || posterFromContent || null,
    tab: tabTitle,
    mediaType: video.mediaType || 'video',
  };
  if (video.hlsManifest) {
    // Reject fake phncdn manifest paths before storing
    if (!isValidManifestUrl(video.hlsManifest)) {
      console.warn('[goon] Rejecting fake manifest URL:', video.hlsManifest.substring(0, 120));
    } else {
      entry.hlsManifest = video.hlsManifest;
    }
  }
  // Also validate src when it looks like a manifest URL (no hlsManifest set but src has .m3u8)
  if (!entry.hlsManifest && entry.src?.includes('.m3u8') && !isValidManifestUrl(entry.src)) {
    console.warn('[goon] Rejecting fake manifest URL from src:', entry.src.substring(0, 120));
    // Don't treat it as HLS — leave mediaType as-is (likely 'video' or unset)
  }
  return entry;
}

/**
 * Run the full scan: probe HLS manifests, scrape video elements, query content scripts, dedup, store.
 * @param {Array} tabsToScan - tabs returned by chrome.tabs.query
 * @returns {Promise<{ items: Array, scanned: number, skipped: number }>}
 */
async function scanVideos(tabsToScan) {
  log('scanVideos: starting scan of', tabsToScan.length, 'tabs');
  await logToPage(`scanVideos: starting scan of ${tabsToScan.length} tabs`);

  // Step 1: Probe for HLS manifests in all frames
  const manifestPromises = tabsToScan.map(t => probeHlsManifests(t.id));
  const allManifestResults = await Promise.all(manifestPromises);

  // Build per-tab manifest map (deduped)
  const tabManifestMap = new Map();
  let totalManifests = 0;
  for (let i = 0; i < tabsToScan.length; i++) {
    const unique = dedupManifests(allManifestResults[i]);
    const tabUrl = tabsToScan[i].url ? tabsToScan[i].url.substring(0, 80) : '(unknown)';
    log('scanVideos step1: tab', tabsToScan[i].id, '(' + tabUrl + ') has', unique.length, 'unique manifests');
    totalManifests += unique.length;
    tabManifestMap.set(tabsToScan[i].id, unique);
  }
  await logToPage(`step1 (probe): found ${totalManifests} manifests across ${tabsToScan.length} tabs`);

  // Step 1.5: Query service worker for webRequest-captured HLS manifests.
  // This catches manifests at the network level — no world or timing issues.
  // Works even when the player loads before our interceptors are active.
  const webRequestPromises = tabsToScan.map(t => queryWebRequestManifests(t.id));
  const webRequestResults = await Promise.all(webRequestPromises);
  let totalWebRequestManifests = 0;
  for (let i = 0; i < tabsToScan.length; i++) {
    const urls = webRequestResults[i];
    const existing = tabManifestMap.get(tabsToScan[i].id) || [];
    for (const url of urls) {
      if (!existing.some(m => m.url === url)) {
        existing.push({ url, player: 'webRequest' });
      }
    }
    tabManifestMap.set(tabsToScan[i].id, existing);
    const newCount = urls.length;
    totalWebRequestManifests += newCount;
    if (newCount > 0) {
      log('scanVideos webRequest: tab', tabsToScan[i].id, 'found', newCount, 'manifests via network interception');
    }
  }
  await logToPage(`step1.5 (webRequest): found ${totalWebRequestManifests} manifests via network interception`);

  // Step 1.6: Strategy 8 — Query phncdn.com requests and reconstruct manifest URLs.
  // When the player uses in-memory dynamic HLS (zero .m3u8 network requests), we can
  // still detect it by recognizing segment URL patterns from phncdn.com and deriving
  // the parent manifest URL: /hls/videos/{id}/master.m3u8
  const phncdnPromises = tabsToScan.map(t => queryPhncdnRequests(t.id));
  const phncdnResults = await Promise.all(phncdnPromises);
  let totalPhncdnManifests = 0;
  for (let i = 0; i < tabsToScan.length; i++) {
    const reconstructed = phncdnResults[i]?.reconstructedManifests || [];
    if (reconstructed.length > 0) {
      log('scanVideos phncdn: tab', tabsToScan[i].id, 'found', reconstructed.length, 'reconstructed manifests from segment URLs');
    }
    totalPhncdnManifests += reconstructed.length;
    const existing = tabManifestMap.get(tabsToScan[i].id) || [];
    for (const url of reconstructed) {
      if (!existing.some(m => m.url === url)) {
        existing.push({ url, player: 'phncdn_reconstructed' });
      }
    }
    tabManifestMap.set(tabsToScan[i].id, existing);
  }
  await logToPage(`step1.6 (phncdn): found ${totalPhncdnManifests} reconstructed manifests from segment URLs`);

  // Step 2: Scrape video elements (all frames) AND query content scripts (in parallel)
  const scrapePromises = tabsToScan.map(t =>
    scrapeTab(t.id, tabManifestMap.get(t.id) || [])
  );
  const contentPromises = tabsToScan.map(t => queryContentScript(t.id));
  const [scrapeResults, contentResults] = await Promise.all([
    Promise.all(scrapePromises),
    Promise.all(contentPromises),
  ]);

  // Log scrape + content script results for debugging
  let totalScrapedVideos = 0;
  let totalInterceptedManifests = 0;
  for (let i = 0; i < tabsToScan.length; i++) {
    const tabUrl = tabsToScan[i].url ? tabsToScan[i].url.substring(0, 80) : '(unknown)';
    const scrape = scrapeResults[i];
    const content = contentResults[i];
    const scrapeVideos = scrape ? (scrape.videos ? scrape.videos.length : 0) : 0;
    const intercepts = content ? (content.interceptedManifests ? content.interceptedManifests.length : 0) : 0;
    totalScrapedVideos += scrapeVideos;
    totalInterceptedManifests += intercepts;
    log('scanVideos step2: tab', tabsToScan[i].id, '(' + tabUrl + '):',
      'scrape=' + (scrape ? (scrape.videos ? scrape.videos.length + ' videos' : 'no videos') : 'null'),
      'content=' + (content ? ('poster=' + !!content.posterUrl + ', intercepts=' + intercepts + ', videoEls=' + (content.videoElements ? content.videoElements.length : 0)) : 'null'),
    );
  }
  await logToPage(`step2 (scrape+content): ${totalScrapedVideos} scraped videos, ${totalInterceptedManifests} intercepted manifests`);

  // Step 3: Merge content-script data into tab results
  // - Enrich video entries with poster URLs from the content script
  // - Merge content-script intercepted manifests into the deep probe results
  // - FALLBACK: When scrapeFn found no visible <video> elements (sandboxed
  //   iframe) but interceptors captured manifests, create video entries from
  //   manifest data. The tab is actively playing content even if the DOM is
  //   inaccessible.
  const tabResults = tabsToScan.map((tab, i) => {
    const result = scrapeResults[i];
    const contentData = contentResults[i];
    const tabManifests = tabManifestMap.get(tab.id) || [];

    // Enrich videos with poster from content script (og:image, twitter:image, etc.)
    if (result && result.videos?.length > 0 && contentData?.posterUrl) {
      for (const v of result.videos) {
        if (!v.poster) v.poster = contentData.posterUrl;
      }
    }

    // Merge content-script intercepted manifests into the tab's manifest list
    if (contentData && contentData.interceptedManifests) {
      for (const m of contentData.interceptedManifests) {
        if (m.url && !tabManifests.some(tm => tm.url === m.url)) {
          tabManifests.push({ url: m.url, player: 'content-script-intercept' });
        }
      }
      tabManifestMap.set(tab.id, tabManifests);
    }

    // FALLBACK: If scrapeFn returned no videos but we have manifests,
    // create video entries from manifest data. This handles sandboxed
    // iframes where the video player is invisible to content scripts.
    // Filter: prefer .m3u8 manifest URLs over .ts segment URLs.
    // Reconstruct manifest URL from segment URLs when needed.
    if (!result || !result.videos || result.videos.length === 0) {
      const poster = contentData?.posterUrl || null;
      const filteredManifests = filterManifests(tabManifests);
      if (filteredManifests.length > 0) {
        log('scanVideos fallback: tab', tab.id, 'no visible videos but found', filteredManifests.length, 'manifests — creating fallback entries');
        const fallbackVideos = filteredManifests.map(m => ({
          src: m.url,
          poster: poster,
          mediaType: 'hls',
          hlsManifest: m.url,
        }));
        return {
          tabTitle: tab.title || 'Unknown',
          result: { videos: fallbackVideos },
        };
      }
      log('scanVideos: tab', tab.id, 'has no videos and no manifests — skipping');
      return null;
    }

    return {
      tabTitle: tab.title || 'Unknown',
      result,
    };
  }).filter(g => g != null && g.result && g.result.videos?.length > 0);

  // Step 4: Dedup across tabs
  const seen = new Map();
  for (const group of tabResults) {
    for (const video of group.result.videos) {
      const primarySrc = video.hlsManifest || video.src || '(empty)';
      const key = primarySrc + '||' + (video.poster || '(none)');
      if (!seen.has(key)) {
        seen.set(key, makeVideoEntry(video, group.tabTitle));
      }
    }
  }

  const items = [...seen.values()];
  const skipped = scrapeResults.filter(r => r === null).length;

  log('scanVideos complete: scanned=', tabResults.length, 'skipped=', skipped, 'unique items=', items.length);
  if (items.length > 0) {
    log('Final items:', JSON.stringify(items.map(v => ({ src: (v.src || '').substring(0, 80), mediaType: v.mediaType, tab: v.tab }))));
  }
  await logToPage(`scan complete: ${items.length} unique items from ${tabResults.length} tabs (skipped: ${skipped})`);
  return { items, scanned: tabResults.length, skipped };
}

/** Store video entries in chrome.storage.local. */
async function storeVideos(items) {
  const stored = items.map(v => ({
    src: v.src,
    poster: v.poster,
    tab: v.tab,
    mediaType: v.mediaType || 'video',
    hlsManifest: v.hlsManifest || undefined,
  }));
  await chrome.storage.local.set({
    [STORAGE_KEY]: stored,
    [TAGGED_KEY]: items.map(v => v.tab),
  });
}

/* ======================================================================== */
/* Event handlers                                                           */
/* ======================================================================== */

findBtn.addEventListener('click', async () => {
  setStatus('Scanning tabs...');

  const allTabs = await chrome.tabs.query({ currentWindow: true });
  const validTabs = filterValidTabs(allTabs);

  if (validTabs.length === 0) {
    setStatus('No browsable tabs found.');
    return;
  }

  setStatus(`Scanning ${validTabs.length} tab(s)...`);

  try {
    const { items, scanned, skipped } = await scanVideos(validTabs);

    await storeVideos(items);

    const msg = `Found ${items.length} video(s) across ${scanned} tab(s).`;
    setStatus(skipped > 0 ? `${msg} ${skipped} tab(s) skipped (idle).` : msg);
    btnRow.style.display = 'flex';

    // If no videos found, run diagnostics in the active tab
    if (items.length === 0) {
      const activeTab = validTabs.find(t => t.active) || validTabs[0];
      if (activeTab) {
        try {
          await chrome.scripting.executeScript({
            target: { tabId: activeTab.id },
            func: () => {
              const diag = [];
              // Check interceptor data
              if (window.__goon_plugin_data) {
                diag.push(`__goon_plugin_data.manifests: ${window.__goon_plugin_data.manifests.length} URLs`);
                if (window.__goon_plugin_data.manifests.length > 0) {
                  diag.push(`  First: ${window.__goon_plugin_data.manifests[0].substring(0, 120)}`);
                }
              } else {
                diag.push('__goon_plugin_data: NOT FOUND — interceptors may not have loaded');
              }
              // Check Hls global
              if (typeof Hls !== 'undefined') {
                diag.push(`Hls global: defined`);
                if (typeof Hls.cast === 'function') {
                  diag.push(`Hls.cast: available`);
                }
              } else {
                diag.push(`Hls global: NOT DEFINED`);
              }
              // Check video elements
              const videos = document.querySelectorAll('video');
              diag.push(`Video elements: ${videos.length}`);
              for (let vi = 0; vi < videos.length; vi++) {
                const v = videos[vi];
                const style = window.getComputedStyle(v);
                const isVisible = style.display !== 'none' && v.clientWidth > 0 && v.clientHeight > 0;
                const src = (v.currentSrc || v.src || '').substring(0, 120);
                diag.push(`  Video[${vi}]: src="${src}", visible=${isVisible}, _goon_hls_manifest=${v._goon_hls_manifest || 'null'}`);
                // Check custom properties
                const customProps = [];
                for (const key of Object.keys(v)) {
                  if (typeof v[key] === 'object' && v[key] && typeof v[key].url === 'string') {
                    customProps.push(`${key}.url="${v[key].url.substring(0, 80)}"`);
                  }
                }
                if (customProps.length > 0) {
                  diag.push(`    Custom props with .url: ${customProps.join(', ')}`);
                }
              }
              // Check known player globals
              const playerNames = ['hls', 'Hls', 'player', 'videoPlayer', 'mainPlayer', 'PHPlayer', '__phPlayer', '__ph', 'fhplayer', '__pj', 'bitgravity', 'bgPlayer', 'FG', 'Fhls'];
              for (const name of playerNames) {
                if (window[name] && typeof window[name] !== 'function') {
                  const obj = window[name];
                  const urlVal = obj.url || obj._url || obj.src || obj.manifestUrl || obj.hlsUrl;
                  if (typeof urlVal === 'string' && urlVal) {
                    diag.push(`Global ${name}.url-like: "${urlVal.substring(0, 120)}"`);
                  } else {
                    diag.push(`Global ${name}: exists but no obvious URL property. Keys: ${Object.keys(obj).slice(0, 20).join(', ')}`);
                  }
                }
              }
              console.group('[goon-diag] HLS diagnostics');
              for (const line of diag) {
                console.log(line);
              }
              console.groupEnd();
            },
          });
        } catch (e) {
          console.warn('[goon-diag] Diagnostic failed:', e.message);
        }
      }
    }
  } catch (e) {
    setStatus(`Scan failed: ${e.message}`);
    warn('executeScript failed:', e);
  }
});

/* === "Open Viewer" - launch the NxN grid === */
openBtn.addEventListener('click', async () => {
  const { videos, tags } = await loadVideos();

  if (!videos || videos.length === 0) {
    setStatus('No videos found. Click "Find Videos" first.');
    return;
  }

  const N = Math.ceil(Math.sqrt(videos.length));
  const PANEL_MIN_W = 420;
  const PANEL_MIN_H = 340;
  const GAP = 2;
  const winW = Math.max(PANEL_MIN_W * N + GAP * (N - 1), 400);
  const winH = Math.max(PANEL_MIN_H * N + GAP * (N - 1) + 40, 300);

  const id = 'goonViewer_' + Date.now();
  await chrome.storage.local.set({ [id]: videos });

  const tagsParam = tags.length > 0 ? '&tags=' + encodeURIComponent(JSON.stringify(tags)) : '';
  const viewerUrl = chrome.runtime.getURL('viewer/viewer.html') + '?id=' + id + '&grid=' + N + tagsParam;
  chrome.windows.create({ url: viewerUrl, width: winW, height: winH });
});

/* === "Clear" - reset the stored list === */
clearBtn.addEventListener('click', async () => {
  await chrome.storage.local.remove([STORAGE_KEY, TAGGED_KEY]);
  listEl.style.display = 'none';
  listEl.innerHTML = '';
  setStatus('');
});

/* === Init - restore saved list === */
showActions();