// HLS.js detection and tracking verification tests
// Covers scenarios specific to sites that use hls.js for video playback:
// - Dynamic/late HLS.js loading (polling + MutationObserver)
// - Content script message collection
// - Video playback state machine transitions
// - HLS.js error recovery
// - Manifest URL edge cases (query strings, protocol-relative)
// - End-to-end interceptor -> content script -> deep probe pipeline
import { describe, it } from './runner.mjs';
import { JSDOM } from 'jsdom';
import * as fs from 'fs';
import * as path from 'path';
import { fileURLToPath } from 'url';

const __dirname = path.dirname(fileURLToPath(import.meta.url));
const viewerSource = fs.readFileSync(
  path.join(__dirname, '../src/viewer/viewer.js'),
  'utf-8'
);
const interceptorSource = fs.readFileSync(
  path.join(__dirname, '../src/inject/interceptors.js'),
  'utf-8'
);
const contentSource = fs.readFileSync(
  path.join(__dirname, '../src/content/content.js'),
  'utf-8'
);
const indexSource = fs.readFileSync(
  path.join(__dirname, '../src/viewer/index.js'),
  'utf-8'
);

/* ========================================================================== */
/* Helpers                                                                    */
/* ========================================================================== */

function createBrowserEnv({ storageData = {}, url = 'https://example.com/viewer/viewer.html', hlsMode = 'mocked' } = {}) {
  const html = `<!DOCTYPE html><html><body><div id="panels"></div></body></html>`;
  const dom = new JSDOM(html, {
    url,
    runScripts: 'dangerously',
    resources: 'usable',
  });
  const win = dom.window;

  const storage = { ...storageData };
  win.chrome = {
    storage: {
      local: {
        get: (keys) => new Promise((resolve) => {
          const result = {};
          for (const key of (keys || [])) result[key] = storage[key];
          resolve(result);
        }),
        set: (data) => new Promise((resolve) => {
          for (const [k, v] of Object.entries(data)) storage[k] = v;
          resolve();
        }),
        remove: (keys) => new Promise((resolve) => {
          for (const key of (keys || [])) delete storage[key];
          resolve();
        }),
      },
    },
  };

  const hlsCalls = { instances: [], loaded: false };
  if (hlsMode === 'mocked') {
    win.Hls = class MockHLS {
      constructor(opts) {
        this.levels = [];
        hlsCalls.instances.push({
          opts, destroyed: false, events: {}, source: null, media: null,
          levels: [],
        });
      }
      static get Events() {
        return {
          MANIFEST_PARSED: 'manifestParsed',
          MANIFEST_LOADED: 'manifestLoaded',
          FRAG_LOADING: 'fragLoading',
          FRAG_LOADED: 'fragLoaded',
          FRAG_BUFFERED: 'fragBuffered',
          BUFFER_APPENDED: 'bufferAppended',
          BUFFER_FLUSHED: 'bufferFlushed',
          BUFFER_RESET: 'bufferReset',
          LEVEL_SWITCHED: 'levelSwitched',
          LEVEL_UPDATED: 'levelUpdated',
          FPS_DROP: 'fpsDrop',
          FPS_MAX_LEVEL_DROP: 'fpsMaxLevelDrop',
          MEDIA_ATTACHED: 'mediaAttached',
          MEDIA_DETACHED: 'mediaDetached',
          ERROR: 'error',
          DESTROYING: 'destroying',
        };
      }
      static get ErrorTypes() {
        return { NETWORK_ERROR: 'networkError', MEDIA_ERROR: 'mediaError' };
      }
      static isSupported() { return true; }
      loadSource(src) {
        const inst = hlsCalls.instances[hlsCalls.instances.length - 1];
        inst.source = src;
      }
      attachMedia(media) {
        const inst = hlsCalls.instances[hlsCalls.instances.length - 1];
        inst.media = media;
      }
      on(event, handler) {
        const inst = hlsCalls.instances[hlsCalls.instances.length - 1];
        if (!inst.events[event]) inst.events[event] = [];
        inst.events[event].push(handler);
      }
      destroy() {
        const inst = hlsCalls.instances[hlsCalls.instances.length - 1];
        inst.destroyed = true;
      }
      startLoad() {}
      recoverMediaError() {}
    };
    hlsCalls.loaded = true;
  }

  const consoleLogs = [];
  win.console = {
    log: (...args) => consoleLogs.push(args.map(String).join(' ')),
    error: (...args) => consoleLogs.push('ERROR: ' + args.map(String).join(' ')),
    warn: (...args) => consoleLogs.push('WARN: ' + args.map(String).join(' ')),
  };

  return { dom, win, storage, consoleLogs, hlsCalls };
}

