benchmark.js

import { chromium, firefox, webkit } from 'playwright';
import { execSync } from 'child_process';
import readline from 'readline';
import { readFileSync, existsSync } from 'fs';

// Predefined test websites
const PRESET_WEBSITES = {
  '1': {
    name: 'BBC',
    hasSubmenu: true,
    submenu: {
      '0': { name: 'BBC - Hlavní stránka', url: 'https://www.bbc.com' },
      '1': { name: 'BBC News', url: 'https://www.bbc.com/news' },
      '2': { name: 'BBC Sport', url: 'https://www.bbc.com/sport' },
      '3': { name: 'BBC Business', url: 'https://www.bbc.com/business' },
      '4': { name: 'BBC Innovation', url: 'https://www.bbc.com/innovation' },
      '5': { name: 'BBC Health', url: 'https://www.bbc.com/health' },
      '6': { name: 'BBC Culture', url: 'https://www.bbc.com/culture' },
      '7': { name: 'BBC Arts', url: 'https://www.bbc.com/arts' },
      '8': { name: 'BBC Travel', url: 'https://www.bbc.com/travel' },
      '9': { name: 'BBC Earth', url: 'https://www.bbc.com/earth' },
      '10': { name: 'BBC Audio', url: 'https://www.bbc.com/sounds' },
      '11': { name: 'BBC Video', url: 'https://www.bbc.com/video' },
      '12': { name: 'BBC Live', url: 'https://www.bbc.com/live' },
    }
  },
  '2': {
    name: 'Seznam.cz',
    hasSubmenu: true,
    submenu: {
      '0': { name: 'Seznam.cz - Hlavní stránka', url: 'https://www.seznam.cz' },
      '1': { name: 'Seznam - Internet (Vyhledávání)', url: 'https://search.seznam.cz' },
      '2': { name: 'Seznam - Firmy', url: 'https://www.firmy.cz' },
      '3': { name: 'Seznam - Mapy', url: 'https://mapy.cz' },
      '4': { name: 'Seznam - Zboží', url: 'https://www.zbozi.cz' },
      '5': { name: 'Seznam - Obrázky', url: 'https://search.seznam.cz/?obrázky' },
      '6': { name: 'Seznam - Slovník', url: 'https://slovnik.seznam.cz' },
      '7': { name: 'Seznam - Jízdní řády', url: 'https://jizdnirady.idnes.cz' },
      '8': { name: 'Seznam - Video', url: 'https://video.seznam.cz' },
    }
  },
  '3': {
    name: 'Y Combinator / Hacker News',
    hasSubmenu: true,
    submenu: {
      '0': { name: 'Y Combinator - Hlavní stránka', url: 'https://www.ycombinator.com' },
      '1': { name: 'Hacker News - Front page', url: 'https://news.ycombinator.com' },
      '2': { name: 'Hacker News - New', url: 'https://news.ycombinator.com/newest' },
      '3': { name: 'Hacker News - Ask HN', url: 'https://news.ycombinator.com/ask' },
      '4': { name: 'Hacker News - Show HN', url: 'https://news.ycombinator.com/show' },
      '5': { name: 'YC Companies - Portfolio', url: 'https://www.ycombinator.com/companies' },
      '6': { name: 'YC Library - Články', url: 'https://www.ycombinator.com/library' },
    }
  },
  '4': {
    name: 'Wikipedia',
    hasSubmenu: true,
    submenu: {
      '0': { name: 'Wikipedia - Hlavní stránka', url: 'https://www.wikipedia.org' },
      '1': { name: 'Wikipedia - United States (EN)', url: 'https://en.wikipedia.org/wiki/United_States' },
      '2': { name: 'Wikipedia - World War II (EN)', url: 'https://en.wikipedia.org/wiki/World_War_II' },
      '3': { name: 'Wikipedia - World Heritage Sites (EN)', url: 'https://en.wikipedia.org/wiki/Lists_of_World_Heritage_Sites' },
      '4': { name: 'Wikipedia - Solar System (EN)', url: 'https://en.wikipedia.org/wiki/Solar_System' },
      '5': { name: 'Wikipedia - Česko (CZ)', url: 'https://cs.wikipedia.org/wiki/Česko' },
    }
  },
};

// Benchmark configuration
const config = {
  headless: !process.argv.includes('--headed'), // Default: headless mode
  useChromeChannel: true, // Try to use installed Chrome instead of Chromium
};

// Helper: Detect installed Chrome
function detectChrome() {
  const chromePaths = [
    'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
    'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
  ];

  for (const path of chromePaths) {
    if (existsSync(path)) {
      return path;
    }
  }
  return null;
}

// Helper: Detect installed Edge
function detectEdge() {
  const edgePaths = [
    'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
    'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe',
  ];

  for (const path of edgePaths) {
    if (existsSync(path)) {
      return path;
    }
  }
  return null;
}

// Benchmark results
const results = {
  chrome: { name: 'Chrome (Chromium)', tests: [] },
  edge: { name: 'Microsoft Edge', tests: [] }
};

// Helper: Generate timestamp in YYYYMMDD_HHMMSS format
function getTimestamp() {
  const now = new Date();
  const year = now.getFullYear();
  const month = String(now.getMonth() + 1).padStart(2, '0');
  const day = String(now.getDate()).padStart(2, '0');
  const hours = String(now.getHours()).padStart(2, '0');
  const minutes = String(now.getMinutes()).padStart(2, '0');
  const seconds = String(now.getSeconds()).padStart(2, '0');
  return `${year}${month}${day}_${hours}${minutes}${seconds}`;
}

// Helper: Generate filename from URLs
function generateFilename(websites) {
  // Get the first website's domain/URL to use in filename
  const firstUrl = websites[0].url;

  // Add headless/headed to filename
  const mode = config.headless ? 'headless' : 'headed';

  // Extract domain from URL
  try {
    const url = new URL(firstUrl);
    const domain = url.hostname.replace(/^www\./, ''); // Remove www.
    const safeDomain = domain.replace(/\./g, '_'); // Replace dots with underscores
    const timestamp = getTimestamp();
    return `output/speedtest_${mode}_${safeDomain}_${timestamp}.json`;
  } catch {
    // Fallback if URL parsing fails
    const timestamp = getTimestamp();
    return `output/speedtest_${mode}_${timestamp}.json`;
  }
}

// ============================================================================
// TRACKER DATABÁZE - Dynamické načítání z Disconnect.me
// ============================================================================
// CO: Globální úložiště známých tracker domén s jejich informacemi
// PROČ: Potřebujeme aktuální seznam trackerů pro identifikaci na webech
// JAK: Načítá se při startu programu z open-source databáze Disconnect.me
let KNOWN_TRACKERS = {};

// Popisy kategorií trackerů v češtině
// CO: Lidsky čitelné popisy pro každou kategorii trackeru
// PROČ: Uživatel vidí co daný tracker dělá (reklamy, analytics, social, atd.)
const CATEGORY_DESCRIPTIONS = {
  'Advertising': 'Sleduje návštěvnost pro cílení reklamy a měření konverzí',
  'Analytics': 'Sbírá data o chování uživatelů a návštěvnosti webu',
  'Social': 'Sleduje aktivitu na sociálních sítích a umožňuje sdílení',
  'Disconnect': 'Různé trackery a služby',
  'Content': 'Poskytuje obsah a multimédia třetích stran',
};

// Převod názvu trackeru na URL slug pro WhoTracks.me
// CO: Konvertuje "Google Analytics" → "google_analytics"
// PROČ: WhoTracks.me používá URL ve formátu /trackers/google_analytics
// JAK: Lowercase + nahrazení mezer podtržítky + odstranění speciálních znaků
function toWhoTracksSlug(companyName) {
  return companyName
    .toLowerCase()
    .replace(/\s+/g, '_')        // Mezery → podtržítka
    .replace(/[()]/g, '')         // Odstranit závorky
    .replace(/\./g, '')           // Odstranit tečky
    .replace(/_+/g, '_');         // Vícenásobná podtržítka → jedno
}

// Dynamické načtení tracker databáze z Disconnect.me
// CO: Stáhne JSON se seznamem ~4700 tracker domén a jejich info
// PROČ: Open-source databáze trackerů, pravidelně aktualizovaná
// JAK: HTTP fetch → parse JSON → extrakce domén a kategorií
async function loadTrackers() {
  try {
    // Stažení databáze z GitHub repozitáře Disconnect.me
    const response = await fetch('https://raw.githubusercontent.com/disconnectme/disconnect-tracking-protection/master/services.json');
    const data = await response.json();

    const trackers = {};
    let count = 0;

    // Extrakce VŠECH trackerů ze všech kategorií
    // CO: Procházení JSON struktury a extrakce domén
    // PROČ: Chceme kompletní seznam, ne jen TOP 100
    // JAK: Nested loops přes categories → companies → domains
    for (const [categoryName, companies] of Object.entries(data.categories)) {
      for (const company of companies) {
        const companyName = Object.keys(company)[0];
        const companyData = company[companyName];
        const domains = Object.values(companyData)[0]; // Array of tracking domains

        if (Array.isArray(domains)) {
          for (const domain of domains) {
            // Uložení domény s metadaty (název firmy + kategorie)
            // CO: Mapa domain → {name, category}
            // PROČ: Potřebujeme vědět kdo tracker provozuje a k čemu slouží
            trackers[domain] = {
              name: companyName,
              category: categoryName,
            };
            count++;
          }
        }
      }
    }

    KNOWN_TRACKERS = trackers;
    console.log(`✅ Načteno ${count} trackerů z Disconnect.me databáze\n`);
    return true;
  } catch (error) {
    // Fallback mechanismus pokud se nepodaří stáhnout z webu
    // CO: Použití záložního statického seznamu
    // PROČ: Program musí fungovat i offline nebo při výpadku GitHub
    console.error(`⚠️  Nepodařilo se načíst trackery z Disconnect.me: ${error.message}`);
    console.log('   Používám záložní statický seznam...\n');

    // Fallback to static list with category info
    KNOWN_TRACKERS = {
      // Google ecosystem
      'google-analytics.com': { name: 'Google Analytics', category: 'Analytics' },
      'googletagmanager.com': { name: 'Google Tag Manager', category: 'Analytics' },
      'googleadservices.com': { name: 'Google AdWords', category: 'Advertising' },
      'googlesyndication.com': { name: 'Google AdSense', category: 'Advertising' },
      'doubleclick.net': { name: 'DoubleClick', category: 'Advertising' },
      'google.com': { name: 'Google', category: 'Advertising' },

      // Facebook/Meta ecosystem
      'facebook.com/tr': { name: 'Facebook Pixel', category: 'Advertising' },
      'facebook.net': { name: 'Facebook', category: 'Social' },
      'connect.facebook.net': { name: 'Facebook SDK', category: 'Social' },
      'fbcdn.net': { name: 'Facebook CDN', category: 'Social' },

      // Analytics & Site Monitoring
      'cloudflare.com': { name: 'Cloudflare', category: 'Content' },
      'cloudflareinsights.com': { name: 'Cloudflare Insights', category: 'Analytics' },
      'newrelic.com': { name: 'New Relic', category: 'Analytics' },
      'nr-data.net': { name: 'New Relic', category: 'Analytics' },
      'hotjar.com': { name: 'Hotjar', category: 'Analytics' },
      'mouseflow.com': { name: 'Mouseflow', category: 'Analytics' },
      'clarity.ms': { name: 'Microsoft Clarity', category: 'Analytics' },
      'mixpanel.com': { name: 'Mixpanel', category: 'Analytics' },
      'amplitude.com': { name: 'Amplitude', category: 'Analytics' },
      'segment.com': { name: 'Segment', category: 'Analytics' },
      'segment.io': { name: 'Segment', category: 'Analytics' },

      // Advertising Networks
      'criteo.com': { name: 'Criteo', category: 'Advertising' },
      'criteo.net': { name: 'Criteo', category: 'Advertising' },
      'adroll.com': { name: 'AdRoll', category: 'Advertising' },
      'outbrain.com': { name: 'Outbrain', category: 'Advertising' },
      'taboola.com': { name: 'Taboola', category: 'Advertising' },
      'pubmatic.com': { name: 'PubMatic', category: 'Advertising' },
      'rubiconproject.com': { name: 'Rubicon Project', category: 'Advertising' },
      'openx.net': { name: 'OpenX', category: 'Advertising' },
      'advertising.com': { name: 'AOL Advertising', category: 'Advertising' },
      'adsrvr.org': { name: 'The Trade Desk', category: 'Advertising' },

      // Advertising ID Sync
      'id5-sync.com': { name: 'ID5', category: 'Advertising' },
      'crwdcntrl.net': { name: 'Lotame', category: 'Advertising' },
      'lotame.com': { name: 'Lotame', category: 'Advertising' },
      'rlcdn.com': { name: 'LiveRamp', category: 'Advertising' },

      // Social Media Trackers
      'ads-twitter.com': { name: 'Twitter Ads', category: 'Social' },
      'analytics.twitter.com': { name: 'Twitter Analytics', category: 'Social' },
      'linkedin.com/px': { name: 'LinkedIn Insight', category: 'Social' },
      'pinterest.com/ct': { name: 'Pinterest Tag', category: 'Social' },
      'snapchat.com/p': { name: 'Snapchat Pixel', category: 'Social' },
      'tiktok.com/i18n/pixel': { name: 'TikTok Pixel', category: 'Social' },

      // Analytics Vendors
      'quantserve.com': { name: 'Quantcast', category: 'Analytics' },
      'scorecardresearch.com': { name: 'ComScore', category: 'Analytics' },
      'chartbeat.com': { name: 'Chartbeat', category: 'Analytics' },
      'kissmetrics.com': { name: 'Kissmetrics', category: 'Analytics' },

      // European/Regional Trackers
      'gemius.pl': { name: 'Gemius', category: 'Analytics' },
      'im.cz': { name: 'Seznam Analytics', category: 'Analytics' },
      'imedia.cz': { name: 'Seznam', category: 'Content' },
      'yandex.ru/metrika': { name: 'Yandex Metrica', category: 'Analytics' },
    };
    return false;
  }
}

// ============================================================================
// DETEKCE TRACKERU - Identifikace trackeru z URL
// ============================================================================
// CO: Zjistí zda URL patří známému trackeru
// PROČ: Musíme rozpoznat trackery v network requests, DOM, cookies, atd.
// JAK: Extrakce hostname → porovnání s databází (včetně subdomén)
function detectTracker(url) {
  // Extrakce hostname z URL
  // CO: Z "https://a.example.com/path" → "a.example.com"
  // PROČ: Trackery se identifikují podle domény, ne celé URL
  // JAK: URL parser (s fallbackem na regex pokud selže)
  let hostname = '';
  try {
    const urlObj = new URL(url);
    hostname = urlObj.hostname.toLowerCase();
  } catch {
    // Fallback pokud URL není validní (např. relative path)
    const match = url.match(/^https?:\/\/([^\/]+)/);
    if (match) {
      hostname = match[1].toLowerCase();
    } else {
      return null;
    }
  }

  // Porovnání s databází trackerů
  // CO: Hledá shodu hostname s tracker doménami
  // PROČ: Chceme najít trackery i na subdoménách (b.scorecardresearch.com)
  // JAK: Přesná shoda NEBO hostname končí na ".doména"
  for (const [domain, trackerInfo] of Object.entries(KNOWN_TRACKERS)) {
    const domainLower = domain.toLowerCase();

    // Shoda: přesná shoda nebo subdoména
    // Příklady: "google.com" matchuje "google.com" a "www.google.com"
    if (hostname === domainLower || hostname.endsWith('.' + domainLower)) {
      const slug = toWhoTracksSlug(trackerInfo.name);
      const description = CATEGORY_DESCRIPTIONS[trackerInfo.category] || 'Sledovací služba třetí strany';

      // Vrací kompletní info o trackeru
      return {
        name: trackerInfo.name,
        category: trackerInfo.category,
        description: description,
        url: `https://www.ghostery.com/whotracksme/trackers/${slug}`,
      };
    }
  }
  return null; // Není známý tracker
}

// ============================================================================
// KATEGORIZACE ZDROJŮ - Určení typu načítaného souboru
// ============================================================================
// CO: Klasifikuje network request do kategorie (js, css, image, font, atd.)
// PROČ: Pro analýzu - kolik MB zabírá JS, CSS, obrázky, atd.
// JAK: Kontrola resourceType a MIME type s fallbackem
function getResourceCategory(resourceType, mimeType) {
  const type = resourceType.toLowerCase();

  if (type === 'document') return 'document';
  if (type === 'stylesheet' || mimeType?.includes('css')) return 'css';
  if (type === 'script' || mimeType?.includes('javascript')) return 'javascript';
  if (type === 'image' || mimeType?.includes('image')) return 'image';
  if (type === 'font' || mimeType?.includes('font')) return 'font';
  if (type === 'media' || mimeType?.includes('video') || mimeType?.includes('audio')) return 'media';
  if (type === 'xhr' || type === 'fetch') return 'xhr';

  return 'other';
}