/* ========================================================================== */
/* Test: Dynamic/late HLS.js loading (polling + MutationObserver)            */
/* ========================================================================== */

describe('HLS.js: Dynamic late loading detection', () => {
  it('should patch Hls prototype via polling when Hls appears after interceptors load', () => {
    const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
      url: 'https://example.com/watch',
      runScripts: 'dangerously',
    });
    const win = dom.window;

    const intercepted = [];
    win.postMessage = (msg) => {
      if (msg.type === 'GOON_PLUGIN_HLS_INTERCEPT') intercepted.push(msg);
    };
    win.fetch = () => {};

    // Load interceptors BEFORE Hls is defined
    win.eval(interceptorSource);

    // Simulate hls.js loading dynamically AFTER interceptors
    win.Hls = class {
      loadSource(url) { this._url = url; }
      attachMedia(media) {}
    };
    Object.defineProperty(win.Hls.prototype, 'url', {
      get() { return this._url || ''; }
    });

    // Wait for polling to detect and patch Hls (polls every 50ms)
    return new Promise((resolve, reject) => {
      setTimeout(() => {
        try {
          const hls = new win.Hls();
          hls.loadSource('https://cdn.example.com/late.m3u8');

          const hlsIntercepts = intercepted.filter(m => m.source === 'hls_loadSource');
          if (hlsIntercepts.length === 0) {
            throw new Error('Late-loaded HLS was not intercepted via polling. Sources: ' + intercepted.map(m => m.source).join(', '));
          }
          resolve();
        } catch (e) { reject(e); }
      }, 200);
    });
  });

  it('should detect HLS.js loaded via <script> tag injection (MutationObserver)', () => {
    const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
      url: 'https://example.com/watch',
      runScripts: 'dangerously',
    });
    const win = dom.window;

    const intercepted = [];
    win.postMessage = (msg) => {
      if (msg.type === 'GOON_PLUGIN_HLS_INTERCEPT') intercepted.push(msg);
    };
    win.fetch = () => {};

    // Load interceptors before Hls exists
    win.eval(interceptorSource);

    if (win.eval('typeof Hls') !== 'undefined') {
      throw new Error('Hls should not be defined before script tag injection');
    }

    // Simulate the page adding a <script> tag for hls.js
    const scriptEl = win.document.createElement('script');
    scriptEl.src = 'https://cdn.example.com/hls.min.js';
    win.document.head.appendChild(scriptEl);

    // After the MutationObserver fires, define Hls (simulating script load)
    win.Hls = class {
      loadSource(url) { this._url = url; }
      attachMedia(media) {}
    };
    Object.defineProperty(win.Hls.prototype, 'url', {
      get() { return this._url || ''; }
    });

    return new Promise((resolve, reject) => {
      setTimeout(() => {
        try {
          const hls = new win.Hls();
          hls.loadSource('https://cdn.example.com/mutation-observer.m3u8');

          const hlsIntercepts = intercepted.filter(m => m.source === 'hls_loadSource');
          if (hlsIntercepts.length === 0) {
            throw new Error('MutationObserver did not trigger Hls patching');
          }
          resolve();
        } catch (e) { reject(e); }
      }, 200);
    });
  });

  it('should NOT re-patch Hls prototype if already patched (idempotent patch)', () => {
    const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
      url: 'https://example.com/watch',
      runScripts: 'dangerously',
    });
    const win = dom.window;

    const intercepted = [];
    win.postMessage = (msg) => {
      if (msg.type === 'GOON_PLUGIN_HLS_INTERCEPT') intercepted.push(msg);
    };
    win.fetch = () => {};

    win.Hls = class {
      loadSource(url) { this._url = url; }
    };
    Object.defineProperty(win.Hls.prototype, 'url', {
      get() { return this._url || ''; }
    });

    // Load interceptors twice
    win.eval(interceptorSource);
    win.eval(interceptorSource);

    win.fetch('https://cdn.example.com/stream.m3u8');

    if (intercepted.length !== 1) {
      throw new Error(`Expected 1 intercept after double injection, got ${intercepted.length}`);
    }
  });
});

/* ========================================================================== */
/* Test: Content script message collection                                   */
/* ========================================================================== */

describe('HLS.js: Content script manifest collection', () => {
  it('should collect manifests from postMessage (GOON_PLUGIN_HLS_INTERCEPT)', () => {
    if (!contentSource.includes("event.data.type === 'GOON_PLUGIN_HLS_INTERCEPT'")) {
      throw new Error('Content script missing GOON_PLUGIN_HLS_INTERCEPT message handler');
    }
    if (!contentSource.includes('interceptedSources.has(url)')) {
      throw new Error('Content script does not deduplicate intercepted manifests');
    }
    if (!contentSource.includes('interceptedManifests.push')) {
      throw new Error('Content script does not collect intercepted manifests');
    }
  });

  it('should respond to GOON_GET_VIDEO_DATA with intercepted manifests', () => {
    if (!contentSource.includes("message.type === 'GOON_GET_VIDEO_DATA'")) {
      throw new Error('Content script missing GOON_GET_VIDEO_DATA message handler');
    }
    if (!contentSource.includes('interceptedManifests: interceptedManifests')) {
      throw new Error('Content script does not return intercepted manifests in response');
    }
  });

  it('should filter postMessage from non-self sources', () => {
    if (!contentSource.includes('event.source !== window')) {
      throw new Error('Content script does not filter iframe/cross-origin postMessages');
    }
  });

  it('should inject interceptors via script.src (not inline textContent)', () => {
    // Verify content.js uses script.src = chrome.runtime.getURL(...) pattern
    // This is the CSP-safe approach vs inline script.textContent
    const injectFn = contentSource.match(/function injectInterceptors\(\)[\s\S]*?\n\}/);
    if (!injectFn) throw new Error('injectInterceptors function not found');

    if (!injectFn[0].includes('script.src = chrome.runtime.getURL')) {
      throw new Error('Content script does not use script.src = chrome.runtime.getURL for injection');
    }

    // Verify it does NOT set script.textContent (which CSP blocks)
    // We check actual assignment, not comments — strip comments first
    const noComments = injectFn[0].replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*$/gm, '');
    if (noComments.includes('script.textContent')) {
      throw new Error('Content script uses inline script.textContent injection — blocked by CSP');
    }
  });
});

/* ========================================================================== */
/* Test: Video playback state machine transitions                            */
/* ========================================================================== */