// ============================================================================
// VÝPOČET KVALITY STRÁNKY - Celkové skóre 0-100 bodů
// ============================================================================
// CO: Vypočítá kvalitu stránky (0-100) na základě 5 metrik
// PROČ: Komplexní hodnocení webu - rychlost, velikost, privacy, DOM
// JAK: Váženýprůměr: Performance, Size, Requests, Privacy, DOM Complexity
function calculatePageScore(testResult) {
  // Chyba při testování = 0 bodů
  if (testResult.error) return { total: 0, breakdown: {} };

  // 5 hlavních kategorií hodnocení
  const scores = {
    performance: 0,  // Rychlost načítání (Core Web Vitals + Page Load)
    size: 0,         // Velikost stránky v MB
    requests: 0,     // Počet HTTP requestů
    privacy: 0,      // Trackery a cookies
    dom: 0,          // Složitost DOM stromu
  };

  // ============================================================================
  // 1. PERFORMANCE SCORE - Core Web Vitals + Page Load Time
  // ============================================================================
  // CO: Hodnocení rychlosti na základě LCP, CLS a celkového načítání
  // PROČ: Google ranking factor, uživatelská zkušenost
  // JAK: Lineární škála, každá milisekunda se počítá (přesnost na 2 des. místa)

  // LCP (Largest Contentful Paint): Kdy se vykreslí hlavní obsah
  // CO: Čas do vykreslení největšího elementu v ms → skóre 0-100
  // PROČ: Měří vnímanou rychlost načítání (kdy uživatel vidí obsah)
  // JAK: Lineární stupnice 0s=100 bodů, 6s+=0 bodů
  const lcp = testResult.webVitals.lcp / 1000; // Převod ms → sekundy
  let lcpScore = Math.max(0, 100 - (lcp / 6.0) * 100); // 0s=100, 6s=0

  // CLS (Cumulative Layout Shift): Vizuální stabilita
  // CO: Měří nečekané posuny layoutu během načítání
  // PROČ: Špatná UX když se elementy posouvají (klikneš na X, posune se, klikneš na Y)
  // JAK: Lineární stupnice 0=100 bodů (stabilní), 0.5+=0 bodů (nestabilní)
  const cls = testResult.webVitals.cls;
  let clsScore = Math.max(0, 100 - (cls / 0.5) * 100); // 0=100, 0.5=0

  // Page Load Time: Celkový čas načítání stránky
  // CO: Celkový čas od startu do plného načtení (ms)
  // PROČ: Měří kompletní načtení včetně všech zdrojů
  // JAK: Lineární stupnice 0ms=100 bodů, 7000ms+=0 bodů
  const pageLoad = testResult.timing.pageLoad;
  let pageLoadScore = Math.max(0, 100 - (pageLoad / 7000) * 100); // 0ms=100, 7000ms=0

  // Průměr všech tří performance metrik
  scores.performance = (lcpScore + clsScore + pageLoadScore) / 3;

  // ============================================================================
  // 2. SIZE SCORE - Velikost stránky v MB
  // ============================================================================
  // CO: Hodnocení celkové velikosti stránky (HTML + CSS + JS + images + fonts)
  // PROČ: Menší stránky = rychlejší načítání, menší data, lepší pro mobily
  // JAK: Bodové škály: <1MB=100, <3MB=80, <5MB=60, <10MB=40, 10MB+=20
  const sizeMB = parseFloat(testResult.network.totalSizeMB);
  if (sizeMB < 1) scores.size = 100;      // Vynikající (pod 1 MB)
  else if (sizeMB < 3) scores.size = 80;  // Velmi dobrá (1-3 MB)
  else if (sizeMB < 5) scores.size = 60;  // Dobrá (3-5 MB)
  else if (sizeMB < 10) scores.size = 40; // Průměrná (5-10 MB)
  else scores.size = 20;                   // Špatná (10+ MB)

  // ============================================================================
  // 3. REQUESTS SCORE - Počet HTTP requestů
  // ============================================================================
  // CO: Hodnocení počtu síťových požadavků (každý request = latence)
  // PROČ: Mnoho requestů = pomalé načítání (každý má overhead, RTT, atd.)
  // JAK: Bodové škály: <30=100, <50=80, <100=60, <150=40, 150+=20
  const requests = testResult.network.requests;
  if (requests < 30) scores.requests = 100;      // Vynikající (pod 30 requestů)
  else if (requests < 50) scores.requests = 80;  // Velmi dobrý (30-50)
  else if (requests < 100) scores.requests = 60; // Dobrý (50-100)
  else if (requests < 150) scores.requests = 40; // Průměrný (100-150)
  else scores.requests = 20;                      // Špatný (150+)

  // ============================================================================
  // 4. PRIVACY SCORE - Trackery a third-party cookies
  // ============================================================================
  // CO: Hodnocení soukromí na základě počtu trackerů a 3rd-party cookies
  // PROČ: Trackery = sledování uživatele, ztráta soukromí, GDPR risk
  // JAK: Start na 100, -10 bodů za tracker, -2 body za každý 3rd-party cookie
  const trackers = testResult.privacy.trackers.length;
  const thirdPartyCookies = testResult.privacy.thirdPartyCookies;

  let privacyScore = 100; // Start: perfektní soukromí
  privacyScore -= trackers * 10;           // Každý tracker: -10 bodů (velký dopad)
  privacyScore -= thirdPartyCookies * 2;   // Každý 3rd-party cookie: -2 body
  scores.privacy = Math.max(0, privacyScore); // Minimum 0 bodů

  // ============================================================================
  // 5. DOM COMPLEXITY SCORE - Složitost DOM stromu
  // ============================================================================
  // CO: Hodnocení počtu DOM elementů na stránce
  // PROČ: Velký DOM = pomalé rendering, vysoká paměť, horší performance
  // JAK: Bodové škály: <500=100, <1000=80, <2000=60, <3000=40, 3000+=20
  const elements = testResult.dom.elements;
  if (elements < 500) scores.dom = 100;      // Vynikající (jednoduchý DOM)
  else if (elements < 1000) scores.dom = 80; // Velmi dobrý
  else if (elements < 2000) scores.dom = 60; // Dobrý
  else if (elements < 3000) scores.dom = 40; // Průměrný
  else scores.dom = 20;                       // Špatný (komplexní DOM)

  // ============================================================================
  // CELKOVÉ SKÓRE - Průměr všech 5 kategorií
  // ============================================================================
  // CO: Finální skóre 0-100 bodů
  // PROČ: Jediné číslo pro srovnání kvality stránek
  // JAK: Prostý průměr všech 5 kategorií (každá má stejnou váhu)
  const total = (
    scores.performance +
    scores.size +
    scores.requests +
    scores.privacy +
    scores.dom
  ) / 5;

  return {
    total: Math.round(total),  // Zaokrouhlení na celé číslo
    breakdown: scores,         // Detail každé kategorie
  };
}

// ============================================================================
// ZNÁMKOVÁNÍ SKÓRE - Převod bodů na klasifikaci A+ až F
// ============================================================================
// CO: Převede numerické skóre (0-100) na známku a emoji
// PROČ: Lidsky čitelnější hodnocení než čísla
// JAK: Rozsahy: 90+=A+, 80+=A, 70+=B, 60+=C, 50+=D, <50=F
function getScoreGrade(score) {
  if (score >= 90) return { grade: 'A+', emoji: '🟢', description: 'Vynikající' };
  if (score >= 80) return { grade: 'A', emoji: '🟢', description: 'Velmi dobrý' };
  if (score >= 70) return { grade: 'B', emoji: '🟡', description: 'Dobrý' };
  if (score >= 60) return { grade: 'C', emoji: '🟡', description: 'Průměrný' };
  if (score >= 50) return { grade: 'D', emoji: '🟠', description: 'Podprůměrný' };
  return { grade: 'F', emoji: '🔴', description: 'Špatný' };
}

// Helper: Compare headless vs headed tests
async function compareHeadlessVsHeaded() {
  const fs = await import('fs');

  if (!fs.existsSync('output')) {
    return false;
  }

  const files = fs.readdirSync('output').filter(f => f.endsWith('.json'));

  // Find latest headless and headed tests for same domain
  const headlessFiles = files.filter(f => f.includes('_headless_')).sort().reverse();
  const headedFiles = files.filter(f => f.includes('_headed_')).sort().reverse();

  if (headlessFiles.length === 0 || headedFiles.length === 0) {
    return false;
  }

  // Get latest of each
  const headlessFile = headlessFiles[0];
  const headedFile = headedFiles[0];

  // Extract domain from filename
  const headlessDomain = headlessFile.match(/_headless_(.+?)_\d{8}/)?.[1];
  const headedDomain = headedFile.match(/_headed_(.+?)_\d{8}/)?.[1];

  // Only compare if same domain
  if (headlessDomain !== headedDomain) {
    return false;
  }

  console.log('\n' + '═'.repeat(80));
  console.log('\n📊 Detekoval jsem testy v obou režimech (headless i headed)!\n');

  const rl = createInterface();
  const answer = await question(rl, 'Chceš zobrazit srovnání? (y/N): ');
  rl.close();

  if (!answer.toLowerCase().startsWith('y')) {
    return false;
  }

  // Load both files
  const headless = JSON.parse(fs.readFileSync(`output/${headlessFile}`, 'utf8'));
  const headed = JSON.parse(fs.readFileSync(`output/${headedFile}`, 'utf8'));

  function calcAvg(tests, key) {
    const valid = tests.filter(t => !t.error);
    if (valid.length === 0) return 0;
    return valid.reduce((sum, t) => {
      const keys = key.split('.');
      let val = t;
      for (const k of keys) {
        val = val[k];
        if (val === undefined) return sum;
      }
      return sum + val;
    }, 0) / valid.length;
  }

  console.log('\n' + '═'.repeat(80));
  console.log('SROVNÁNÍ: HEADLESS vs HEADED MODE');
  console.log('═'.repeat(80) + '\n');

  // Chrome comparison
  console.log('GOOGLE CHROME:');
  console.log('                          HEADLESS    HEADED      ROZDÍL');
  console.log('─'.repeat(80));

  const hlChromePageLoad = calcAvg(headless.chrome.tests, 'timing.pageLoad');
  const hdChromePageLoad = calcAvg(headed.chrome.tests, 'timing.pageLoad');
  const diffChromePageLoad = hlChromePageLoad > 0 ? ((hdChromePageLoad - hlChromePageLoad) / hlChromePageLoad * 100).toFixed(1) : '0.0';

  const hlChromeLCP = calcAvg(headless.chrome.tests, 'webVitals.lcp');
  const hdChromeLCP = calcAvg(headed.chrome.tests, 'webVitals.lcp');
  const diffChromeLCP = hlChromeLCP > 0 ? ((hdChromeLCP - hlChromeLCP) / hlChromeLCP * 100).toFixed(1) : '0.0';

  const hlChromeTotal = calcAvg(headless.chrome.tests, 'timing.total');
  const hdChromeTotal = calcAvg(headed.chrome.tests, 'timing.total');
  const diffChromeTotal = hlChromeTotal > 0 ? ((hdChromeTotal - hlChromeTotal) / hlChromeTotal * 100).toFixed(1) : '0.0';

  console.log(`Page Load (ms):           ${hlChromePageLoad.toFixed(0).padStart(6)}    ${hdChromePageLoad.toFixed(0).padStart(6)}    ${diffChromePageLoad > 0 ? '+' : ''}${diffChromePageLoad}%`);
  console.log(`LCP (ms):                 ${hlChromeLCP.toFixed(0).padStart(6)}    ${hdChromeLCP.toFixed(0).padStart(6)}    ${diffChromeLCP > 0 ? '+' : ''}${diffChromeLCP}%`);
  console.log(`Total Time (ms):          ${hlChromeTotal.toFixed(0).padStart(6)}    ${hdChromeTotal.toFixed(0).padStart(6)}    ${diffChromeTotal > 0 ? '+' : ''}${diffChromeTotal}%`);

  // Edge comparison
  console.log('\nMICROSOFT EDGE:');
  console.log('                          HEADLESS    HEADED      ROZDÍL');
  console.log('─'.repeat(80));

  const hlEdgePageLoad = calcAvg(headless.edge.tests, 'timing.pageLoad');
  const hdEdgePageLoad = calcAvg(headed.edge.tests, 'timing.pageLoad');
  const diffEdgePageLoad = hlEdgePageLoad > 0 ? ((hdEdgePageLoad - hlEdgePageLoad) / hlEdgePageLoad * 100).toFixed(1) : '0.0';

  const hlEdgeLCP = calcAvg(headless.edge.tests, 'webVitals.lcp');
  const hdEdgeLCP = calcAvg(headed.edge.tests, 'webVitals.lcp');
  const diffEdgeLCP = hlEdgeLCP > 0 ? ((hdEdgeLCP - hlEdgeLCP) / hlEdgeLCP * 100).toFixed(1) : '0.0';

  const hlEdgeTotal = calcAvg(headless.edge.tests, 'timing.total');
  const hdEdgeTotal = calcAvg(headed.edge.tests, 'timing.total');
  const diffEdgeTotal = hlEdgeTotal > 0 ? ((hdEdgeTotal - hlEdgeTotal) / hlEdgeTotal * 100).toFixed(1) : '0.0';

  console.log(`Page Load (ms):           ${hlEdgePageLoad.toFixed(0).padStart(6)}    ${hdEdgePageLoad.toFixed(0).padStart(6)}    ${diffEdgePageLoad > 0 ? '+' : ''}${diffEdgePageLoad}%`);
  console.log(`LCP (ms):                 ${hlEdgeLCP.toFixed(0).padStart(6)}    ${hdEdgeLCP.toFixed(0).padStart(6)}    ${diffEdgeLCP > 0 ? '+' : ''}${diffEdgeLCP}%`);
  console.log(`Total Time (ms):          ${hlEdgeTotal.toFixed(0).padStart(6)}    ${hdEdgeTotal.toFixed(0).padStart(6)}    ${diffEdgeTotal > 0 ? '+' : ''}${diffEdgeTotal}%`);

  // Conclusion
  console.log('\n' + '═'.repeat(80));
  console.log('ZÁVĚR:');
  console.log('═'.repeat(80));

  const avgDiff = (parseFloat(diffChromePageLoad) + parseFloat(diffEdgePageLoad)) / 2;

  if (Math.abs(avgDiff) < 5) {
    console.log('✅ Headed vs Headless: MINIMÁLNÍ ROZDÍL (<5%)');
    console.log('   Výsledky jsou konzistentní napříč režimy!');
  } else {
    console.log('⚠️  Headed vs Headless: VÝZNAMNÝ ROZDÍL (>5%)');
    console.log('   Vykreslování má vliv na měření výkonu.');
  }

  console.log('\n' + '═'.repeat(80) + '\n');

  return true;
}

// Helper: Create readline interface
function createInterface() {
  return readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });
}

// Helper: Ask question
function question(rl, prompt) {
  return new Promise((resolve) => {
    rl.question(prompt, (answer) => {
      resolve(answer);
    });
  });
}

// Show BBC submenu
async function showBBCSubmenu(rl, selectedUrls) {
  console.log('\n┌────────────────────────────────────────────────────────────┐');
  console.log('│              📺 BBC PODSTRÁNKY 📺                          │');
  console.log('└────────────────────────────────────────────────────────────┘\n');

  console.log('  0. Hlavní stránka (www.bbc.com)');
  console.log('  1. News');
  console.log('  2. Sport');
  console.log('  3. Business');
  console.log('  4. Innovation');
  console.log('  5. Health');
  console.log('  6. Culture');
  console.log('  7. Arts');
  console.log('  8. Travel');
  console.log('  9. Earth');
  console.log(' 10. Audio');
  console.log(' 11. Video');
  console.log(' 12. Live');
  console.log('  A. Všechny BBC podstránky (0-12)');
  console.log('\n');

  while (true) {
    const subChoice = await question(rl, 'Vyber podstránku (0-12, A=všechny) nebo ENTER pro návrat: ');

    if (subChoice.trim() === '') {
      break; // Návrat do hlavního menu
    }

    if (subChoice.toUpperCase() === 'A') {
      // Přidat všechny BBC podstránky
      const bbcSubmenu = PRESET_WEBSITES['1'].submenu;
      let addedCount = 0;

      for (const [key, site] of Object.entries(bbcSubmenu)) {
        if (!selectedUrls.find(u => u.url === site.url)) {
          selectedUrls.push(site);
          addedCount++;
        }
      }

      console.log(`\n   ✅ Přidáno ${addedCount} BBC podstránek\n`);
      break; // Vrátit se do hlavního menu
    }

    const bbcSubmenu = PRESET_WEBSITES['1'].submenu;
    if (bbcSubmenu[subChoice]) {
      const site = bbcSubmenu[subChoice];

      if (selectedUrls.find(u => u.url === site.url)) {
        console.log(`   ⚠️  ${site.name} už je v seznamu!\n`);
      } else {
        selectedUrls.push(site);
        console.log(`   ✅ Přidáno: ${site.name}\n`);
      }
    } else {
      console.log('   ❌ Neplatná volba, zkus znovu.\n');
    }
  }
}