describe('HLS.js: Playback state machine', () => {
  it('should transition from idle -> loading -> buffering -> playing on normal playback', () => {
    const storageData = {};
    const viewerId = 'test_state_machine';
    storageData[viewerId] = [{ url: 'x', src: 'x', hlsManifest: 'https://cdn.example.com/stream.m3u8', mediaType: 'hls' }];
    const url = `https://example.com/viewer/viewer.html?id=${viewerId}&grid=1`;
    const { win, hlsCalls } = createBrowserEnv({ storageData, url, hlsMode: 'mocked' });

    win.eval(viewerSource);

    return new Promise((resolve, reject) => {
      setTimeout(() => {
        try {
          const inst = hlsCalls.instances[0];
          if (!inst) throw new Error('No HLS instance');

          // 1. MEDIA_ATTACHED -> loading
          inst.events['mediaAttached'][0]('mediaAttached');

          // 2. MANIFEST_LOADED -> loading
          inst.events['manifestLoaded'][0]('manifestLoaded', { levels: [{ width: 1280, height: 720 }] });

          // 3. FRAG_LOADING (video.paused=true) -> buffering
          const video = win.document.querySelector('video');
          Object.defineProperty(video, 'paused', { value: true, configurable: true });
          Object.defineProperty(video, 'readyState', { value: 1, configurable: true });
          inst.events['fragLoading'][0]('fragLoading');

          // 4. FRAG_BUFFERED (video not paused, readyState >= 3) -> playing
          Object.defineProperty(video, 'paused', { value: false, configurable: true });
          Object.defineProperty(video, 'readyState', { value: 4, configurable: true });
          inst.events['fragBuffered'][0]('fragBuffered');

          const overlay = win.document.querySelector('.panel-overlay');
          if (!overlay) throw new Error('No panel overlay found');
          if (!overlay.textContent.includes('playing')) {
            throw new Error(`Expected overlay to show 'playing' state, got: ${overlay.textContent}`);
          }

          resolve();
        } catch (e) { reject(e); }
      }, 500);
    });
  });

  it('should transition to switching state during level change', () => {
    const storageData = {};
    const viewerId = 'test_level_switch';
    storageData[viewerId] = [{ url: 'x', src: 'x', hlsManifest: 'https://cdn.example.com/stream.m3u8', mediaType: 'hls' }];
    const url = `https://example.com/viewer/viewer.html?id=${viewerId}&grid=1`;
    const { win, hlsCalls } = createBrowserEnv({ storageData, url, hlsMode: 'mocked' });

    win.eval(viewerSource);

    return new Promise((resolve, reject) => {
      setTimeout(() => {
        try {
          const inst = hlsCalls.instances[0];
          const hls = inst.hlsInstance; // the actual mock instance

          // Set levels on the actual Hls instance (viewer.js reads hls.levels)
          // The mock instance is the one returned by the MockHLS constructor
          // We need to set it on the real instance, not our tracking proxy
          const levelSwitchedHandlers = inst.events['levelSwitched'];
          if (!levelSwitchedHandlers) throw new Error('LEVEL_SWITCHED handler not registered');

          // Simulate level switch
          levelSwitchedHandlers[0]('levelSwitched', { level: 0 });

          // Check overlay for switching state
          const overlay = win.document.querySelector('.panel-overlay');
          if (!overlay) throw new Error('No panel overlay');
          if (!overlay.textContent.includes('switching')) {
            throw new Error(`Expected 'switching' state during level change, got: ${overlay.textContent}`);
          }

          resolve();
        } catch (e) { reject(e); }
      }, 500);
    });
  });

  it('should transition from any non-error state to playing on FRAG_BUFFERED', () => {
    const storageData = {};
    const viewerId = 'test_direct_playing';
    storageData[viewerId] = [{ url: 'x', src: 'x', hlsManifest: 'https://cdn.example.com/stream.m3u8', mediaType: 'hls' }];
    const url = `https://example.com/viewer/viewer.html?id=${viewerId}&grid=1`;
    const { win, hlsCalls } = createBrowserEnv({ storageData, url, hlsMode: 'mocked' });

    win.eval(viewerSource);

    return new Promise((resolve, reject) => {
      setTimeout(() => {
        try {
          const inst = hlsCalls.instances[0];
          const video = win.document.querySelector('video');

          Object.defineProperty(video, 'paused', { value: false, configurable: true });
          Object.defineProperty(video, 'readyState', { value: 4, configurable: true });

          const fragBufferedHandlers = inst.events['fragBuffered'];
          if (!fragBufferedHandlers) throw new Error('FRAG_BUFFERED handler not registered');

          fragBufferedHandlers[0]('fragBuffered');

          const overlay = win.document.querySelector('.panel-overlay');
          if (!overlay) throw new Error('No panel overlay');
          if (!overlay.textContent.includes('playing')) {
            throw new Error(`Expected direct transition to 'playing', got: ${overlay.textContent}`);
          }

          resolve();
        } catch (e) { reject(e); }
      }, 500);
    });
  });
});

/* ========================================================================== */
/* Test: HLS.js error recovery                                                */
/* ========================================================================== */