// Show Seznam.cz submenu
async function showSeznamSubmenu(rl, selectedUrls) {
  console.log('\n┌────────────────────────────────────────────────────────────┐');
  console.log('│            📋 SEZNAM.CZ SLUŽBY 📋                          │');
  console.log('└────────────────────────────────────────────────────────────┘\n');

  console.log('  0. Hlavní stránka (www.seznam.cz)');
  console.log('  1. Internet (Vyhledávání)');
  console.log('  2. Firmy');
  console.log('  3. Mapy');
  console.log('  4. Zboží');
  console.log('  5. Obrázky');
  console.log('  6. Slovník');
  console.log('  7. Jízdní řády');
  console.log('  8. Video');
  console.log('  A. Všechny Seznam služby (0-8)');
  console.log('\n');

  while (true) {
    const subChoice = await question(rl, 'Vyber službu (0-8, A=všechny) nebo ENTER pro návrat: ');

    if (subChoice.trim() === '') {
      break; // Návrat do hlavního menu
    }

    if (subChoice.toUpperCase() === 'A') {
      // Přidat všechny Seznam služby
      const seznamSubmenu = PRESET_WEBSITES['2'].submenu;
      let addedCount = 0;

      for (const [key, site] of Object.entries(seznamSubmenu)) {
        if (!selectedUrls.find(u => u.url === site.url)) {
          selectedUrls.push(site);
          addedCount++;
        }
      }

      console.log(`\n   ✅ Přidáno ${addedCount} Seznam služeb\n`);
      break; // Vrátit se do hlavního menu
    }

    const seznamSubmenu = PRESET_WEBSITES['2'].submenu;
    if (seznamSubmenu[subChoice]) {
      const site = seznamSubmenu[subChoice];

      if (selectedUrls.find(u => u.url === site.url)) {
        console.log(`   ⚠️  ${site.name} už je v seznamu!\n`);
      } else {
        selectedUrls.push(site);
        console.log(`   ✅ Přidáno: ${site.name}\n`);
      }
    } else {
      console.log('   ❌ Neplatná volba, zkus znovu.\n');
    }
  }
}

// Show Y Combinator / Hacker News submenu
async function showYCSubmenu(rl, selectedUrls) {
  console.log('\n┌────────────────────────────────────────────────────────────┐');
  console.log('│        🚀 Y COMBINATOR / HACKER NEWS 🚀                    │');
  console.log('└────────────────────────────────────────────────────────────┘\n');

  console.log('  0. Y Combinator - Hlavní stránka');
  console.log('  1. Hacker News - Front page');
  console.log('  2. Hacker News - New');
  console.log('  3. Hacker News - Ask HN');
  console.log('  4. Hacker News - Show HN');
  console.log('  5. YC Companies - Portfolio');
  console.log('  6. YC Library - Články');
  console.log('  A. Všechny stránky (0-6)');
  console.log('\n');

  while (true) {
    const subChoice = await question(rl, 'Vyber stránku (0-6, A=všechny) nebo ENTER pro návrat: ');

    if (subChoice.trim() === '') {
      break; // Návrat do hlavního menu
    }

    if (subChoice.toUpperCase() === 'A') {
      // Přidat všechny YC stránky
      const ycSubmenu = PRESET_WEBSITES['3'].submenu;
      let addedCount = 0;

      for (const [key, site] of Object.entries(ycSubmenu)) {
        if (!selectedUrls.find(u => u.url === site.url)) {
          selectedUrls.push(site);
          addedCount++;
        }
      }

      console.log(`\n   ✅ Přidáno ${addedCount} YC/HN stránek\n`);
      break; // Vrátit se do hlavního menu
    }

    const ycSubmenu = PRESET_WEBSITES['3'].submenu;
    if (ycSubmenu[subChoice]) {
      const site = ycSubmenu[subChoice];

      if (selectedUrls.find(u => u.url === site.url)) {
        console.log(`   ⚠️  ${site.name} už je v seznamu!\n`);
      } else {
        selectedUrls.push(site);
        console.log(`   ✅ Přidáno: ${site.name}\n`);
      }
    } else {
      console.log('   ❌ Neplatná volba, zkus znovu.\n');
    }
  }
}

// Show Wikipedia submenu
async function showWikipediaSubmenu(rl, selectedUrls) {
  console.log('\n┌────────────────────────────────────────────────────────────┐');
  console.log('│              📖 WIKIPEDIA ČLÁNKY 📖                        │');
  console.log('└────────────────────────────────────────────────────────────┘\n');

  console.log('  0. Hlavní stránka (www.wikipedia.org)');
  console.log('  1. United States (EN) - Komplexní článek');
  console.log('  2. World War II (EN) - Extrémně dlouhý');
  console.log('  3. World Heritage Sites (EN) - Masivní seznam');
  console.log('  4. Solar System (EN) - Vědecký s vizualizacemi');
  console.log('  5. Česko (CZ) - Národní článek');
  console.log('  A. Všechny články (0-5)');
  console.log('\n');

  while (true) {
    const subChoice = await question(rl, 'Vyber článek (0-5, A=všechny) nebo ENTER pro návrat: ');

    if (subChoice.trim() === '') {
      break; // Návrat do hlavního menu
    }

    if (subChoice.toUpperCase() === 'A') {
      // Přidat všechny Wikipedia články
      const wikiSubmenu = PRESET_WEBSITES['4'].submenu;
      let addedCount = 0;

      for (const [key, site] of Object.entries(wikiSubmenu)) {
        if (!selectedUrls.find(u => u.url === site.url)) {
          selectedUrls.push(site);
          addedCount++;
        }
      }

      console.log(`\n   ✅ Přidáno ${addedCount} Wikipedia článků\n`);
      break; // Vrátit se do hlavního menu
    }

    const wikiSubmenu = PRESET_WEBSITES['4'].submenu;
    if (wikiSubmenu[subChoice]) {
      const site = wikiSubmenu[subChoice];

      if (selectedUrls.find(u => u.url === site.url)) {
        console.log(`   ⚠️  ${site.name} už je v seznamu!\n`);
      } else {
        selectedUrls.push(site);
        console.log(`   ✅ Přidáno: ${site.name}\n`);
      }
    } else {
      console.log('   ❌ Neplatná volba, zkus znovu.\n');
    }
  }
}

// Discover sub-pages from a custom URL
// autoSelectLimit: if provided (e.g. '5', '10', 'all'), skip menu and auto-select pages
async function discoverSubPages(rl, baseUrl, autoSelectLimit = null) {
  console.log(`\n🔍 Analyzuji ${baseUrl}...`);
  let browser = null;

  try {
    // Detect Chrome or Edge installation (same as main tests)
    const chromePath = detectChrome();
    const edgePath = detectEdge();

    const launchOptions = {
      headless: config.headless,
    };

    if (chromePath) {
      launchOptions.executablePath = chromePath;
    } else if (edgePath) {
      console.log('   ℹ️  Chrome nenalezen, používám Edge...');
      launchOptions.executablePath = edgePath;
    } else {
      // If neither Chrome nor Edge found, try Playwright chromium
      console.log('   ⚠️  Chrome ani Edge nenalezeny, zkouším Playwright Chromium...');
    }

    browser = await chromium.launch(launchOptions);
    const page = await browser.newPage({
      userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36'
    });

    // Navigate to the page with fallback strategy
    try {
      await page.goto(baseUrl, { waitUntil: 'load', timeout: 30000 });
      // Try to wait for networkidle but don't fail if timeout
      await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {});
    } catch (e) {
      if (e.message.includes('closed') || e.message.includes('timeout')) {
        await page.goto(baseUrl, { waitUntil: 'domcontentloaded', timeout: 30000 });
      } else {
        throw e;
      }
    }

    // Extract all links
    const links = await page.evaluate(() => {
      const anchors = Array.from(document.querySelectorAll('a[href]'));
      return anchors.map(a => ({
        href: a.href,
        text: a.textContent.trim().substring(0, 60) // Limit text length
      }));
    });

    // Helper: Normalize URL (remove trailing slash for comparison)
    function normalizeUrl(urlString) {
      try {
        const url = new URL(urlString);
        // Remove trailing slash from pathname (but keep single / for root)
        if (url.pathname.length > 1 && url.pathname.endsWith('/')) {
          url.pathname = url.pathname.slice(0, -1);
        }
        return url.href;
      } catch {
        return urlString;
      }
    }

    // Filter to same domain
    const url = new URL(baseUrl);
    const baseDomain = url.hostname;
    const normalizedBase = normalizeUrl(baseUrl);

    const sameDomainLinks = links.filter(link => {
      try {
        const linkUrl = new URL(link.href);
        const normalizedLink = normalizeUrl(link.href);
        return linkUrl.hostname === baseDomain && normalizedLink !== normalizedBase;
      } catch {
        return false;
      }
    });

    // Remove duplicates by normalized URL
    const uniqueLinks = [];
    const seenUrls = new Set();

    for (const link of sameDomainLinks) {
      const normalized = normalizeUrl(link.href);
      if (!seenUrls.has(normalized)) {
        seenUrls.add(normalized);
        uniqueLinks.push(link);
      }
    }

    if (uniqueLinks.length === 0) {
      // Don't print error here - let caller handle retry logic
      return [];
    }

    console.log(`\n✅ Nalezeno ${uniqueLinks.length} sub-stránek\n`);

    // If autoSelectLimit provided, skip menu and auto-select
    if (autoSelectLimit !== null) {
      let selectedSubPages = [];
      if (autoSelectLimit === 'all') {
        selectedSubPages = uniqueLinks;
      } else {
        const limit = parseInt(autoSelectLimit);
        selectedSubPages = uniqueLinks.slice(0, limit);
      }

      const selected = selectedSubPages.map((link, i) => ({
        name: `${baseDomain} - ${link.text || 'Stránka ' + (i + 1)}`,
        url: link.href
      }));

      return selected;
    }

    // Show up to 20 links for interactive selection
    const displayLinks = uniqueLinks.slice(0, 20);
    displayLinks.forEach((link, i) => {
      console.log(`  ${i + 1}. ${link.text || 'Bez názvu'}`);
      console.log(`     ${link.href}`);
    });

    if (uniqueLinks.length > 20) {
      console.log(`\n  ... a dalších ${uniqueLinks.length - 20} stránek`);
    }

    console.log('\n  A. Testovat VŠECHNY podstránky');
    console.log('  B. Zadat čísla ručně (např: 1,3,5,7)');
    console.log('  C. Zrušit a vrátit se\n');

    const choice = await question(rl, 'Vyber možnost (A/B/C): ');

    if (choice.toUpperCase() === 'A') {
      // Select ALL subpages
      const selected = uniqueLinks.map((link, i) => ({
        name: `${baseDomain} - ${link.text || 'Stránka ' + (i + 1)}`,
        url: link.href
      }));
      console.log(`\n   ✅ Přidáno ${selected.length} sub-stránek\n`);
      return selected;

    } else if (choice.toUpperCase() === 'B') {
      // Manual selection
      const indices = await question(rl, 'Zadej čísla oddělená čárkou (např: 1,3,5,7): ');
      const numbers = indices.split(',').map(n => parseInt(n.trim())).filter(n => !isNaN(n) && n >= 1 && n <= uniqueLinks.length);

      if (numbers.length === 0) {
        console.log('   ⚠️  Neplatný výběr\n');
        return [];
      }

      const selected = numbers.map(n => {
        const link = uniqueLinks[n - 1];
        return {
          name: `${baseDomain} - ${link.text || 'Stránka ' + n}`,
          url: link.href
        };
      });

      console.log(`\n   ✅ Přidáno ${selected.length} sub-stránek\n`);
      return selected;

    } else {
      console.log('   ❌ Zrušeno\n');
      return [];
    }

  } catch (error) {
    if (error.message.includes('Executable doesn\'t exist') || error.message.includes('playwright install')) {
      console.log(`   ❌ Chyba: Playwright Chromium není nainstalovaný`);
      console.log(`   💡 Spusť: npx playwright install chromium\n`);
    } else {
      console.log(`   ❌ Chyba při analýze: ${error.message}\n`);
    }
    return [];
  } finally {
    // Always close browser
    if (browser) {
      try {
        await browser.close();
      } catch (e) {
        // Ignore close errors
      }
    }
  }
}

// Load URLs from CSV file and discover sub-pages
async function loadUrlsFromCSV(rl, subpageLimit) {
  const fs = await import('fs');
  const csvPath = 'url.csv';

  // Check if file exists
  if (!fs.existsSync(csvPath)) {
    console.log('   ❌ Soubor url.csv nenalezen!\n');
    console.log('   💡 Vytvoř soubor url.csv ve složce projektu s URL (jeden na řádek)\n');
    return [];
  }

  // Read CSV file
  const content = fs.readFileSync(csvPath, 'utf-8');
  const lines = content.split('\n')
    .map(line => line.trim())
    .filter(line => line && !line.startsWith('#')); // Skip empty lines and comments

  if (lines.length === 0) {
    console.log('   ❌ Soubor url.csv je prázdný!\n');
    return [];
  }

  console.log(`\n📄 Načteno ${lines.length} URL z csv souboru\n`);

  const allUrls = [];

  // Process each URL
  for (let i = 0; i < lines.length; i++) {
    const rawUrl = lines[i];
    const fullUrl = `https://${rawUrl}`;

    console.log(`\n[${i+1}/${lines.length}] Zpracovávám: ${rawUrl}`);

    // Add main page
    allUrls.push({ name: `${rawUrl} - Hlavní stránka`, url: fullUrl });

    // Discover sub-pages with auto-select limit (skip menu)
    let subPages = await discoverSubPages(rl, fullUrl, subpageLimit);

    // If no sub-pages found and URL doesn't start with www., try with www.
    if (subPages.length === 0 && !rawUrl.startsWith('www.')) {
      console.log('   ℹ️  Zkouším přidat "www." prefix...\n');
      const wwwUrl = `https://www.${rawUrl}`;
      subPages = await discoverSubPages(rl, wwwUrl, subpageLimit);

      // If found with www., update main page URL
      if (subPages.length > 0) {
        allUrls[allUrls.length - 1].url = wwwUrl;
        allUrls[allUrls.length - 1].name = `www.${rawUrl} - Hlavní stránka`;
      }
    }

    // Add sub-pages (already limited by discoverSubPages)
    allUrls.push(...subPages);

    console.log(`   ✅ Přidáno: 1 hlavní stránka + ${subPages.length} sub-stránek\n`);
  }

  return allUrls;
}

// Interactive menu for website selection
async function selectWebsites() {
  const rl = createInterface();
  const selectedUrls = [];

  console.log('\n╔════════════════════════════════════════════════════════════╗');
  console.log('║          🌐 VÝBĚR WEBŮ PRO BENCHMARK TEST 🌐               ║');
  console.log('╚════════════════════════════════════════════════════════════╝\n');

  console.log('Dostupné možnosti:\n');
  console.log('  1. BBC (www.bbc.com) + podstránky');
  console.log('  2. Seznam.cz (www.seznam.cz) + služby');
  console.log('  3. Y Combinator / Hacker News + stránky');
  console.log('  4. Wikipedia (www.wikipedia.org) + články');
  console.log('  5. 📄 Načíst URL ze souboru url.csv');
  console.log('  6. Zadám vlastní URL');
  console.log('  7. ❌ Ukončit program\n');

  while (true) {
    const choice = await question(rl, 'Vyber možnost (1-7) nebo stiskni ENTER pro spuštění testu: ');

    if (choice.trim() === '') {
      if (selectedUrls.length === 0) {
        console.log('\n⚠️  Musíš vybrat alespoň jeden web!\n');
        continue;
      }
      break;
    }

    if (choice === '7') {
      // Ukončit program
      console.log('\n👋 Ukončuji program...\n');
      rl.close();
      return null; // Signal to exit
    } else if (choice === '1') {
      // BBC submenu
      await showBBCSubmenu(rl, selectedUrls);
    } else if (choice === '2') {
      // Seznam.cz submenu
      await showSeznamSubmenu(rl, selectedUrls);
    } else if (choice === '3') {
      // Y Combinator / Hacker News submenu
      await showYCSubmenu(rl, selectedUrls);
    } else if (choice === '4') {
      // Wikipedia submenu
      await showWikipediaSubmenu(rl, selectedUrls);
    } else if (choice === '5') {
      // Load from CSV
      console.log('\n📄 Načítání URL ze souboru url.csv...\n');
      console.log('Kolik stránek celkem testovat pro každou URL? (včetně hlavní)');
      console.log('  1 - Jen hlavní stránka');
      console.log('  5 - Celkem 5 stránek (hlavní + 4 sub-stránky)');
      console.log('  10 - Celkem 10 stránek (hlavní + 9 sub-stránek)');
      console.log('  20 - Celkem 20 stránek (hlavní + 19 sub-stránek)');
      console.log('  50 - Celkem 50 stránek (hlavní + 49 sub-stránek)');
      console.log('  all - Všechny nalezené stránky\n');

      const subpageChoice = await question(rl, 'Vyber počet (1/5/10/20/50/all): ');

      if (['1', '5', '10', '20', '50', 'all'].includes(subpageChoice.trim())) {
        // Subtract 1 to account for main page (except for '1' and 'all')
        let limit;
        if (subpageChoice.trim() === '1') {
          limit = '0'; // Just main page
        } else if (subpageChoice.trim() === 'all') {
          limit = 'all';
        } else {
          limit = String(parseInt(subpageChoice.trim()) - 1); // e.g. 50 -> 49 sub-pages
        }
        const csvUrls = await loadUrlsFromCSV(rl, limit);

        if (csvUrls.length > 0) {
          selectedUrls.push(...csvUrls);
          console.log(`\n✅ Celkem přidáno ${csvUrls.length} URL ze souboru\n`);
        }
      } else {
        console.log('   ❌ Neplatná volba!\n');
      }
    } else if (choice === '6') {
      console.log('\n📝 Zadej URL ve tvaru: web.domena nebo web.domena.domena2');
      console.log('   (např: thechive.com, salon.com, nydailynews.com, crooksandliars.com)');
      console.log('   Skript automaticky najde sub-stránky na této doméně\n');

      const customUrl = await question(rl, 'URL: ');
      const trimmedUrl = customUrl.trim();

      if (trimmedUrl) {
        // Add https:// prefix
        const fullUrl = `https://${trimmedUrl}`;

        // First, add the main page
        if (!selectedUrls.find(u => u.url === fullUrl)) {
          selectedUrls.push({ name: `${trimmedUrl} - Hlavní stránka`, url: fullUrl });
          console.log(`   ✅ Přidána hlavní stránka: ${fullUrl}\n`);
        }

        // Then discover sub-pages
        let subPages = await discoverSubPages(rl, fullUrl);

        // If no sub-pages found and URL doesn't start with www., try with www.
        if (subPages.length === 0 && !trimmedUrl.startsWith('www.')) {
          console.log('   ℹ️  Zkouším přidat "www." prefix...\n');
          const wwwUrl = `https://www.${trimmedUrl}`;
          subPages = await discoverSubPages(rl, wwwUrl);

          // If found with www., update main page URL too
          if (subPages.length > 0) {
            const mainPageIndex = selectedUrls.findIndex(u => u.url === fullUrl);
            if (mainPageIndex !== -1) {
              selectedUrls[mainPageIndex].url = wwwUrl;
              selectedUrls[mainPageIndex].name = `www.${trimmedUrl} - Hlavní stránka`;
            }
          }
        }

        // If still no sub-pages found, show error
        if (subPages.length === 0) {
          console.log('   ⚠️  Nenalezeny žádné sub-stránky na stejné doméně.\n');
        }

        // Add discovered sub-pages
        for (const subPage of subPages) {
          if (!selectedUrls.find(u => u.url === subPage.url)) {
            selectedUrls.push(subPage);
          }
        }
      } else {
        console.log('   ❌ Prázdná URL, zkus znovu.\n');
      }
    } else if (PRESET_WEBSITES[choice]) {
      const website = PRESET_WEBSITES[choice];

      // Skip if has submenu
      if (website.hasSubmenu) {
        console.log('   ⚠️  Použij submenu!\n');
        continue;
      }

      // Check if already added
      if (selectedUrls.find(u => u.url === website.url)) {
        console.log(`   ⚠️  ${website.name} už je v seznamu!\n`);
      } else {
        selectedUrls.push(website);
        console.log(`   ✅ Přidáno: ${website.name}\n`);
      }
    } else {
      console.log('   ❌ Neplatná volba, zkus znovu.\n');
    }
  }

  rl.close();

  console.log('\n📋 Vybrané weby pro test:');
  selectedUrls.forEach((site, i) => {
    console.log(`   ${i + 1}. ${site.name} - ${site.url}`);
  });
  console.log('');

  return selectedUrls;
}

// Helper: Run single test with comprehensive metrics
// ============================================================================
// HLAVNÍ TESTOVACÍ FUNKCE - Kompletní benchmark jedné stránky
// ============================================================================
// CO: Načte stránku v prohlížeči a změří všechny metriky (timing, network, trackery, DOM)
// PROČ: Jádro celého benchmarku - tato funkce dělá skutečnou práci
// JAK: 1) Launch browser, 2) Hook tracking APIs, 3) Navigace, 4) Wait 5s, 5) Analýza
async function runTest(browserType, browserName, testUrl, testName, executablePath = null) {
  const startTime = Date.now();
  let browser = null;

  try {
    // ========================================================================
    // SPUŠTĚNÍ PROHLÍŽEČE
    // ========================================================================
    // CO: Otevře novou instanci browseru (Chrome nebo Edge)
    // PROČ: Čistý stav pro každý test, žádný cache, cookies, historie
    // JAK: Playwright launch s headless/headed módem
    const launchStart = Date.now();
    const launchOptions = {
      headless: config.headless,           // Bez okna (rychlejší) nebo s oknem (debug)
      slowMo: config.headless ? 0 : 100,   // Zpomalení v headed mode pro viditelnost
    };

    // Použití vlastní instalace Chrome/Edge místo Playwright Chromium
    // CO: Nastavení cesty k chrome.exe nebo msedge.exe
    // PROČ: Chceme testovat skutečné prohlížeče, ne Chromium
    if (executablePath) {
      launchOptions.executablePath = executablePath;
    }

    browser = await browserType.launch(launchOptions);
    const launchTime = Date.now() - launchStart;

    // ========================================================================
    // VYTVOŘENÍ STRÁNKY S REALISTICKÝM USER AGENT
    // ========================================================================
    // CO: Nová záložka s nastaveným User-Agent
    // PROČ: Anti-bot ochrana - weby blokují headless browser bez UA
    // JAK: Předstíráme Chrome 131 na Windows 10
    const page = await browser.newPage({
      userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36'
    });

    // ========================================================================
    // NETWORK TRACKING - Sledování všech HTTP requestů
    // ========================================================================
    // CO: Zachytávání všech network requestů a responses
    // PROČ: Potřebujeme vědět: kolik requestů, z jakých domén, jak velké
    // JAK: Event listeners na page.on('request') a page.on('response')
    const requests = [];    // Seznam všech HTTP requestů
    const responses = [];   // Seznam všech HTTP responses
    const domains = new Set(); // Unikátní domény (pro count third-party)

    page.on('request', request => {
      const url = request.url();
      try {
        const urlObj = new URL(url);
        domains.add(urlObj.hostname);
      } catch {}

      requests.push({
        url,
        method: request.method(),
        resourceType: request.resourceType(),
      });
    });

    page.on('response', async response => {
      const request = response.request();
      const url = response.url();

      try {
        const headers = response.headers();
        const status = response.status();

        // Get actual body size (more accurate than content-length header)
        let bodySize = 0;
        try {
          const body = await response.body();
          bodySize = body.length;
        } catch {
          // If body fails, fallback to content-length header
          bodySize = parseInt(headers['content-length'] || '0');
        }

        responses.push({
          url,
          status,
          resourceType: request.resourceType(),
          contentType: headers['content-type'] || '',
          contentLength: bodySize,
          encodedLength: 0, // Will be filled from timing
        });
      } catch (err) {
        // Some responses might fail to get headers
      }
    });

    // ========================================================================
    // ADVANCED FINGERPRINTING DETECTION - Hook browser APIs PŘED načtením stránky
    // ========================================================================
    // CO: Podvrhne browser APIs pro detekci canvas/WebRTC/font fingerprintingu
    // PROČ: Moderní trackery používají fingerprinting místo cookies
    // JAK: evaluateOnNewDocument() = spustí se před jakýmkoli JS na stránce
    // FALLBACK: Pokud evaluateOnNewDocument() není podporováno → skip fingerprinting
    try {
      await page.evaluateOnNewDocument(() => {
      // Globální úložiště pro zachycené fingerprinting pokusy
      window.__trackingDetection = {
        canvasFingerprinting: [],  // Canvas API volání (toDataURL, toBlob, getImageData)
        webrtcConnections: [],     // WebRTC peer connections (úniky IP)
        fontDetection: [],         // Font enumeration (document.fonts.check)
      };

      // ======================================================================
      // CANVAS FINGERPRINTING - Detekce trackingu přes Canvas API
      // ======================================================================
      // CO: Monitoruje volání Canvas metod pro vytváření otisků
      // PROČ: Canvas rendering je unikátní pro každý PC → identifikace uživatele
      // JAK: Hook 3 metody: toDataURL(), toBlob(), getImageData()
      const CanvasProto = HTMLCanvasElement.prototype;
      const originalToDataURL = CanvasProto.toDataURL;
      const originalToBlob = CanvasProto.toBlob;
      const originalGetImageData = CanvasRenderingContext2D.prototype.getImageData;

      // Hook: canvas.toDataURL() - Nejčastější metoda pro fingerprinting
      // CO: Zachytí každé volání toDataURL() a uloží stack trace
      // PROČ: Stack trace odhalí který script to volá (tracker doména)
      CanvasProto.toDataURL = function(...args) {
        const stack = new Error().stack;
        window.__trackingDetection.canvasFingerprinting.push({
          method: 'toDataURL',
          size: `${this.width}x${this.height}`,
          stack: stack  // Stack trace → extrakce tracker domény
        });
        return originalToDataURL.apply(this, args); // Normální běh
      };

      // Hook: canvas.toBlob() - Alternativa k toDataURL
      CanvasProto.toBlob = function(...args) {
        const stack = new Error().stack;
        window.__trackingDetection.canvasFingerprinting.push({
          method: 'toBlob',
          size: `${this.width}x${this.height}`,
          stack: stack
        });
        return originalToBlob.apply(this, args);
      };

      // Hook: context.getImageData() - Přímé čtení pixel data
      CanvasRenderingContext2D.prototype.getImageData = function(...args) {
        const stack = new Error().stack;
        window.__trackingDetection.canvasFingerprinting.push({
          method: 'getImageData',
          args: args,
          stack: stack
        });
        return originalGetImageData.apply(this, args);
      };

      // ======================================================================
      // WEBRTC LEAK DETECTION - Detekce úniků IP přes WebRTC
      // ======================================================================
      // CO: Monitoruje vytváření WebRTC peer connections
      // PROČ: WebRTC odhaluje skutečnou IP i přes VPN (STUN server leak)
      // JAK: Hook konstruktor RTCPeerConnection
      if (window.RTCPeerConnection) {
        const OriginalRTC = window.RTCPeerConnection;
        window.RTCPeerConnection = function(...args) {
          const stack = new Error().stack;
          window.__trackingDetection.webrtcConnections.push({
            config: args[0],  // STUN/TURN server konfigurace
            stack: stack      // Kdo to volá
          });
          return new OriginalRTC(...args); // Normální běh
        };
        window.RTCPeerConnection.prototype = OriginalRTC.prototype;
      }

      // ======================================================================
      // FONT DETECTION - Detekce enumerace nainstalovaných fontů
      // ======================================================================
      // CO: Monitoruje testování fontů přes document.fonts.check()
      // PROČ: Seznam fontů je unikátní pro každý PC → fingerprint
      // JAK: Hook document.fonts.check() metoda
      const originalCheck = document.fonts ? document.fonts.check : null;
      if (originalCheck) {
        document.fonts.check = function(...args) {
          const stack = new Error().stack;
          window.__trackingDetection.fontDetection.push({
            font: args[0],    // Který font se testuje
            stack: stack      // Kdo to volá
          });
          return originalCheck.apply(this, args);
        };
      }
      });
    } catch (e) {
      // evaluateOnNewDocument() není podporováno v této verzi Playwright/browseru
      // CO: Fingerprinting detection se přeskočí
      // PROČ: Starší Playwright nebo custom browser build nemá tuto funkci
      // JAK: Pokračovat bez fingerprinting hooks (základní tracking detection funguje)
      // Tichý fallback - uživateli se nic nezobrazuje
    }

    // ========================================================================
    // NAVIGACE A NAČÍTÁNÍ STRÁNKY
    // ========================================================================
    // CO: Otevření URL a měření času načtení
    // PROČ: Hlavní metrika - jak dlouho trvá načtení stránky
    // JAK: page.goto() s timeout + fallback strategií
    const loadStart = Date.now();
    try {
      // Primární pokus: waitUntil 'load' = čekání na load event
      // CO: Navigace s čekáním na kompletní načtení (všechny zdroje)
      // PROČ: 'load' = window.onload event = HTML + CSS + JS + obrázky hotovo
      // JAK: timeout 60s (některé weby jsou pomalé)
      await page.goto(testUrl, { waitUntil: 'load', timeout: 60000 });

      // Bonusové čekání na networkidle
      // CO: Pokus počkat až síť ztichne (žádné requesty 500ms)
      // PROČ: Lazy-loaded content se může načítat po 'load' eventu
      // JAK: timeout 5s + .catch() = ignorovat timeout (některé weby nikdy neztichnou)
      await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {
        // Ignore timeout - some sites never reach networkidle (např. continuous polling)
      });
    } catch (e) {
      // Fallback strategie pokud 'load' selže
      // CO: Pokud primary load selže → zkusit 'domcontentloaded'
      // PROČ: 'domcontentloaded' = rychlejší (jen HTML+JS, bez čekání na obrázky)
      // JAK: Check error type → retry s jinou strategií
      if (e.message.includes('closed') || e.message.includes('timeout')) {
        console.log(`      ⚠️  Load selhal, zkouším domcontentloaded...`);
        await page.goto(testUrl, { waitUntil: 'domcontentloaded', timeout: 60000 });
      } else {
        throw e; // Jiná chyba → propaguj výš
      }
    }
    const loadTime = Date.now() - loadStart;

    // ========================================================================
    // SIMULACE UŽIVATELSKÉ INTERAKCE + LAZY-LOAD DETECTION
    // ========================================================================
    // CO: Scrollování + čekání 5s pro zachycení lazy-loaded trackerů
    // PROČ: Trackery se často aktivují až po scroll/interakci, ne při načtení
    // JAK: MutationObserver + scroll simulace + 5s wait
    try {
      // ======================================================================
      // MUTATIONOBSERVER - Zachycení dynamicky přidaných scriptů
      // ======================================================================
      // CO: Nastavení DOM watcheru pro nové <script> tagy
      // PROČ: Trackery se často vkládají až po načtení (lazy load, on-scroll)
      // JAK: MutationObserver sleduje změny v DOM → uloží do window.__dynamicScripts
      await page.evaluate(() => {
        window.__dynamicScripts = []; // Globální seznam pro zachycené scripty

        // Vytvoření MutationObserver = watcher DOM změn
        // CO: Callback spouštěný při každé změně v DOM
        // PROČ: Chceme vědět kdy se přidá nový <script> tag
        // JAK: mutations → addedNodes → filtr SCRIPT s src
        const observer = new MutationObserver((mutations) => {
          mutations.forEach((mutation) => {
            mutation.addedNodes.forEach((node) => {
              // Pouze <script src="..."> tagy (ne inline)
              if (node.tagName === 'SCRIPT' && node.src) {
                window.__dynamicScripts.push(node.src);
              }
            });
          });
        });

        // Spuštění observeru na celém dokumentu
        // CO: observe(element, config) = start watching
        // PROČ: Chceme sledovat celý document včetně nested elementů
        // JAK: childList=true (sleduj přidané/odstraněné), subtree=true (i vnořené)
        observer.observe(document.documentElement, {
          childList: true,  // Sleduj přidání/odstranění child nodes
          subtree: true     // Sleduj i vnořené elementy (celý strom)
        });
      });

      // ======================================================================
      // SCROLL SIMULACE - Trigger lazy-load obsahu
      // ======================================================================
      // CO: Simulace uživatelského scrollování shora dolů
      // PROČ: Lazy-load trackery se aktivují až když user scrolluje
      // JAK: scrollTo() na střed → bottom → top + 500ms pauzy

      // Scroll na střed stránky
      // CO: window.scrollTo(0, scrollHeight/2) = polovina stránky
      // PROČ: Některé trackery se spouští při scroll past fold
      await page.evaluate(() => {
        window.scrollTo(0, document.body.scrollHeight / 2);
      });
      await page.waitForTimeout(500); // Pauza pro lazy-load

      // Scroll na konec stránky
      // CO: window.scrollTo(0, scrollHeight) = úplně dolů
      // PROČ: Trackery na bottom of page (newsletter, footer ads)
      await page.evaluate(() => {
        window.scrollTo(0, document.body.scrollHeight);
      });
      await page.waitForTimeout(500); // Pauza

      // Scroll zpět nahoru
      // CO: window.scrollTo(0, 0) = návrat na začátek
      // PROČ: Některé trackery se spouští při scroll back up
      await page.evaluate(() => {
        window.scrollTo(0, 0);
      });

      // ======================================================================
      // ČEKÁNÍ 5 SEKUND - Finální lazy-load period
      // ======================================================================
      // CO: Čekání 5 sekund na pozdě načítané trackery
      // PROČ: Některé trackery mají delayed load (3s, 5s timeouty)
      // JAK: waitForTimeout(5000) = blocking wait
      await page.waitForTimeout(5000);
    } catch (e) {
      // Ignore scroll errors (může selhat na některých typech stránek)
    }

    // ========================================================================
    // PERFORMANCE NAVIGATION TIMING - Standardní browser metriky
    // ========================================================================
    // CO: Získání timing metrik z Performance API
    // PROČ: Přesné měření TTFB, DOMContentLoaded, Load Complete
    // JAK: performance.getEntriesByType('navigation') = browser built-in metrics
    const perfTiming = await page.evaluate(() => {
      const perf = performance.getEntriesByType('navigation')[0];
      if (!perf) return null; // Starší browsery nemají Navigation Timing Level 2

      // CO: Výpočet klíčových timing metrik
      // PROČ: Standard W3C metriky pro analýzu rychlosti
      // JAK: Rozdíly mezi timing events (vše v ms)
      return {
        ttfb: perf.responseStart - perf.requestStart,              // Time To First Byte
        domContentLoaded: perf.domContentLoadedEventEnd - perf.fetchStart,  // DOMContentLoaded
        loadComplete: perf.loadEventEnd - perf.fetchStart,         // Load event complete
        domInteractive: perf.domInteractive - perf.fetchStart,     // DOM interactive
      };
    });

    // ========================================================================
    // CORE WEB VITALS - Google ranking faktory
    // ========================================================================
    // CO: Získání LCP, CLS, FID metrik
    // PROČ: Google používá tyto metriky pro SEO ranking
    // JAK: Performance API entries pro paint, layout-shift, first-input
    const webVitals = await page.evaluate(() => {
      const vitals = {
        lcp: 0,   // Largest Contentful Paint (ms)
        cls: 0,   // Cumulative Layout Shift (score 0-1)
        fid: 0,   // First Input Delay (ms) - obtížné měřit bez user input
      };

      // ======================================================================
      // LCP (Largest Contentful Paint) - Hlavní obsah vykreslený
      // ======================================================================
      // CO: Čas kdy se vykreslil největší element na stránce
      // PROČ: Měří vnímanou rychlost načítání (kdy user vidí "něco")
      // JAK: performance.getEntriesByType('largest-contentful-paint')
      try {
        const lcpEntries = performance.getEntriesByType('largest-contentful-paint');
        if (lcpEntries.length > 0) {
          const lastEntry = lcpEntries[lcpEntries.length - 1]; // Poslední = finální LCP
          vitals.lcp = lastEntry.renderTime || lastEntry.loadTime; // Prefer renderTime
        }
      } catch (e) {
        // LCP not available (některé browsery nemají)
      }

      // ======================================================================
      // CLS (Cumulative Layout Shift) - Vizuální stabilita
      // ======================================================================
      // CO: Suma všech neočekávaných posunů layoutu
      // PROČ: Špatná UX když se elementy posouvají (user klikne na špatné místo)
      // JAK: Suma layout-shift entries (kromě těch způsobených user inputem)
      try {
        const clsEntries = performance.getEntriesByType('layout-shift');
        for (const entry of clsEntries) {
          // Pouze unexpected shifts (ne ty způsobené user interakcí)
          if (!entry.hadRecentInput) {
            vitals.cls += entry.value;
          }
        }
      } catch (e) {
        // CLS not available
      }

      // ======================================================================
      // FID (First Input Delay) - Responsiveness
      // ======================================================================
      // CO: Čas mezi user inputem a zpracováním browseru
      // PROČ: Měří jak rychle web reaguje na interakci (klik, tap)
      // JAK: performance.getEntriesByType('first-input')
      // POZNÁMKA: V automatických testech obtížné měřit (žádný real user input)
      try {
        const fidEntries = performance.getEntriesByType('first-input');
        if (fidEntries.length > 0) {
          // FID = doba čekání na zpracování inputu
          vitals.fid = fidEntries[0].processingStart - fidEntries[0].startTime;
        }
      } catch (e) {
        // FID not available (většinou v automatických testech)
      }

      return vitals;
    });

    // ========================================================================
    // LCP FALLBACK PRO HEADLESS MODE
    // ========================================================================
    // CO: V headless módu LCP API nefunguje → použít loadComplete
    // PROČ: Headless Chrome neměří paint events správně
    // JAK: Pokud lcp===0 → použij loadComplete jako aproximaci
    if (webVitals.lcp === 0 && perfTiming && perfTiming.loadComplete > 0) {
      // loadComplete = všechen obsah včetně obrázků načten
      webVitals.lcp = perfTiming.loadComplete;
    }

    // ========================================================================
    // JAVASCRIPT EXECUTION TEST - Rychlost JS enginu
    // ========================================================================
    // CO: Měření rychlosti JavaScript výpočtu v browseru
    // PROČ: Benchmark rychlosti JS enginu (V8 vs SpiderMonkey)
    // JAK: 1 milion Math.sqrt() operací → měření času
    const jsStart = Date.now();
    await page.evaluate(() => {
      let sum = 0;
      for (let i = 0; i < 1000000; i++) {
        sum += Math.sqrt(i); // CPU-intensive operace
      }
      return sum;
    });
    const jsTime = Date.now() - jsStart;

    // ========================================================================
    // DOM METRICS - Statistiky DOM struktury
    // ========================================================================
    // CO: Počítání různých typů elementů v DOM
    // PROČ: Velký DOM = pomalé rendering, vysoká paměť
    // JAK: querySelectorAll() na různé selektory
    const domMetrics = await page.evaluate(() => {
      return {
        elements: document.querySelectorAll('*').length,              // Všechny elementy
        links: document.querySelectorAll('a').length,                 // <a> tagy
        images: document.querySelectorAll('img').length,              // <img> tagy
        scripts: document.querySelectorAll('script').length,          // <script> tagy
        stylesheets: document.querySelectorAll('link[rel="stylesheet"]').length, // CSS soubory
      };
    });

    // ========================================================================
    // COOKIE ANALÝZA - Rozdělení na first-party vs third-party
    // ========================================================================
    // CO: Získání všech cookies a filtrování third-party
    // PROČ: Third-party cookies = tracking riziko, GDPR problém
    // JAK: context.cookies() → filtr podle domény (jiná než page URL)
    const cookies = await page.context().cookies();
    const thirdPartyCookies = cookies.filter(cookie => {
      try {
        const pageUrl = new URL(testUrl);
        // Third-party = cookie domain neobsahuje page hostname
        // Příklad: na bbc.com cookie od google.com = third-party
        return !cookie.domain.includes(pageUrl.hostname);
      } catch {
        return false; // Invalid URL → skip
      }
    });

    // ========================================================================
    // NETWORK BREAKDOWN - Kategorizace requestů podle typu
    // ========================================================================
    // CO: Rozdělení network requestů do kategorií (JS, CSS, images, atd.)
    // PROČ: Analýza co zabírá nejvíc dat (např. 5MB obrázků vs 100KB JS)
    // JAK: Pro každý response → determine category → increment count + size
    const breakdown = {
      document: { count: 0, size: 0 },     // HTML dokumenty
      css: { count: 0, size: 0 },          // Stylesheets
      javascript: { count: 0, size: 0 },   // JS soubory
      image: { count: 0, size: 0 },        // Obrázky (PNG, JPG, SVG, atd.)
      font: { count: 0, size: 0 },         // Webfonty (WOFF, TTF, atd.)
      media: { count: 0, size: 0 },        // Video/audio
      xhr: { count: 0, size: 0 },          // XHR/Fetch API calls
      other: { count: 0, size: 0 },        // Ostatní
    };

    let totalSize = 0; // Celková velikost všech requestů

    // Iterace přes všechny responses a kategorizace
    // CO: Pro každý response → zjisti kategorii → přičti count a size
    // PROČ: Potřebujeme vědět kolik KB je JS, CSS, images, atd.
    // JAK: getResourceCategory() → increment counters
    for (const resp of responses) {
      const category = getResourceCategory(resp.resourceType, resp.contentType);
      const size = resp.contentLength; // Velikost v bytech

      breakdown[category].count++;     // +1 request dané kategorie
      breakdown[category].size += size; // +size bytes
      totalSize += size;
    }

    // ========================================================================
    // THIRD-PARTY DOMAINS - Sběr všech externích domén
    // ========================================================================
    // CO: Identifikace všech domén ze kterých se načítá obsah (kromě hlavní)
    // PROČ: Third-party = potenciální trackery, security risk, GDPR problem
    // JAK: Pro každý request → check hostname → pokud != main domain → přidat do Set
    const mainHostname = new URL(testUrl).hostname; // Hlavní doména (např. bbc.com)
    const thirdPartyDomains = new Set(); // Set = automatická deduplikace

    for (const req of requests) {
      try {
        const reqUrl = new URL(req.url);
        const hostname = reqUrl.hostname;

        // Third-party check
        // CO: Je tato doména third-party (cizí)?
        // PROČ: Chceme vědět kolik externích domén stránka používá
        // JAK: hostname !== mainHostname && !subdoména hlavní domény
        if (!hostname.endsWith(mainHostname) && hostname !== mainHostname) {
          thirdPartyDomains.add(hostname); // Přidat do seznamu
        }
      } catch (e) {
        // Invalid URL → skip (některé requesty mají weird URLs)
      }
    }

    // ========================================================================
    // MULTI-SOURCE TRACKER DETECTION - Prohledání všech míst kde mohou být trackery
    // ========================================================================
    // CO: Hledá trackery v: DOM, inline scripts, cookies, localStorage, fingerprinting
    // PROČ: Trackery nejsou jen v network requestech - mohou být kdekoli
    // JAK: page.evaluate() = spuštění kódu v kontextu stránky → přístup k DOM/cookies/storage

    const trackerDomains = Object.keys(KNOWN_TRACKERS); // Seznam všech známých tracker domén

    const domData = await page.evaluate((domains) => {
      // Samostatné seznamy pro každý typ detekce (pro statistiky)
      const domElementUrls = [];      // <script src>, <iframe src>, <img src>, <link href>
      const inlineUrls = [];          // Inline <script> obsahy
      const dynamicScripts = [];      // Dynamicky přidané <script> (MutationObserver)
      const cookieUrls = [];          // Cookie jména obsahující tracker domény
      const localStorageUrls = [];    // localStorage keys/values s tracker doménami
      const fingerprintingUrls = [];  // Stack traces z canvas/WebRTC/font detekce

      // ======================================================================
      // DYNAMICKÉ SCRIPTY - MutationObserver zachycené změny
      // ======================================================================
      // CO: Získání seznamu dynamicky přidaných <script> tagů
      // PROČ: Trackery se často přidávají po načtení stránky (lazy load)
      // JAK: window.__dynamicScripts naplněn MutationObserver (nastaven dřív)
      if (window.__dynamicScripts) {
        dynamicScripts.push(...window.__dynamicScripts);
      }

      // ======================================================================
      // FINGERPRINTING ANALÝZA - Extrakce domén ze stack traces
      // ======================================================================
      // CO: Z hooked API calls vytáhnout domény tracker scriptů
      // PROČ: Stack trace obsahuje URL scriptu který volal API
      // JAK: Regex match "https://domain.com" v Error().stack
      if (window.__trackingDetection) {

        // Canvas fingerprinting - které scripty volaly canvas API?
        // CO: Z každého canvas API volání extrahovat doménu ze stack trace
        // PROČ: "Error().stack" obsahuje celý call stack s URLs
        // JAK: Regex /https?:\/\/([^\/\s]+)/ → první URL ve stack trace
        if (window.__trackingDetection.canvasFingerprinting.length > 0) {
          for (const detection of window.__trackingDetection.canvasFingerprinting) {
            const urlMatch = detection.stack.match(/https?:\/\/([^\/\s]+)/);
            if (urlMatch) {
              fingerprintingUrls.push(urlMatch[0]); // Celá URL s doménou
            }
          }
        }

        // WebRTC connections - které scripty vytváření peer connections?
        // CO: Extrakce domén ze stack traces WebRTC volání
        // PROČ: WebRTC leak = tracker chce zjistit skutečnou IP
        if (window.__trackingDetection.webrtcConnections.length > 0) {
          for (const detection of window.__trackingDetection.webrtcConnections) {
            const urlMatch = detection.stack.match(/https?:\/\/([^\/\s]+)/);
            if (urlMatch) {
              fingerprintingUrls.push(urlMatch[0]);
            }
          }
        }

        // Font detection - které scripty testují fonty?
        // CO: Extrakce domén ze stack traces font enumeration
        // PROČ: Font list je unikátní → fingerprint → tracking
        if (window.__trackingDetection.fontDetection.length > 0) {
          for (const detection of window.__trackingDetection.fontDetection) {
            const urlMatch = detection.stack.match(/https?:\/\/([^\/\s]+)/);
            if (urlMatch) {
              fingerprintingUrls.push(urlMatch[0]);
            }
          }
        }
      }

      // ======================================================================
      // COOKIE ANALÝZA - Hledání tracker domén v cookie jménech
      // ======================================================================
      // CO: Kontrola zda cookie jména obsahují části tracker domén
      // PROČ: Cookies často pojmenovány podle trackeru: "_ga" = Google Analytics
      // JAK: Pro každou doménu → check všechny cookie names → substring match
      const cookies = document.cookie.split(';');
      for (const cookie of cookies) {
        const [name] = cookie.split('='); // Jen jméno, ne hodnota
        // Porovnání s každou tracker doménou
        // CO: Split doména na části (google.com → ["google", "com"])
        // PROČ: Cookie "_ga" matchuje "google" z "google-analytics.com"
        // JAK: .some() check zda nějaká část domény je v cookie názvu
        for (const domain of domains) {
          const domainParts = domain.split('.');
          if (domainParts.some(part => name.toLowerCase().includes(part))) {
            cookieUrls.push(`https://${domain}`); // Match → přidat tracker URL
            break; // Našli jsme, další doména
          }
        }
      }

      // ======================================================================
      // LOCALSTORAGE ANALÝZA - Hledání tracker dat v localStorage
      // ======================================================================
      // CO: Scan localStorage keys a values pro tracker domény
      // PROČ: Trackery ukládají ID do localStorage (alternativa ke cookies)
      // JAK: Iterace localStorage → substring match v keys/values
      try {
        for (let i = 0; i < localStorage.length; i++) {
          const key = localStorage.key(i);
          const value = localStorage.getItem(key);
          // Kontrola každé tracker domény
          // CO: Check zda key nebo value obsahuje doménu
          // PROČ: localStorage["_ga_xyz"] = tracker data z google-analytics.com
          // JAK: .includes() na key i value strings
          for (const domain of domains) {
            if (key.includes(domain) || (value && value.includes(domain))) {
              localStorageUrls.push(`https://${domain}`); // Match → přidat
              break;
            }
          }
        }
      } catch (e) {
        // localStorage může být blokovaný (privacy mode, GDPR, atd.)
      }

      // ======================================================================
      // DOM ELEMENT EXTRACTION - <script>, <iframe>, <img>, <link>
      // ======================================================================
      // CO: Extrakce URL ze všech elementů které mohou načítat tracker kód
      // PROČ: Trackery jsou obvykle external scripts nebo tracking pixely
      // JAK: querySelectorAll() na každý typ elementu

      // <script src="..."> - JavaScript soubory
      document.querySelectorAll('script[src]').forEach(el => {
        domElementUrls.push(el.src);
      });

      // <iframe src="..."> - Embedded content (často třetí strany)
      document.querySelectorAll('iframe[src]').forEach(el => {
        domElementUrls.push(el.src);
      });

      // <img src="..."> - Obrázky (včetně 1×1px tracking pixelů)
      document.querySelectorAll('img[src]').forEach(el => {
        domElementUrls.push(el.src);
      });

      // <link href="..."> - Stylesheets a preconnect (někdy k trackerům)
      document.querySelectorAll('link[href]').forEach(el => {
        domElementUrls.push(el.href);
      });

      // ======================================================================
      // INLINE SCRIPTS ANALÝZA - Hledání tracker URL v <script> obsahu
      // ======================================================================
      // CO: Prohledání obsahu inline <script> tagů pro tracker domény
      // PROČ: Trackery často vloženy přímo do HTML: <script>var url="https://tracker.com";</script>
      // JAK: Extrakce textContent všech inline scriptů → regex search pro každou doménu

      const inlineScripts = Array.from(document.querySelectorAll('script:not([src])')).map(s => s.textContent);
      const allInlineCode = inlineScripts.join('\n'); // Spojení do jednoho stringu

      // Hledání tracker domén v inline kódu
      // CO: Pro každou známou tracker doménu → regex match v inline JS
      // PROČ: JS často obsahuje hardcoded URLs: "https://google-analytics.com/collect"
      // JAK: Dynamický regex pattern pro každou doménu
      for (const domain of domains) {
        // Escape tečky pro regex (google.com → google\.com)
        const escapedDomain = domain.replace(/\./g, '\\.');

        // Pattern: https://[subdomain.]doména.com/cesta
        // CO: Regex který matchuje doménu i s libovolnými subdoménami
        // PROČ: "www.google-analytics.com" i "ssl.google-analytics.com" jsou stejný tracker
        // JAK: [a-z0-9.-]* = libovolné subdomény před hlavní doménou
        const pattern = new RegExp(`https?://[a-z0-9.-]*${escapedDomain}[^\\s"'<>]*`, 'gi');
        const matches = allInlineCode.match(pattern);

        if (matches) {
          inlineUrls.push(...matches); // Všechny matchnuté URLs
        }
      }

      // ======================================================================
      // NÁVRAT VŠECH NALEZENÝCH DAT
      // ======================================================================
      // CO: Vrácení všech seznamů + statistiky fingerprinting detekce
      // PROČ: Hlavní funkce potřebuje vědět co bylo nalezeno a kde
      // JAK: Objekt se separátními seznamy + agregované allUrls
      return {
        domElementUrls,         // Ze <script src>, <img>, <iframe>, <link>
        inlineUrls,             // Z inline <script> obsahů
        dynamicScripts,         // MutationObserver zachycené
        cookieUrls,             // Z cookie jmen
        localStorageUrls,       // Z localStorage keys/values
        fingerprintingUrls,     // Ze stack traces (canvas/WebRTC/font)
        allUrls: [...domElementUrls, ...inlineUrls, ...dynamicScripts, ...cookieUrls, ...localStorageUrls, ...fingerprintingUrls],
        // Statistiky fingerprinting technik
        canvasFingerprintCount: window.__trackingDetection?.canvasFingerprinting?.length || 0,
        webrtcCount: window.__trackingDetection?.webrtcConnections?.length || 0,
        fontDetectionCount: window.__trackingDetection?.fontDetection?.length || 0,
      };
    }, trackerDomains); // Předání seznamu domén do page.evaluate()

    const domUrls = domData.allUrls;

    // ========================================================================
    // AGREGACE TRACKERŮ - Spojení všech zdrojů do jediného seznamu
    // ========================================================================
    // CO: Detekce trackerů ze všech zdrojů (network + DOM + cookies + storage)
    // PROČ: Tracker může být v requestu, DOM elementu, cookie, localStorage - všude
    // JAK: Map = deduplikace podle jména (stejný tracker jen 1x)
    const trackersMap = new Map();

    // Check network requests - Kontrola všech HTTP requestů
    // CO: Projít všechny síťové requesty a detekovat trackery
    // PROČ: Většina trackerů dělá HTTP requesty (analytics, pixels, atd.)
    // JAK: detectTracker(url) → kontrola proti KNOWN_TRACKERS databázi
    for (const req of requests) {
      const tracker = detectTracker(req.url);
      if (tracker && !trackersMap.has(tracker.name)) {
        trackersMap.set(tracker.name, tracker); // Deduplikace - jen unikátní jména
      }
    }

    // Check DOM URLs - Kontrola všech URL z DOM, cookies, storage, fingerprinting
    // CO: Projít všechny URL nalezené v DOM analýze
    // PROČ: Trackery mohou být jen v DOM (lazy load, inline, cookies)
    // JAK: detectTracker() na každou URL z domData.allUrls
    for (const url of domUrls) {
      const tracker = detectTracker(url);
      if (tracker && !trackersMap.has(tracker.name)) {
        trackersMap.set(tracker.name, tracker);
      }
    }

    // ========================================================================
    // HEURISTICKÁ DETEKCE - Identifikace neznámých trackerů pomocí pattern matching
    // ========================================================================
    // CO: Hledá third-party domény které VYPADAJÍ jako trackery (ale nejsou v databázi)
    // PROČ: Disconnect.me má ~4700 trackerů, ale existují tisíce dalších
    // JAK: Keyword matching + známé ad-tech domény → pravděpodobnost trackeru

    // Seznam klíčových slov která často obsahují tracker domény
    // CO: Výrazy typické pro ad-tech, analytics a tracking domény
    // PROČ: "googletagmanager.com" → obsahuje "tag" → pravděpodobný tracker
    // JAK: Substring match v lowercase názvu domény
    const trackerKeywords = [
      // Reklamy
      'ad', 'ads', 'adserver', 'adservice', 'advertising',
      // Tracking
      'track', 'tracker', 'tracking',
      // Analytics
      'analytics', 'analytic', 'metric', 'stats', 'statistic',
      // Pixely a beacony
      'pixel', 'beacon',
      // Cookie syncing
      'sync', 'match', 'cookie',
      // Programmatic advertising (RTB = Real-Time Bidding)
      'bid', 'bidder', 'prebid', 'rtb',
      // Tag managers
      'tag', 'tags', 'gtm',
      // Známé Google služby
      'doubleclick', 'adsense', 'adwords',
      // Ad metrics
      'impression', 'click',
      // Targeting
      'targeting', 'segment',
      // Affiliate marketing
      'partner', 'affiliate',
      // Consent management (GDPR tracking)
      'consent', 'consentmanager', 'cookiebot', 'onetrust', 'trustarc', 'cookiepro'
    ];

    // Seznam známých ad-tech domén které nejsou v Disconnect.me
    // CO: Top ad-tech platformy a DSP (Demand Side Platform)
    // PROČ: AppNexus, Rubicon, OpenX jsou obří trackery, musí být detekovány
    // JAK: Hardcoded seznam top 14 ad-tech domén
    const knownAdTechDomains = [
      'adnxs.com',           // AppNexus (Microsoft)
      'rubiconproject.com',  // Rubicon Project (Magnite)
      'openx.net',           // OpenX
      'pubmatic.com',        // PubMatic
      'quantserve.com',      // Quantcast
      'doubleclick.net',     // Google DoubleClick
      'googlesyndication.com', // Google AdSense
      '3lift.com',           // TripleLift
      'sharethrough.com',    // Sharethrough
      'richaudience.com',    // RichAudience
      'unrulymedia.com',     // Unruly
      'seedtag.com',         // Seedtag
      'kueezrtb.com',        // Kueez RTB
      'cootlogix.com'        // Cootlogix
    ];

    // Iterace přes všechny third-party domény na stránce
    // CO: Prohledání každé third-party domény heuristikou
    // PROČ: Chceme detekovat trackery i když nejsou v databázi
    // JAK: Pro každou doménu → check keywords + check ad-tech → přidat do seznamu
    for (const domain of thirdPartyDomains) {
      // Skip pokud už je identifikovaný v databázi
      // CO: Kontrola zda tracker není už v trackersMap (z Disconnect.me)
      // PROČ: Nechceme duplicity (stejný tracker 2x)
      // JAK: Porovnání slug domény se slug identifikovaných trackerů
      const alreadyIdentified = Array.from(trackersMap.values()).some(t => {
        const slug = toWhoTracksSlug(t.name);
        return domain.includes(slug) || slug.includes(domain);
      });

      if (alreadyIdentified) continue; // Už máme, skip

      // Kontrola zda doména vypadá jako tracker
      // CO: Pattern matching - obsahuje doména tracker keyword?
      // PROČ: "googletagmanager.com" → "tag" → MATCH → tracker
      // JAK: .some() na keywords + .some() na known ad-tech
      const domainLower = domain.toLowerCase();
      const looksLikeTracker =
        trackerKeywords.some(kw => domainLower.includes(kw)) ||      // Keyword match
        knownAdTechDomains.some(tech => domainLower.includes(tech)); // Ad-tech match

      // Přidání do seznamu trackerů pokud match
      // CO: Vytvoření nového tracker záznamu s prefixem "Neidentifikovaný:"
      // PROČ: Uživatel vidí že je detekován heuristikou, ne databází
      // JAK: Přidání do trackersMap s kategorií "Unknown"
      if (looksLikeTracker) {
        const trackerName = `Neidentifikovaný: ${domain}`;
        if (!trackersMap.has(trackerName)) {
          trackersMap.set(trackerName, {
            name: trackerName,
            category: 'Unknown',  // Neznámá kategorie (není v databázi)
            description: 'Pravděpodobný tracker (není v databázi)',
            url: `https://www.ghostery.com/whotracksme/trackers/${domain.replace(/\./g, '_')}`,
          });
        }
      }
    }

    const trackers = Array.from(trackersMap.values());

    const totalTime = Date.now() - startTime;

    // Calculate percentages
    for (const category of Object.keys(breakdown)) {
      breakdown[category].percentage = totalSize > 0
        ? ((breakdown[category].size / totalSize) * 100).toFixed(1)
        : 0;
    }

    const result = {
      name: testName,
      url: testUrl,

      // Timing metrics
      timing: {
        browserLaunch: launchTime,
        pageLoad: loadTime,
        jsExecution: jsTime,
        total: totalTime,
      },

      // Performance timing
      performance: perfTiming || {},

      // Core Web Vitals
      webVitals,

      // Network summary
      network: {
        requests: requests.length,
        domains: domains.size,
        totalSize: totalSize,
        totalSizeMB: (totalSize / 1024 / 1024).toFixed(2),
      },

      // Content breakdown
      breakdown,

      // DOM metrics
      dom: domMetrics,

      // Privacy & tracking
      privacy: {
        cookies: cookies.length,
        thirdPartyCookies: thirdPartyCookies.length,
        trackers: trackers,
        thirdPartyDomains: Array.from(thirdPartyDomains).sort(),
      },

      // Debug info
      debug: {
        networkUrls: requests.length,
        domUrls: domData.domElementUrls.length,
        inlineUrls: domData.inlineUrls.length,
        dynamicScripts: domData.dynamicScripts.length,
        cookieUrls: domData.cookieUrls.length,
        localStorageUrls: domData.localStorageUrls.length,
        fingerprintingUrls: domData.fingerprintingUrls.length,
        canvasFingerprint: domData.canvasFingerprintCount,
        webrtc: domData.webrtcCount,
        fontDetection: domData.fontDetectionCount,
      },
    };

    // Calculate and add score
    const scoreData = calculatePageScore(result);
    const grade = getScoreGrade(scoreData.total);

    result.score = {
      total: scoreData.total,
      grade: grade.grade,
      description: grade.description,
      breakdown: scoreData.breakdown,
    };

    return result;

  } catch (error) {
    return {
      name: testName,
      url: testUrl,
      error: error.message
    };
  } finally {
    // Always close browser, even if error occurs
    if (browser) {
      try {
        await browser.close();
      } catch (e) {
        // Ignore close errors
      }
    }
  }
}