describe('HLS.js: Error handling and recovery', () => {
  it('should attempt media error recovery (not destroy instance)', () => {
    const storageData = {};
    const viewerId = 'test_media_err';
    storageData[viewerId] = [{ url: 'x', src: 'x', hlsManifest: 'https://cdn.example.com/stream.m3u8', mediaType: 'hls' }];
    const url = `https://example.com/viewer/viewer.html?id=${viewerId}&grid=1`;
    const { win, hlsCalls } = createBrowserEnv({ storageData, url, hlsMode: 'mocked' });

    win.eval(viewerSource);

    return new Promise((resolve, reject) => {
      setTimeout(() => {
        try {
          const inst = hlsCalls.instances[0];
          if (!inst) throw new Error('No HLS instance');

          const errorHandlers = inst.events['error'];
          if (!errorHandlers) throw new Error('ERROR handler not registered');

          // Simulate non-fatal media error (should recover, not destroy)
          errorHandlers[0]('error', {
            fatal: false,
            type: 'mediaError',
            details: 'fragParsingError',
          });

          if (inst.destroyed) {
            throw new Error('HLS instance was destroyed on non-fatal media error — should have recovered');
          }

          resolve();
        } catch (e) { reject(e); }
      }, 500);
    });
  });

  it('should destroy instance on fatal network error', () => {
    const storageData = {};
    const viewerId = 'test_net_err';
    storageData[viewerId] = [{ url: 'x', src: 'x', hlsManifest: 'https://cdn.example.com/stream.m3u8', mediaType: 'hls' }];
    const url = `https://example.com/viewer/viewer.html?id=${viewerId}&grid=1`;
    const { win, hlsCalls } = createBrowserEnv({ storageData, url, hlsMode: 'mocked' });

    win.eval(viewerSource);

    return new Promise((resolve, reject) => {
      setTimeout(() => {
        try {
          const inst = hlsCalls.instances[0];
          const errorHandlers = inst.events['error'];

          errorHandlers[0]('error', {
            fatal: true,
            type: 'networkError',
            details: 'loadsource timeout',
          });

          if (!inst.destroyed) {
            throw new Error('HLS instance should be destroyed on fatal network error');
          }

          const panelError = win.document.querySelector('.panel-error');
          if (!panelError) {
            throw new Error('Expected panel-error element for fatal network error');
          }

          resolve();
        } catch (e) { reject(e); }
      }, 500);
    });
  });

  it('should track non-fatal fragment load failures (segmentsFailed++)', () => {
    const storageData = {};
    const viewerId = 'test_frag_fail';
    storageData[viewerId] = [{ url: 'x', src: 'x', hlsManifest: 'https://cdn.example.com/stream.m3u8', mediaType: 'hls' }];
    const url = `https://example.com/viewer/viewer.html?id=${viewerId}&grid=1`;
    const { win, hlsCalls } = createBrowserEnv({ storageData, url, hlsMode: 'mocked' });

    win.eval(viewerSource);

    return new Promise((resolve, reject) => {
      setTimeout(() => {
        try {
          const inst = hlsCalls.instances[0];
          const errorHandlers = inst.events['error'];
          const fragLoadedHandlers = inst.events['fragLoaded'];

          // First load some segments so the overlay shows segment count
          for (let i = 0; i < 5; i++) {
            fragLoadedHandlers[0]('fragLoaded', { frag: { level: 0, sn: i } });
          }

          // Simulate non-fatal network errors (transient fragment failures)
          errorHandlers[0]('error', { fatal: false, type: 'networkError', details: 'fragLoadError' });
          errorHandlers[0]('error', { fatal: false, type: 'networkError', details: 'fragLoadError' });

          const overlay = win.document.querySelector('.panel-overlay');
          if (!overlay) throw new Error('No panel overlay');
          // Should show segment count + failure count
          if (!overlay.textContent.includes('5 seg')) {
            throw new Error(`Expected '5 seg' in overlay after loading segments, got: ${overlay.textContent}`);
          }
          if (!overlay.textContent.includes('fail')) {
            throw new Error(`Expected fragment failure tracking in overlay, got: ${overlay.textContent}`);
          }

          resolve();
        } catch (e) { reject(e); }
      }, 500);
    });
  });
});

/* ========================================================================== */
/* Test: Manifest URL edge cases (query strings, protocol-relative, etc.)    */
/* ========================================================================== */