// ============================================================================
// ZOBRAZENÍ METODIKY TESTOVÁNÍ
// ============================================================================
// CO: Vypíše kompletní metodiku jak benchmark funguje
// PROČ: Uživatel chce vědět co se přesně testuje a jak
// JAK: Vypíše všechny sekce s CO/PROČ/JAK popisem
function showMethodology() {
  console.log('\n' + '═'.repeat(80));
  console.log('📚 METODIKA TESTOVÁNÍ - JAK BENCHMARK FUNGUJE');
  console.log('═'.repeat(80) + '\n');

  const sections = [
    {
      title: '1. SPUŠTĚNÍ PROHLÍŽEČE',
      co: 'Otevře novou instanci browseru (Chrome nebo Edge)',
      proc: 'Čistý stav pro každý test, žádný cache, cookies, historie',
      jak: 'Playwright launch s headless/headed módem'
    },
    {
      title: '2. VYTVOŘENÍ STRÁNKY S REALISTICKÝM USER AGENT',
      co: 'Nová záložka s nastaveným User-Agent',
      proc: 'Anti-bot ochrana - weby blokují headless browser bez UA',
      jak: 'Předstíráme Chrome 131 na Windows 10'
    },
    {
      title: '3. NETWORK TRACKING - Sledování všech HTTP requestů',
      co: 'Zachytávání všech network requestů a responses',
      proc: 'Potřebujeme vědět: kolik requestů, z jakých domén, jak velké',
      jak: 'Event listeners na page.on(\'request\') a page.on(\'response\')'
    },
    {
      title: '4. ADVANCED FINGERPRINTING DETECTION',
      co: 'Podvrhne browser APIs pro detekci canvas/WebRTC/font fingerprintingu',
      proc: 'Moderní trackery používají fingerprinting místo cookies',
      jak: 'evaluateOnNewDocument() = spustí se před jakýmkoli JS na stránce',
      subsections: [
        '   • Canvas Fingerprinting - toDataURL(), toBlob(), getImageData()',
        '   • WebRTC Leak Detection - RTCPeerConnection monitoring',
        '   • Font Detection - document.fonts.check() enumeration'
      ]
    },
    {
      title: '5. NAVIGACE A NAČÍTÁNÍ STRÁNKY',
      co: 'Otevření URL a měření času načtení',
      proc: 'Hlavní metrika - jak dlouho trvá načtení stránky',
      jak: 'page.goto() s timeout + fallback strategií (load → domcontentloaded)'
    },
    {
      title: '6. SIMULACE UŽIVATELSKÉ INTERAKCE + LAZY-LOAD',
      co: 'Scrollování + čekání 5s pro zachycení lazy-loaded trackerů',
      proc: 'Trackery se často aktivují až po scroll/interakci, ne při načtení',
      jak: 'MutationObserver + scroll simulace (střed→dolů→nahoru) + 5s wait'
    },
    {
      title: '7. PERFORMANCE NAVIGATION TIMING',
      co: 'Získání timing metrik z Performance API',
      proc: 'Přesné měření TTFB, DOMContentLoaded, Load Complete',
      jak: 'performance.getEntriesByType(\'navigation\') = browser built-in metrics'
    },
    {
      title: '8. CORE WEB VITALS - Google ranking faktory',
      co: 'Získání LCP, CLS, FID metrik',
      proc: 'Google používá tyto metriky pro SEO ranking',
      jak: 'Performance API entries pro paint, layout-shift, first-input',
      subsections: [
        '   • LCP (Largest Contentful Paint) - Kdy se vykreslí hlavní obsah',
        '   • CLS (Cumulative Layout Shift) - Vizuální stabilita layoutu',
        '   • FID (First Input Delay) - Responsiveness na user input'
      ]
    },
    {
      title: '9. JAVASCRIPT EXECUTION TEST',
      co: 'Měření rychlosti JavaScript výpočtu v browseru',
      proc: 'Benchmark rychlosti JS enginu (V8 vs SpiderMonkey)',
      jak: '1 milion Math.sqrt() operací → měření času'
    },
    {
      title: '10. DOM METRICS',
      co: 'Počítání různých typů elementů v DOM',
      proc: 'Velký DOM = pomalé rendering, vysoká paměť',
      jak: 'querySelectorAll() na různé selektory (*, a, img, script, link)'
    },
    {
      title: '11. COOKIE ANALÝZA',
      co: 'Získání všech cookies a filtrování third-party',
      proc: 'Third-party cookies = tracking riziko, GDPR problém',
      jak: 'context.cookies() → filtr podle domény (jiná než page URL)'
    },
    {
      title: '12. NETWORK BREAKDOWN - Kategorizace requestů',
      co: 'Rozdělení network requestů do kategorií (JS, CSS, images, atd.)',
      proc: 'Analýza co zabírá nejvíc dat (např. 5MB obrázků vs 100KB JS)',
      jak: 'Pro každý response → determine category → increment count + size'
    },
    {
      title: '13. THIRD-PARTY DOMAINS',
      co: 'Identifikace všech domén ze kterých se načítá obsah (kromě hlavní)',
      proc: 'Third-party = potenciální trackery, security risk, GDPR problem',
      jak: 'Pro každý request → check hostname → pokud != main domain → přidat'
    },
    {
      title: '14. MULTI-SOURCE TRACKER DETECTION',
      co: 'Hledá trackery v: DOM, inline scripts, cookies, localStorage, fingerprinting',
      proc: 'Trackery nejsou jen v network requestech - mohou být kdekoli',
      jak: 'page.evaluate() = spuštění kódu v kontextu stránky',
      subsections: [
        '   • DOM Elements - <script src>, <iframe>, <img>, <link>',
        '   • Inline Scripts - Regex search v <script> obsahu',
        '   • Cookies - Jména obsahující tracker domény',
        '   • localStorage - Keys/values s tracker references',
        '   • Fingerprinting - Stack traces z hooked APIs',
        '   • MutationObserver - Dynamicky přidané scripty'
      ]
    },
    {
      title: '15. AGREGACE TRACKERŮ',
      co: 'Detekce trackerů ze všech zdrojů (network + DOM + cookies + storage)',
      proc: 'Tracker může být v requestu, DOM elementu, cookie, localStorage - všude',
      jak: 'Map = deduplikace podle jména (stejný tracker jen 1x)',
      subsections: [
        '   • Check proti Disconnect.me databázi (~4700 open-source trackerů)',
        '   • Zdroj: https://github.com/disconnectme/disconnect-tracking-protection',
        '   • Detekce z network requests',
        '   • Detekce z DOM/cookies/storage/fingerprinting'
      ]
    },
    {
      title: '16. HEURISTICKÁ DETEKCE',
      co: 'Hledá third-party domény které VYPADAJÍ jako trackery (ale nejsou v DB)',
      proc: 'Disconnect.me má ~4700 trackerů, ale existují tisíce dalších',
      jak: 'Keyword matching + známé ad-tech domény → pravděpodobnost trackeru',
      subsections: [
        '   • Keywords: ad, track, analytics, pixel, sync, bid, tag, consent, atd.',
        '   • Consent Management: consentmanager, cookiebot, onetrust, trustarc',
        '   • Known ad-tech: adnxs.com, rubiconproject.com, doubleclick.net, atd.',
        '   • Prefix "Neidentifikovaný:" pro heuristicky detekované'
      ]
    },
    {
      title: '17. VÝPOČET KVALITY STRÁNKY (Score 0-100)',
      co: 'Celkové hodnocení stránky na základě 5 metrik',
      proc: 'Komplexní hodnocení webu - rychlost, velikost, privacy, DOM',
      jak: 'Vážený průměr: Performance + Size + Requests + Privacy + DOM',
      subsections: [
        '   • Performance (LCP, CLS, Page Load) - Rychlost načítání',
        '   • Size (MB) - Celková velikost stránky',
        '   • Requests - Počet HTTP requestů',
        '   • Privacy - Trackery a third-party cookies',
        '   • DOM Complexity - Počet elementů v DOM',
        '   • Grade: A+ (90+), A (80+), B (70+), C (60+), D (50+), F (<50)'
      ]
    }
  ];

  sections.forEach((section, index) => {
    console.log(`${section.title}`);
    console.log('─'.repeat(80));
    console.log(`   CO:   ${section.co}`);
    console.log(`   PROČ: ${section.proc}`);
    console.log(`   JAK:  ${section.jak}`);
    if (section.subsections) {
      console.log('');
      section.subsections.forEach(sub => console.log(sub));
    }
    console.log('');
  });

  console.log('═'.repeat(80));
  console.log('📊 CELKOVÝ POČET METRIK:');
  console.log('   • Timing: Browser Launch, TTFB, DOMContentLoaded, Load Complete, Total');
  console.log('   • Core Web Vitals: LCP, CLS, FID');
  console.log('   • Network: Requests, Domains, Total Size, Breakdown (JS/CSS/Images/Fonts)');
  console.log('   • DOM: Elements, Links, Images, Scripts, Stylesheets');
  console.log('   • Privacy: Cookies, Third-party Cookies, Trackers, Third-party Domains');
  console.log('   • Fingerprinting: Canvas, WebRTC, Font Detection counts');
  console.log('   • Quality Score: 0-100 (breakdown per category)');
  console.log('═'.repeat(80) + '\n');
}