describe('HLS.js: Manifest URL edge cases', () => {
  it('should intercept .m3u8 URLs with query string parameters', () => {
    const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
      url: 'https://example.com/watch',
      runScripts: 'dangerously',
    });
    const win = dom.window;

    const intercepted = [];
    win.postMessage = (msg) => {
      if (msg.type === 'GOON_PLUGIN_HLS_INTERCEPT') intercepted.push(msg);
    };
    win.fetch = () => {};

    win.eval(interceptorSource);
    win.fetch('https://cdn.example.com/stream.m3u8?token=abc123&expires=999999');

    if (intercepted.length !== 1) {
      throw new Error(`Expected 1 intercept for .m3u8 with query string, got ${intercepted.length}`);
    }
    if (!intercepted[0].url.includes('token=abc123')) {
      throw new Error(`Query string should be preserved: ${intercepted[0].url}`);
    }
  });

  it('should intercept protocol-relative manifest URLs (//cdn.example.com)', () => {
    const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
      url: 'https://example.com/watch',
      runScripts: 'dangerously',
    });
    const win = dom.window;

    const intercepted = [];
    win.postMessage = (msg) => {
      if (msg.type === 'GOON_PLUGIN_HLS_INTERCEPT') intercepted.push(msg);
    };
    win.fetch = () => {};

    win.eval(interceptorSource);
    win.fetch('//cdn.example.com/stream.m3u8');

    if (intercepted.length !== 1) {
      throw new Error(`Expected 1 intercept for protocol-relative URL, got ${intercepted.length}`);
    }
    if (!intercepted[0].url.startsWith('https://')) {
      throw new Error(`Protocol-relative URL should be resolved to absolute: ${intercepted[0].url}`);
    }
  });

  it('should intercept .hlsvod URLs (non-standard HLS extension)', () => {
    const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
      url: 'https://example.com/watch',
      runScripts: 'dangerously',
    });
    const win = dom.window;

    const intercepted = [];
    win.postMessage = (msg) => {
      if (msg.type === 'GOON_PLUGIN_HLS_INTERCEPT') intercepted.push(msg);
    };
    win.fetch = () => {};

    win.eval(interceptorSource);
    win.fetch('https://cdn.example.com/stream.hlsvod');

    if (intercepted.length !== 1) {
      throw new Error(`Expected 1 intercept for .hlsvod URL, got ${intercepted.length}`);
    }
  });

  it('should intercept /hls/ path URLs', () => {
    const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
      url: 'https://example.com/watch',
      runScripts: 'dangerously',
    });
    const win = dom.window;

    const intercepted = [];
    win.postMessage = (msg) => {
      if (msg.type === 'GOON_PLUGIN_HLS_INTERCEPT') intercepted.push(msg);
    };
    win.fetch = () => {};

    win.eval(interceptorSource);
    win.fetch('https://cdn.example.com/hls/video/12345/master');

    if (intercepted.length !== 1) {
      throw new Error(`Expected 1 intercept for /hls/ path URL, got ${intercepted.length}`);
    }
  });

  it('should use hlsManifest field even when src is not .m3u8', () => {
    const storageData = {};
    const viewerId = 'test_hls_field_priority';
    storageData[viewerId] = [{
      url: 'https://example.com/video/123',
      src: 'https://example.com/video/123',
      hlsManifest: 'https://cdn.example.com/stream.m3u8',
      mediaType: 'hls',
    }];
    const url = `https://example.com/viewer/viewer.html?id=${viewerId}&grid=1`;
    const { win, hlsCalls } = createBrowserEnv({ storageData, url, hlsMode: 'mocked' });

    win.eval(viewerSource);

    return new Promise((resolve, reject) => {
      setTimeout(() => {
        try {
          const inst = hlsCalls.instances[0];
          if (!inst) throw new Error('No HLS instance — hlsManifest field not used');
          if (!inst.source || !inst.source.includes('stream.m3u8')) {
            throw new Error(`Expected stream.m3u8 from hlsManifest, got: ${inst.source}`);
          }
          resolve();
        } catch (e) { reject(e); }
      }, 500);
    });
  });
});

/* ========================================================================== */
/* Test: Deep probe deduplication and priority                               */
/* ========================================================================== */

describe('HLS.js: Deep probe deduplication', () => {
  const probeMatch = indexSource.match(/function m3u8DeepProbeFn\(\)[\s\S]*?^}/m);
  if (!probeMatch) throw new Error('Could not find m3u8DeepProbeFn in index.js');
  const probeFnSource = probeMatch[0];

  function runProbeInWin(win) {
    const result = win.eval(`(${probeFnSource})();`);
    if (!Array.isArray(result)) throw new Error(`m3u8DeepProbeFn did not return an array`);
    return result;
  }

  it('should deduplicate manifest found via multiple strategies', () => {
    const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
      url: 'https://example.com/watch',
      runScripts: 'dangerously',
    });
    const win = dom.window;

    // Same URL via multiple detection strategies
    win.hls = { url: 'https://cdn.example.com/stream.m3u8' };
    win.__goon_plugin_data = {
      manifests: ['https://cdn.example.com/stream.m3u8'],
      sources: ['xhr'],
    };
    const script = win.document.createElement('script');
    script.textContent = 'var m = "https://cdn.example.com/stream.m3u8";';
    win.document.body.appendChild(script);

    const results = runProbeInWin(win);

    const duplicates = results.filter(r => r.url === 'https://cdn.example.com/stream.m3u8');
    if (duplicates.length > 1) {
      throw new Error(`Expected deduplication: manifest found ${duplicates.length} times across strategies`);
    }
    if (duplicates.length !== 1) {
      throw new Error(`Manifest not found. Results: ${JSON.stringify(results)}`);
    }
  });

  it('should deduplicate via interceptor strategy (seen Set prevents duplicates)', () => {
    // The seen Set in m3u8DeepProbeFn ensures that once a URL is found by any
    // earlier strategy, later strategies skip it. Strategy order: A(player globals),
    // B(video elements), C(inline scripts), D(config globals), E(__goon_plugin_data).
    // When __goon_plugin_data is the ONLY source, it should be the player label.
    const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
      url: 'https://example.com/watch',
      runScripts: 'dangerously',
    });
    const win = dom.window;

    // Only interceptor-collected data (Strategy E)
    win.__goon_plugin_data = {
      manifests: ['https://cdn.example.com/stream.m3u8'],
      sources: ['xhr'],
    };

    const results = runProbeInWin(win);
    const found = results.find(r => r.url === 'https://cdn.example.com/stream.m3u8');
    if (!found) throw new Error('Manifest not found');
    if (found.player !== '__goon_plugin_data') {
      throw new Error(`Expected player=__goon_plugin_data, got: ${found.player}`);
    }
  });
});

/* ========================================================================== */
/* Test: dedupManifests priority sorting                                     */
/* ========================================================================== */

describe('HLS.js: Manifest priority sorting', () => {
  it('should sort manifests by priority: interceptor > player > inline-script', () => {
    // Extract dedupManifests from index.js
    const dedupMatch = indexSource.match(/function dedupManifests\(allManifests\)[\s\S]*?^}/m);
    if (!dedupMatch) throw new Error('Could not find dedupManifests in index.js');

    // Check playerRank values enforce correct priority
    const rankMatch = indexSource.match(/const playerRank = \{[\s\S]*?\}/);
    if (!rankMatch) throw new Error('Could not find playerRank in index.js');

    const rankText = rankMatch[0];
    // __goon_plugin_data should have lowest rank number (highest priority)
    if (!rankText.includes("'__goon_plugin_data': 0")) {
      throw new Error('__goon_plugin_data should have rank 0 (highest priority)');
    }
    // inline-script should have highest rank number (lowest priority)
    if (!rankText.includes("'inline-script': 99")) {
      throw new Error('inline-script should have rank 99 (lowest priority)');
    }
  });

  it('should filter out .ts segment URLs, keeping only manifests', () => {
    const filterMatch = indexSource.match(/function filterManifests\(manifests\)[\s\S]*?^}/m);
    if (!filterMatch) throw new Error('Could not find filterManifests in index.js');

    const filterText = filterMatch[0];
    // Should filter by .m3u8 / .hlsvod extensions
    if (!filterText.includes('.m3u8') || !filterText.includes('.hlsvod')) {
      throw new Error('filterManifests should check for .m3u8 and .hlsvod extensions');
    }
    // Should handle .ts segment URLs separately
    if (!filterText.includes('.ts')) {
      throw new Error('filterManifests should handle .ts segment URLs');
    }
  });
});

/* ========================================================================== */
/* Test: End-to-end interceptor -> deep probe pipeline                       */
/* ========================================================================== */