// Main benchmark
// ============================================================================
// HLAVNÍ BENCHMARK FUNKCE - Entry point celého programu
// ============================================================================
// CO: Orchestrace celého benchmarku - init, výběr stránek, testy, výsledky
// PROČ: Main funkce která řídí celý flow programu od startu po konec
// JAK: 1) Load trackers, 2) Headless/Headed choice, 3) Loop: výběr→test→results
async function runBenchmark() {
  // ========================================================================
  // INICIALIZACE - Načtení tracker databáze
  // ========================================================================
  // CO: Stažení ~4700 trackerů z Disconnect.me před prvním testem
  // PROČ: Potřebujeme tracker databázi pro detekci
  // JAK: await loadTrackers() = async fetch from GitHub
  await loadTrackers();

  // ========================================================================
  // ÚVODNÍ OBRAZOVKA
  // ========================================================================
  // CO: Zobrazení welcome message a info o programu
  // PROČ: UX - user ví že program běží
  console.log('\n╔════════════════════════════════════════════════════════════╗');
  console.log('║           🚀 BROWSER SPEED BENCHMARK 🚀                    ║');
  console.log('╚════════════════════════════════════════════════════════════╝\n');
  console.log('Spouštím test...\n');

  // ========================================================================
  // NABÍDKA ZOBRAZENÍ METODIKY
  // ========================================================================
  // CO: Ptát se zda user chce vidět detailní popis jak benchmark funguje
  // PROČ: Transparentnost - user vidí co přesně se testuje a jak
  // JAK: Prompt → y = showMethodology() → vypíše všechny sekce
  const rlMethodology = createInterface();
  const methodologyAnswer = await question(rlMethodology, '📚 Chceš zobrazit metodiku testování? (y/N): ');
  rlMethodology.close();

  if (methodologyAnswer.toLowerCase().startsWith('y')) {
    showMethodology();

    // Pauza před pokračováním
    const rlContinue = createInterface();
    await question(rlContinue, '\nStiskni ENTER pro pokračování...');
    rlContinue.close();
  }

  // ========================================================================
  // VÝBĚR HEADLESS/HEADED REŽIMU
  // ========================================================================
  // CO: Ptát se na headless vs headed pouze pokud není nastaveno přes CLI
  // PROČ: CLI flags --headed/--headless mají přednost před interaktivní volbou
  // JAK: Check process.argv → pokud není → prompt uživatele
  if (!process.argv.includes('--headed') && !process.argv.includes('--headless')) {

    // Vysvětlení režimů
    // CO: Info o rozdílu mezi headless a headed
    // PROČ: User nemusí vědět co to znamená
    console.log('Režim testování:\n');
    console.log('  🔇 Headless (doporučeno)');
    console.log('     - Browsery běží bez viditelného okna');
    console.log('     - Rychlejší a konzistentnější výsledky\n');
    console.log('  👁️  Headed (debug)');
    console.log('     - Vidíte otevřené okno browseru');
    console.log('     - Pomalejší, pro vizualizaci testů\n');

    // Interaktivní prompt
    // CO: Otázka uživateli - chce headed mode?
    // PROČ: Default je headless (rychlejší), ale user může chtít vidět okna
    // JAK: readline prompt → y=headed, N=headless (default)
    const rl = createInterface();
    const answer = await question(rl, 'Spustit v headed mode (viditelné okno)? (y/N): ');
    rl.close();

    config.headless = !answer.toLowerCase().startsWith('y'); // y→headed, jinak headless
  }

  // ========================================================================
  // HLAVNÍ LOOP - Opakované testování až do exit
  // ========================================================================
  // CO: Nekonečný loop pro opakované testy
  // PROČ: User může spustit více testů bez restartu programu
  // JAK: while(true) → break pouze na explicitní exit confirmation
  while (true) {
    // Hlavička hlavního menu
    // CO: Zobrazení stavu (headless/headed) + hlavní logo
    // PROČ: User vidí v jakém režimu běží testy
    console.log('\n╔════════════════════════════════════════════════════════════╗');
    console.log('║           🚀 BROWSER SPEED BENCHMARK 🚀                    ║');
    console.log('╚════════════════════════════════════════════════════════════╝');
    console.log(`\nRežim: ${config.headless ? '🔇 Headless (bez viditelného okna)' : '👁️  Headed (s viditelným oknem)'}`);
    if (!config.headless) {
      console.log('⚠️  Headed mode je pomalejší - určený pro debug/vizualizaci');
    }

    // ======================================================================
    // VÝBĚR STRÁNEK K TESTOVÁNÍ
    // ======================================================================
    // CO: Interaktivní menu pro výběr webů (BBC, Seznam, custom URL, atd.)
    // PROČ: User si vybere co chce testovat
    // JAK: await selectWebsites() = interaktivní menu
    const websites = await selectWebsites();

    // ======================================================================
    // EXIT HANDLING - User zvolil ukončení
    // ======================================================================
    // CO: Pokud selectWebsites() vrátí null → user chce exit
    // PROČ: Validovat exit + možnost porovnat headless vs headed
    // JAK: websites===null → compare results → final confirmation → break/continue
    if (websites === null) {
      // Pokus o zobrazení porovnání headless vs headed (pokud existuje)
      // CO: Když existují testy v obou režimech → zobraz porovnání
      // PROČ: Zajímavá metrika - jak moc headed mode zpomaluje
      await compareHeadlessVsHeaded();

      // Finální potvrzení ukončení
      // CO: Ptát se "Opravdu exit?" aby user omylem neukončil
      // PROČ: Prevence accidental exit po dlouhém benchmarku
      const rl = createInterface();
      const exitAnswer = await question(rl, '\n❓ Opravdu ukončit program? (y/N): ');
      rl.close();

      if (exitAnswer.toLowerCase().startsWith('y')) {
        console.log('👋 Děkuji za použití Browser Speed Benchmark!\n');
        break; // Exit main loop → konec programu
      } else {
        console.log('📋 Návrat do hlavního menu...\n');
        continue; // Zpět do menu (nový loop iteration)
      }
    }

    // Reset results for new test
    results.chrome.tests = [];
    results.edge.tests = [];

  console.log('\n' + '='.repeat(80));
  console.log('\n⏳ Spouštím testy...\n');
  console.log('='.repeat(80));

  // Detect Chrome installation
  const chromePath = detectChrome();
  let chromeBrowserType = chromium;
  let chromeLabel = 'Chrome';

  if (chromePath) {
    console.log(`  ℹ️  Nalezen Google Chrome: ${chromePath}`);
    chromeLabel = 'Google Chrome';
    results.chrome.name = 'Google Chrome';
  } else {
    console.log('  ℹ️  Google Chrome nenalezen, používám Chromium (Playwright)');
    chromeLabel = 'Chromium';
    results.chrome.name = 'Chromium (open-source Chrome)';
  }

  // Test Chrome
  console.log(`\n📊 Testování: ${chromeLabel}\n`);
  for (let i = 0; i < websites.length; i++) {
    const site = websites[i];
    console.log(`  🌐 Chrome [${i+1}/${websites.length}] ${site.name}`);
    console.log(`     ${site.url}`);
    const result = await runTest(chromium, 'chrome', site.url, site.name, chromePath);
    results.chrome.tests.push(result);
    if (result.error) {
      console.log(`     ❌ Chyba: ${result.error}\n`);
    } else {
      // Color LCP red if >= 2.5s (Google recommendation for page rework)
      const lcpSeconds = (result.webVitals.lcp / 1000).toFixed(2);
      const lcpColor = result.webVitals.lcp >= 2500 ? '\x1b[31m' : ''; // Red if >= 2.5s
      const lcpReset = result.webVitals.lcp >= 2500 ? '\x1b[0m' : '';

      // Color trackers: 0 = green, 1-3 = orange, 4+ = red
      const trackerCount = result.privacy.trackers.length;
      let trackerColor = '';
      if (trackerCount === 0) trackerColor = '\x1b[32m'; // Green
      else if (trackerCount <= 3) trackerColor = '\x1b[33m'; // Orange/Yellow
      else trackerColor = '\x1b[31m'; // Red
      const trackerReset = '\x1b[0m';

      console.log(`     ✅ Načtení: ${result.timing.pageLoad}ms | Requests: ${result.network.requests} | Velikost: ${result.network.totalSizeMB}MB`);
      console.log(`     📊 LCP (Largest Contentful Paint): ${lcpColor}${lcpSeconds}s${lcpReset} | Trackers: ${trackerColor}${trackerCount}${trackerReset}`);

      // Show detected trackers
      if (trackerCount > 0) {
        console.log(`     🔍 Detekované trackery: ${result.privacy.trackers.map(t => t.name).join(', ')}`);

        // Show detection sources
        if (result.debug) {
          console.log(`     📊 Zdroje detekce:`);
          console.log(`        Network requests: ${result.debug.networkUrls} URL`);
          console.log(`        DOM elements: ${result.debug.domUrls} URL`);
          console.log(`        Inline scripts: ${result.debug.inlineUrls} URL`);
          console.log(`        Dynamic scripts (MutationObserver): ${result.debug.dynamicScripts} URL`);
          console.log(`        Cookies: ${result.debug.cookieUrls} trackerů`);
          console.log(`        localStorage: ${result.debug.localStorageUrls} trackerů`);
          console.log(`        Fingerprinting: ${result.debug.fingerprintingUrls} trackerů`);
          console.log(`        └─ Canvas: ${result.debug.canvasFingerprint} volání`);
          console.log(`        └─ WebRTC: ${result.debug.webrtc} pokusů`);
          console.log(`        └─ Font detection: ${result.debug.fontDetection} pokusů`);
        }
      }

      // Show all third-party domains (for debugging)
      if (result.privacy.thirdPartyDomains.length > 0) {
        console.log(`     🌍 Third-party domény (${result.privacy.thirdPartyDomains.length}):`);
        console.log(`        ${result.privacy.thirdPartyDomains.join(', ')}`);
      }
      console.log('');
    }
  }

  // Test Edge - use system Edge
  console.log('\n📊 Testování: Microsoft Edge\n');

  const edgePath = detectEdge();

  if (edgePath) {
    console.log(`  ℹ️  Nalezen Microsoft Edge: ${edgePath}\n`);
    results.edge.name = 'Microsoft Edge';
  } else {
    console.log('  ⚠️  Microsoft Edge nenalezen!\n');
    console.log('  ❌ Edge musí být nainstalovaný pro testování.\n');
    // Skip Edge tests if not found
    console.log('  ⏭️  Přeskakuji Edge testy...\n');
  }

  if (edgePath) {
    for (let i = 0; i < websites.length; i++) {
      const site = websites[i];
      console.log(`  🌐 Edge [${i+1}/${websites.length}] ${site.name}`);
      console.log(`     ${site.url}`);
      const result = await runTest(chromium, 'edge', site.url, site.name, edgePath);
      results.edge.tests.push(result);
      if (result.error) {
        console.log(`     ❌ Chyba: ${result.error}\n`);
      } else {
        // Color LCP red if >= 2.5s (Google recommendation for page rework)
        const lcpSeconds = (result.webVitals.lcp / 1000).toFixed(2);
        const lcpColor = result.webVitals.lcp >= 2500 ? '\x1b[31m' : ''; // Red if >= 2.5s
        const lcpReset = result.webVitals.lcp >= 2500 ? '\x1b[0m' : '';

        // Color trackers: 0 = green, 1-3 = orange, 4+ = red
        const trackerCount = result.privacy.trackers.length;
        let trackerColor = '';
        if (trackerCount === 0) trackerColor = '\x1b[32m'; // Green
        else if (trackerCount <= 3) trackerColor = '\x1b[33m'; // Orange/Yellow
        else trackerColor = '\x1b[31m'; // Red
        const trackerReset = '\x1b[0m';

        console.log(`     ✅ Načtení: ${result.timing.pageLoad}ms | Requests: ${result.network.requests} | Velikost: ${result.network.totalSizeMB}MB`);
        console.log(`     📊 LCP (Largest Contentful Paint): ${lcpColor}${lcpSeconds}s${lcpReset} | Trackers: ${trackerColor}${trackerCount}${trackerReset}`);

        // Show detected trackers
        if (trackerCount > 0) {
          console.log(`     🔍 Detekované trackery: ${result.privacy.trackers.map(t => t.name).join(', ')}`);

          // Show detection sources
          if (result.debug) {
            console.log(`     📊 Zdroje detekce:`);
            console.log(`        Network requests: ${result.debug.networkUrls} URL`);
            console.log(`        DOM elements: ${result.debug.domUrls} URL`);
            console.log(`        Inline scripts: ${result.debug.inlineUrls} URL`);
            console.log(`        Dynamic scripts (MutationObserver): ${result.debug.dynamicScripts} URL`);
            console.log(`        Cookies: ${result.debug.cookieUrls} trackerů`);
            console.log(`        localStorage: ${result.debug.localStorageUrls} trackerů`);
            console.log(`        Fingerprinting: ${result.debug.fingerprintingUrls} trackerů`);
            console.log(`        └─ Canvas: ${result.debug.canvasFingerprint} volání`);
            console.log(`        └─ WebRTC: ${result.debug.webrtc} pokusů`);
            console.log(`        └─ Font detection: ${result.debug.fontDetection} pokusů`);
          }
        }

        // Show all third-party domains (for debugging)
        if (result.privacy.thirdPartyDomains.length > 0) {
          console.log(`     🌍 Third-party domény (${result.privacy.thirdPartyDomains.length}):`);
          console.log(`        ${result.privacy.thirdPartyDomains.join(', ')}`);
        }
        console.log('');
      }
    }
  }

  // Display comprehensive results
  console.log('\n' + '='.repeat(80));
  console.log('\n📈 DETAILNÍ VÝSLEDKY\n');
  console.log('='.repeat(80));

  const chromeTests = results.chrome.tests.filter(t => !t.error);
  const edgeTests = results.edge.tests.filter(t => !t.error);

  // Display results for each browser
  for (const [key, data] of Object.entries(results)) {
    const validTests = data.tests.filter(t => !t.error);

    if (validTests.length === 0) {
      console.log(`\n${data.name}: Žádné úspěšné testy`);
      continue;
    }

    console.log(`\n╔════════════════════════════════════════════════════════════╗`);
    console.log(`║  ${data.name.padEnd(56)}  ║`);
    console.log(`╚════════════════════════════════════════════════════════════╝`);

    // Calculate averages
    const avg = {
      timing: {
        browserLaunch: validTests.reduce((sum, t) => sum + t.timing.browserLaunch, 0) / validTests.length,
        pageLoad: validTests.reduce((sum, t) => sum + t.timing.pageLoad, 0) / validTests.length,
        total: validTests.reduce((sum, t) => sum + t.timing.total, 0) / validTests.length,
      },
      performance: {
        ttfb: validTests.reduce((sum, t) => sum + (t.performance.ttfb || 0), 0) / validTests.length,
        domContentLoaded: validTests.reduce((sum, t) => sum + (t.performance.domContentLoaded || 0), 0) / validTests.length,
        loadComplete: validTests.reduce((sum, t) => sum + (t.performance.loadComplete || 0), 0) / validTests.length,
      },
      webVitals: {
        lcp: validTests.reduce((sum, t) => sum + t.webVitals.lcp, 0) / validTests.length,
        cls: validTests.reduce((sum, t) => sum + t.webVitals.cls, 0) / validTests.length,
      },
      network: {
        requests: validTests.reduce((sum, t) => sum + t.network.requests, 0) / validTests.length,
        domains: validTests.reduce((sum, t) => sum + t.network.domains, 0) / validTests.length,
        totalSizeMB: validTests.reduce((sum, t) => sum + parseFloat(t.network.totalSizeMB), 0) / validTests.length,
      },
      breakdown: {},
      dom: {
        elements: validTests.reduce((sum, t) => sum + t.dom.elements, 0) / validTests.length,
        links: validTests.reduce((sum, t) => sum + t.dom.links, 0) / validTests.length,
        images: validTests.reduce((sum, t) => sum + t.dom.images, 0) / validTests.length,
      },
      privacy: {
        cookies: validTests.reduce((sum, t) => sum + t.privacy.cookies, 0) / validTests.length,
        thirdPartyCookies: validTests.reduce((sum, t) => sum + t.privacy.thirdPartyCookies, 0) / validTests.length,
        trackers: [],
      },
    };

    // Calculate average breakdown
    const categories = ['document', 'css', 'javascript', 'image', 'font', 'media', 'xhr', 'other'];
    for (const cat of categories) {
      avg.breakdown[cat] = {
        count: validTests.reduce((sum, t) => sum + t.breakdown[cat].count, 0) / validTests.length,
        size: validTests.reduce((sum, t) => sum + t.breakdown[cat].size, 0) / validTests.length,
        percentage: validTests.reduce((sum, t) => sum + parseFloat(t.breakdown[cat].percentage), 0) / validTests.length,
      };
    }

    // Collect all unique trackers (deduplicate by name)
    const allTrackersMap = new Map();
    for (const test of validTests) {
      for (const tracker of test.privacy.trackers) {
        if (!allTrackersMap.has(tracker.name)) {
          allTrackersMap.set(tracker.name, tracker);
        }
      }
    }
    avg.privacy.trackers = Array.from(allTrackersMap.values());

    // Calculate overall score
    const scores = validTests.map(t => calculatePageScore(t));
    const avgScore = scores.reduce((sum, s) => sum + s.total, 0) / scores.length;
    const grade = getScoreGrade(avgScore);

    // Display results
    console.log(`\n⏱️  ČASOVÉ METRIKY:`);
    console.log(`  Spuštění browseru:      ${avg.timing.browserLaunch.toFixed(0)}ms`);
    console.log(`  TTFB:                   ${avg.performance.ttfb.toFixed(0)}ms`);
    console.log(`  DOM Content Loaded:     ${avg.performance.domContentLoaded.toFixed(0)}ms`);
    console.log(`  Load Complete:          ${avg.performance.loadComplete.toFixed(0)}ms`);
    console.log(`  Celkový čas:            ${avg.timing.total.toFixed(0)}ms`);

    console.log(`\n🎯 CORE WEB VITALS:`);
    console.log(`  LCP (Largest Contentful Paint): ${(avg.webVitals.lcp / 1000).toFixed(2)}s ${avg.webVitals.lcp < 2500 ? '🟢' : avg.webVitals.lcp < 4000 ? '🟡' : '🔴'}`);
    console.log(`  CLS (Cumulative Layout Shift):  ${avg.webVitals.cls.toFixed(3)} ${avg.webVitals.cls < 0.1 ? '🟢' : avg.webVitals.cls < 0.25 ? '🟡' : '🔴'}`);

    console.log(`\n🌐 NETWORK:`);
    console.log(`  HTTP Requesty:          ${avg.network.requests.toFixed(0)}`);
    console.log(`  Domény:                 ${avg.network.domains.toFixed(0)}`);
    console.log(`  Celková velikost:       ${avg.network.totalSizeMB.toFixed(2)} MB`);

    console.log(`\n📦 BREAKDOWN OBSAHU:`);
    console.log(`  JavaScript:             ${avg.breakdown.javascript.count.toFixed(0)} souborů (${(avg.breakdown.javascript.size / 1024).toFixed(0)} KB, ${avg.breakdown.javascript.percentage.toFixed(1)}%)`);
    console.log(`  CSS:                    ${avg.breakdown.css.count.toFixed(0)} souborů (${(avg.breakdown.css.size / 1024).toFixed(0)} KB, ${avg.breakdown.css.percentage.toFixed(1)}%)`);
    console.log(`  Obrázky:                ${avg.breakdown.image.count.toFixed(0)} souborů (${(avg.breakdown.image.size / 1024).toFixed(0)} KB, ${avg.breakdown.image.percentage.toFixed(1)}%)`);
    console.log(`  Fonty:                  ${avg.breakdown.font.count.toFixed(0)} souborů (${(avg.breakdown.font.size / 1024).toFixed(0)} KB, ${avg.breakdown.font.percentage.toFixed(1)}%)`);

    console.log(`\n🏗️  DOM:`);
    console.log(`  Elementy:               ${avg.dom.elements.toFixed(0)}`);
    console.log(`  Odkazy:                 ${avg.dom.links.toFixed(0)}`);
    console.log(`  Obrázky:                ${avg.dom.images.toFixed(0)}`);

    console.log(`\n🔒 PRIVACY & TRACKING:`);
    console.log(`  Cookies:                ${avg.privacy.cookies.toFixed(0)} (${avg.privacy.thirdPartyCookies.toFixed(0)} third-party)`);
    console.log(`  Detekované trackery:    ${avg.privacy.trackers.length}`);
    if (avg.privacy.trackers.length > 0) {
      console.log('');
      for (const tracker of avg.privacy.trackers) {
        console.log(`    • ${tracker.name} (${tracker.category})`);
        console.log(`      ${tracker.description}`);
        console.log(`      \x1b]8;;${tracker.url}\x1b\\${tracker.url}\x1b]8;;\x1b\\\n`);
      }
    }

    console.log(`\n⭐ CELKOVÉ HODNOCENÍ:`);
    console.log(`  Skóre:                  ${avgScore.toFixed(0)}/100 ${grade.emoji}`);
    console.log(`  Známka:                 ${grade.grade} (${grade.description})`);
  }

  // Declare variables for summary (will be populated if both browsers tested)
  let chromeAvg, edgeAvg, chromeScore, edgeScore, chromeWins, edgeWins;

  // Browser comparison
  if (chromeTests.length > 0 && edgeTests.length > 0) {
    console.log('\n' + '='.repeat(80));
    console.log('\n🆚 SROVNÁNÍ BROWSERŮ\n');
    console.log('='.repeat(80));

    // Count unique trackers by name
    const chromeTrackerNames = new Set(chromeTests.flatMap(t => t.privacy.trackers.map(tr => tr.name)));
    const edgeTrackerNames = new Set(edgeTests.flatMap(t => t.privacy.trackers.map(tr => tr.name)));

    chromeAvg = {
      pageLoad: chromeTests.reduce((sum, t) => sum + t.timing.pageLoad, 0) / chromeTests.length,
      lcp: chromeTests.reduce((sum, t) => sum + t.webVitals.lcp, 0) / chromeTests.length,
      cls: chromeTests.reduce((sum, t) => sum + t.webVitals.cls, 0) / chromeTests.length,
      requests: chromeTests.reduce((sum, t) => sum + t.network.requests, 0) / chromeTests.length,
      sizeMB: chromeTests.reduce((sum, t) => sum + parseFloat(t.network.totalSizeMB), 0) / chromeTests.length,
      trackers: chromeTrackerNames.size,
    };

    edgeAvg = {
      pageLoad: edgeTests.reduce((sum, t) => sum + t.timing.pageLoad, 0) / edgeTests.length,
      lcp: edgeTests.reduce((sum, t) => sum + t.webVitals.lcp, 0) / edgeTests.length,
      cls: edgeTests.reduce((sum, t) => sum + t.webVitals.cls, 0) / edgeTests.length,
      requests: edgeTests.reduce((sum, t) => sum + t.network.requests, 0) / edgeTests.length,
      sizeMB: edgeTests.reduce((sum, t) => sum + parseFloat(t.network.totalSizeMB), 0) / edgeTests.length,
      trackers: edgeTrackerNames.size,
    };

    // Calculate scores
    const chromeScores = chromeTests.map(t => calculatePageScore(t));
    const edgeScores = edgeTests.map(t => calculatePageScore(t));
    chromeScore = chromeScores.reduce((sum, s) => sum + s.total, 0) / chromeScores.length;
    edgeScore = edgeScores.reduce((sum, s) => sum + s.total, 0) / edgeScores.length;

    // ANSI color codes
    const green = '\x1b[32m';
    const red = '\x1b[31m';
    const reset = '\x1b[0m';

    function colorBrowserNames(chromeVal, edgeVal, lowerIsBetter = true) {
      // Handle zero or very small values - no coloring for ties
      if (chromeVal === 0 && edgeVal === 0) return { chrome: 'Chrome', edge: 'Edge' };
      if (edgeVal === 0) {
        const chromeWins = lowerIsBetter;
        return {
          chrome: chromeWins ? `${green}Chrome${reset}` : `${red}Chrome${reset}`,
          edge: chromeWins ? `${red}Edge${reset}` : `${green}Edge${reset}`
        };
      }
      if (chromeVal === 0) {
        const edgeWins = lowerIsBetter;
        return {
          chrome: edgeWins ? `${red}Chrome${reset}` : `${green}Chrome${reset}`,
          edge: edgeWins ? `${green}Edge${reset}` : `${red}Edge${reset}`
        };
      }

      const diff = lowerIsBetter
        ? ((edgeVal - chromeVal) / edgeVal * 100)
        : ((chromeVal - edgeVal) / chromeVal * 100);

      // Check for NaN or Infinity or tie
      if (!isFinite(diff) || Math.abs(diff) < 1) {
        return { chrome: 'Chrome', edge: 'Edge' };
      }

      if (lowerIsBetter) {
        const chromeWins = chromeVal < edgeVal;
        return {
          chrome: chromeWins ? `${green}Chrome${reset}` : `${red}Chrome${reset}`,
          edge: chromeWins ? `${red}Edge${reset}` : `${green}Edge${reset}`
        };
      } else {
        const chromeWins = chromeVal > edgeVal;
        return {
          chrome: chromeWins ? `${green}Chrome${reset}` : `${red}Chrome${reset}`,
          edge: chromeWins ? `${red}Edge${reset}` : `${green}Edge${reset}`
        };
      }
    }

    // Helper: Checks if val1 wins over val2 with 1% threshold
    function isSignificantWin(val1, val2, lowerIsBetter = true) {
      if (val1 === 0 && val2 === 0) return false; // Tie
      if (val2 === 0) return lowerIsBetter ? false : true;
      if (val1 === 0) return lowerIsBetter ? true : false;

      const diff = lowerIsBetter
        ? ((val2 - val1) / val2 * 100)
        : ((val1 - val2) / val2 * 100);

      return isFinite(diff) && diff >= 1; // Win only if 1% or more
    }

    function getWinner(chromeVal, edgeVal, lowerIsBetter = true) {
      // Handle zero or very small values
      if (chromeVal === 0 && edgeVal === 0) return '🤝 Remíza (obě 0)';
      if (edgeVal === 0) return lowerIsBetter ? '🟢 Edge (0)' : '🟢 Chrome';
      if (chromeVal === 0) return lowerIsBetter ? '🟢 Chrome (0)' : '🟢 Edge';

      const diff = lowerIsBetter
        ? ((edgeVal - chromeVal) / edgeVal * 100)
        : ((chromeVal - edgeVal) / chromeVal * 100);

      // Check for NaN or Infinity
      if (!isFinite(diff)) return '🤝 Remíza';
      if (Math.abs(diff) < 1) return '🤝 Remíza';

      if (lowerIsBetter) {
        return chromeVal < edgeVal ? `🟢 Chrome (${Math.abs(diff).toFixed(1)}% rychlejší)` : `🟢 Edge (${Math.abs(diff).toFixed(1)}% rychlejší)`;
      } else {
        return chromeVal > edgeVal ? `🟢 Chrome (${Math.abs(diff).toFixed(1)}% lepší)` : `🟢 Edge (${Math.abs(diff).toFixed(1)}% lepší)`;
      }
    }

    // Page Load
    let colors = colorBrowserNames(chromeAvg.pageLoad, edgeAvg.pageLoad);
    console.log(`\n📊 Načítací čas:              ${colors.chrome}: ${chromeAvg.pageLoad.toFixed(0)}ms vs ${colors.edge}: ${edgeAvg.pageLoad.toFixed(0)}ms`);
    console.log(`   ${getWinner(chromeAvg.pageLoad, edgeAvg.pageLoad)}`);

    // LCP
    colors = colorBrowserNames(chromeAvg.lcp, edgeAvg.lcp);
    console.log(`\n📊 LCP (Core Web Vital):      ${colors.chrome}: ${(chromeAvg.lcp / 1000).toFixed(2)}s vs ${colors.edge}: ${(edgeAvg.lcp / 1000).toFixed(2)}s`);
    console.log(`   ${getWinner(chromeAvg.lcp, edgeAvg.lcp)}`);

    // CLS
    colors = colorBrowserNames(chromeAvg.cls, edgeAvg.cls);
    console.log(`\n📊 CLS (Core Web Vital):      ${colors.chrome}: ${chromeAvg.cls.toFixed(3)} vs ${colors.edge}: ${edgeAvg.cls.toFixed(3)}`);
    console.log(`   ${getWinner(chromeAvg.cls, edgeAvg.cls)}`);

    // HTTP Requests
    colors = colorBrowserNames(chromeAvg.requests, edgeAvg.requests);
    console.log(`\n📊 HTTP Requests:             ${colors.chrome}: ${chromeAvg.requests.toFixed(0)} vs ${colors.edge}: ${edgeAvg.requests.toFixed(0)}`);
    console.log(`   ${getWinner(chromeAvg.requests, edgeAvg.requests)}`);

    // Size
    colors = colorBrowserNames(chromeAvg.sizeMB, edgeAvg.sizeMB);
    console.log(`\n📊 Celková velikost:          ${colors.chrome}: ${chromeAvg.sizeMB.toFixed(2)}MB vs ${colors.edge}: ${edgeAvg.sizeMB.toFixed(2)}MB`);
    console.log(`   ${getWinner(chromeAvg.sizeMB, edgeAvg.sizeMB)}`);

    // Trackers
    colors = colorBrowserNames(chromeAvg.trackers, edgeAvg.trackers);
    console.log(`\n📊 Detekované trackery:       ${colors.chrome}: ${chromeAvg.trackers} vs ${colors.edge}: ${edgeAvg.trackers}`);
    console.log(`   ${getWinner(chromeAvg.trackers, edgeAvg.trackers)}`);

    // Score (higher is better) - use precise values with 2 decimal places
    const chromeScorePrecise = chromeScore.toFixed(2);
    const edgeScorePrecise = edgeScore.toFixed(2);

    // Special handling for score - only tie if EXACTLY the same (to 2 decimals)
    let scoreColors = { chrome: 'Chrome', edge: 'Edge' };
    if (Math.abs(chromeScore - edgeScore) >= 0.01) { // Different if differs by 0.01 or more
      scoreColors = colorBrowserNames(chromeScore, edgeScore, false);
    }

    let scoreWinner = '🤝 Remíza';
    if (chromeScore > edgeScore && Math.abs(chromeScore - edgeScore) >= 0.01) {
      const diff = ((chromeScore - edgeScore) / edgeScore * 100).toFixed(1);
      scoreWinner = `🟢 Chrome (${diff}% lepší)`;
    } else if (edgeScore > chromeScore && Math.abs(chromeScore - edgeScore) >= 0.01) {
      const diff = ((edgeScore - chromeScore) / chromeScore * 100).toFixed(1);
      scoreWinner = `🟢 Edge (${diff}% lepší)`;
    }

    console.log(`\n📊 Celkové skóre:             ${scoreColors.chrome}: ${chromeScorePrecise}/100 vs ${scoreColors.edge}: ${edgeScorePrecise}/100`);
    console.log(`   ${scoreWinner}`);

    // Overall winner - count wins in key metrics (don't count total score as it's derived)
    // Use 1% threshold - same logic as display
    console.log('\n' + '='.repeat(80));
    chromeWins = [
      isSignificantWin(chromeAvg.pageLoad, edgeAvg.pageLoad, true),
      isSignificantWin(chromeAvg.lcp, edgeAvg.lcp, true),
      isSignificantWin(chromeAvg.cls, edgeAvg.cls, true),
      isSignificantWin(chromeAvg.requests, edgeAvg.requests, true),
      isSignificantWin(chromeAvg.sizeMB, edgeAvg.sizeMB, true),
      isSignificantWin(chromeAvg.trackers, edgeAvg.trackers, true),
    ].filter(Boolean).length;

    edgeWins = [
      isSignificantWin(edgeAvg.pageLoad, chromeAvg.pageLoad, true),
      isSignificantWin(edgeAvg.lcp, chromeAvg.lcp, true),
      isSignificantWin(edgeAvg.cls, chromeAvg.cls, true),
      isSignificantWin(edgeAvg.requests, chromeAvg.requests, true),
      isSignificantWin(edgeAvg.sizeMB, chromeAvg.sizeMB, true),
      isSignificantWin(edgeAvg.trackers, chromeAvg.trackers, true),
    ].filter(Boolean).length;

    if (chromeWins > edgeWins) {
      console.log(`\n🏆 CELKOVÝ VÍTĚZ: Chrome (${chromeWins}:${edgeWins})`);
    } else if (edgeWins > chromeWins) {
      console.log(`\n🏆 CELKOVÝ VÍTĚZ: Edge (${edgeWins}:${chromeWins})`);
    } else {
      console.log(`\n🤝 REMÍZA (${chromeWins}:${edgeWins})`);
    }
  }

  console.log('\n' + '='.repeat(80) + '\n');

  // Save results to JSON with timestamp
  const fs = await import('fs');

  // Ensure output directory exists
  if (!fs.existsSync('output')) {
    fs.mkdirSync('output', { recursive: true });
  }

  // Add summary section with metadata, averages and winner
  const summaryData = {
    timestamp: new Date().toISOString(),
    config: {
      headless: config.headless,
      mode: config.headless ? 'Headless (bez viditelného okna)' : 'Headed (s viditelným oknem)'
    },
    testsCount: {
      chrome: chromeTests.length,
      edge: edgeTests.length,
      total: chromeTests.length + edgeTests.length
    }
  };

  // Add averages if both browsers have tests
  if (chromeTests.length > 0 && edgeTests.length > 0) {
    summaryData.averages = {
      chrome: {
        pageLoad: chromeAvg.pageLoad,
        lcp: chromeAvg.lcp,
        cls: chromeAvg.cls,
        requests: chromeAvg.requests,
        sizeMB: chromeAvg.sizeMB,
        trackers: chromeAvg.trackers,
        score: chromeScore
      },
      edge: {
        pageLoad: edgeAvg.pageLoad,
        lcp: edgeAvg.lcp,
        cls: edgeAvg.cls,
        requests: edgeAvg.requests,
        sizeMB: edgeAvg.sizeMB,
        trackers: edgeAvg.trackers,
        score: edgeScore
      }
    };

    // Determine winner
    summaryData.winner = {
      chromeWins: chromeWins,
      edgeWins: edgeWins,
      result: chromeWins > edgeWins ? 'Chrome' : (edgeWins > chromeWins ? 'Edge' : 'Tie')
    };
  }

  // Create final output with summary first
  const outputData = {
    summary: summaryData,
    chrome: results.chrome,
    edge: results.edge
  };

  const filename = generateFilename(websites);
  fs.writeFileSync(filename, JSON.stringify(outputData, null, 2));
  console.log(`💾 Výsledky uloženy do: ${filename}\n`);

  // Wait for user input before returning to menu
  const rl = createInterface();
  await question(rl, '⏸️  Stiskni ENTER pro návrat do menu nebo Ctrl+C pro ukončení...');
  rl.close();

  } // End of while loop
}

// Run
runBenchmark().catch(console.error);