describe('HLS.js: End-to-end detection pipeline', () => {
  it('should collect intercepted manifests and pass them to deep probe', () => {
    // Pipeline verification:
    // 1. interceptors.js -> window.__goon_plugin_data.manifests[]
    if (!interceptorSource.includes('window.__goon_plugin_data.manifests')) {
      throw new Error('interceptors.js does not write to __goon_plugin_data.manifests');
    }
    // 2. m3u8DeepProbeFn reads from __goon_plugin_data.manifests
    if (!indexSource.includes('window.__goon_plugin_data.manifests')) {
      throw new Error('m3u8DeepProbeFn does not read from __goon_plugin_data.manifests');
    }
    // 3. content.js collects from postMessage
    if (!contentSource.includes('interceptedManifests')) {
      throw new Error('content.js does not track intercepted manifests');
    }
    // 4. viewer.js uses hlsManifest from storage
    if (!viewerSource.includes('hlsManifest')) {
      throw new Error('viewer.js does not use hlsManifest field');
    }
  });

  it('should handle the full hls.js lifecycle: create -> play -> error -> recover -> destroy', () => {
    const lifecycleSteps = [
      { step: 'create HLS instance', pattern: /new window\.Hls\(HLS_CONFIG\)/ },
      { step: 'loadSource', pattern: /hls\.loadSource/ },
      { step: 'attachMedia', pattern: /hls\.attachMedia/ },
      { step: 'wireHlsEvents', pattern: /wireHlsEvents\(hls/ },
      { step: 'wireVideoEvents', pattern: /wireVideoEvents\(video\)/ },
      { step: 'startBufferMonitor', pattern: /startBufferMonitor\(video/ },
      { step: 'destroy on error', pattern: /hls\.destroy\(\)/ },
      { step: 'recoverMediaError', pattern: /hls\.recoverMediaError\(\)/ },
      { step: 'destroy on unload', pattern: /destroyHls/ },
    ];

    for (const { step, pattern } of lifecycleSteps) {
      if (!pattern.test(viewerSource)) {
        throw new Error(`Missing lifecycle step: ${step}`);
      }
    }
  });
});

/* ========================================================================== */
/* Test: Fragment tracking accuracy                                          */
/* ========================================================================== */

describe('HLS.js: Fragment tracking accuracy', () => {
  it('should correctly count segments loaded via FRAG_LOADED events', () => {
    const storageData = {};
    const viewerId = 'test_seg_count';
    storageData[viewerId] = [{ url: 'x', src: 'x', hlsManifest: 'https://cdn.example.com/stream.m3u8', mediaType: 'hls' }];
    const url = `https://example.com/viewer/viewer.html?id=${viewerId}&grid=1`;
    const { win, hlsCalls } = createBrowserEnv({ storageData, url, hlsMode: 'mocked' });

    win.eval(viewerSource);

    return new Promise((resolve, reject) => {
      setTimeout(() => {
        try {
          const inst = hlsCalls.instances[0];
          const fragLoadedHandlers = inst.events['fragLoaded'];

          for (let i = 0; i < 5; i++) {
            fragLoadedHandlers[0]('fragLoaded', { frag: { level: 0, sn: i } });
          }

          const overlay = win.document.querySelector('.panel-overlay');
          if (!overlay) throw new Error('No panel overlay');
          if (!overlay.textContent.includes('5 seg')) {
            throw new Error(`Expected '5 seg' in overlay, got: ${overlay.textContent}`);
          }

          resolve();
        } catch (e) { reject(e); }
      }, 500);
    });
  });

  it('should reset segment count on BUFFER_RESET event', () => {
    const storageData = {};
    const viewerId = 'test_buf_reset';
    storageData[viewerId] = [{ url: 'x', src: 'x', hlsManifest: 'https://cdn.example.com/stream.m3u8', mediaType: 'hls' }];
    const url = `https://example.com/viewer/viewer.html?id=${viewerId}&grid=1`;
    const { win, hlsCalls } = createBrowserEnv({ storageData, url, hlsMode: 'mocked' });

    win.eval(viewerSource);

    return new Promise((resolve, reject) => {
      setTimeout(() => {
        try {
          const inst = hlsCalls.instances[0];

          // Load some segments first
          for (let i = 0; i < 3; i++) {
            inst.events['fragLoaded'][0]('fragLoaded', { frag: { level: 0, sn: i } });
          }

          // Trigger BUFFER_RESET
          inst.events['bufferReset'][0]('bufferReset');

          const overlay = win.document.querySelector('.panel-overlay');
          if (!overlay) throw new Error('No panel overlay');
          // After buffer reset, segmentsLoaded should be 0
          if (overlay.textContent.includes('3 seg')) {
            throw new Error(`Expected segment count to reset after BUFFER_RESET, still shows '3 seg'`);
          }

          resolve();
        } catch (e) { reject(e); }
      }, 500);
    });
  });

  it('should track buffer health updates via BUFFER_APPENDED', () => {
    const storageData = {};
    const viewerId = 'test_buf_append';
    storageData[viewerId] = [{ url: 'x', src: 'x', hlsManifest: 'https://cdn.example.com/stream.m3u8', mediaType: 'hls' }];
    const url = `https://example.com/viewer/viewer.html?id=${viewerId}&grid=1`;
    const { win, hlsCalls } = createBrowserEnv({ storageData, url, hlsMode: 'mocked' });

    win.eval(viewerSource);

    return new Promise((resolve, reject) => {
      setTimeout(() => {
        try {
          const inst = hlsCalls.instances[0];

          inst.events['bufferAppended'][0]('bufferAppended');

          const overlay = win.document.querySelector('.panel-overlay');
          if (!overlay) throw new Error('No panel overlay');
          if (!overlay.textContent.includes('buf')) {
            throw new Error(`Expected buffer info in overlay, got: ${overlay.textContent}`);
          }

          resolve();
        } catch (e) { reject(e); }
      }, 500);
    });
  });
});