// Reusable utility functions for Playwright automation.

const fs = require("fs");
const os = require("os");
const path = require("path");
const {
  loadPlaywright,
  ensureBrowserAvailable,
  sandboxOptions,
} = require("./runtime");

function isQuiet() {
  return process.env.PLAYWRIGHT_SKILL_QUIET === "1";
}

let playwrightBrowsers = null;

/**
 * Ensure Playwright is installed and its browser launchers (chromium,
 * firefox, webkit) are loaded, memoizing the result. Loading Playwright can
 * trigger a blocking install, so callers must invoke this explicitly (e.g.
 * at the top of an entry point) instead of relying on import-time side
 * effects. Safe to call more than once; only loads once per process.
 * @param {Object} options - forwarded to loadPlaywright (e.g. { quiet })
 * @returns {Object} { chromium, firefox, webkit }
 */
function ensurePlaywrightReady(options = {}) {
  if (!playwrightBrowsers) {
    playwrightBrowsers = loadPlaywright({ quiet: isQuiet(), ...options });
  }
  return playwrightBrowsers;
}

function log(...parts) {
  if (!isQuiet()) {
    console.error(...parts);
  }
}

function warn(...parts) {
  console.error(...parts);
}

/**
 * Parse extra HTTP headers from environment variables.
 * Supports two formats:
 * - PW_HEADER_NAME + PW_HEADER_VALUE: Single header (simple, common case)
 * - PW_EXTRA_HEADERS: JSON object for multiple headers (advanced)
 * Single header format takes precedence if both are set.
 * @returns {Object|null} Headers object or null if none configured
 */
function getExtraHeadersFromEnv() {
  const headerName = process.env.PW_HEADER_NAME;
  const headerValue = process.env.PW_HEADER_VALUE;

  if (headerName && headerValue) {
    return { [headerName]: headerValue };
  }

  const headersJson = process.env.PW_EXTRA_HEADERS;
  if (headersJson) {
    try {
      const parsed = JSON.parse(headersJson);
      if (
        typeof parsed === "object" &&
        parsed !== null &&
        !Array.isArray(parsed)
      ) {
        return parsed;
      }
      warn("PW_EXTRA_HEADERS must be a JSON object, ignoring...");
    } catch (error) {
      warn("Failed to parse PW_EXTRA_HEADERS as JSON:", error.message);
    }
  }

  return null;
}

/**
 * Merge environment-provided extra HTTP headers into browser context options.
 * @param {Object} options - Browser context options
 * @returns {Object} Options with extraHTTPHeaders merged in
 */
function getContextOptionsWithHeaders(options = {}) {
  const extraHeaders = getExtraHeadersFromEnv();

  if (!extraHeaders) {
    return options;
  }

  return {
    ...options,
    extraHTTPHeaders: {
      ...extraHeaders,
      ...(options.extraHTTPHeaders || {}),
    },
  };
}

/**
 * Launch browser with standard configuration.
 * @param {string} browserType - 'chromium', 'firefox', or 'webkit'
 * @param {Object} options - Additional launch options
 */
async function launchBrowser(browserType = "chromium", options = {}) {
  const defaultOptions = {
    headless: process.env.HEADLESS !== "false",
    slowMo: process.env.SLOW_MO ? parseInt(process.env.SLOW_MO, 10) : 0,
    ...(browserType === "chromium" ? sandboxOptions() : {}),
  };

  const browsers = ensurePlaywrightReady();
  const browser = browsers[browserType];

  if (!browser) {
    throw new Error(`Invalid browser type: ${browserType}`);
  }

  if (!options.executablePath && !options.channel) {
    ensureBrowserAvailable(browser, browserType);
  }
  return await browser.launch({ ...defaultOptions, ...options });
}

/**
 * Create a new page with viewport and user agent.
 * @param {Object} context - Browser context
 * @param {Object} options - Page options
 */
async function createPage(context, options = {}) {
  const page = await context.newPage();

  if (options.viewport) {
    await page.setViewportSize(options.viewport);
  }

  if (options.userAgent) {
    await page.setExtraHTTPHeaders({
      "User-Agent": options.userAgent,
    });
  }

  page.setDefaultTimeout(options.timeout || 30000);
  return page;
}

async function waitForAnimationFrames(page, frames = 2) {
  const frameCount = Math.max(0, Number(frames) || 0);
  if (frameCount === 0) {
    return;
  }

  await page.evaluate(
    (count) =>
      new Promise((resolve) => {
        let remaining = count;
        function tick() {
          remaining -= 1;
          if (remaining <= 0) {
            resolve();
            return;
          }
          window.requestAnimationFrame(tick);
        }
        window.requestAnimationFrame(tick);
      }),
    frameCount,
  );
}

async function waitForFonts(page) {
  await page.evaluate(async () => {
    if (document.fonts?.ready) {
      await document.fonts.ready;
    }
  });
}

// Playwright's internal TargetClosedError isn't exported from the public
// "playwright" package (only errors.TimeoutError is), so a closed
// page/context/browser surfaces as a plain Error whose message matches one
// of these shapes. See lib/client/errors.js in playwright-core.
const CLOSED_TARGET_MESSAGE_PATTERN =
  /Target (?:page, context or browser )?(?:has been |is )?closed|Browser has been closed/i;

function isClosedTargetError(error) {
  if (!error) {
    return false;
  }
  if (error.name === "TargetClosedError") {
    return true;
  }
  return (
    typeof error.message === "string" &&
    CLOSED_TARGET_MESSAGE_PATTERN.test(error.message)
  );
}

async function waitForStableBoundingBox(page, selector, options = {}) {
  const timeout = options.timeout || 10000;
  const requiredStableFrames = options.frames || 2;
  const locator = page.locator(selector).first();
  const deadline = Date.now() + timeout;
  let lastBox = null;
  let stableFrames = 0;

  while (Date.now() < deadline) {
    let box = null;
    try {
      box = await locator.boundingBox({ timeout: Math.min(1000, timeout) });
    } catch (error) {
      if (isClosedTargetError(error)) {
        throw error;
      }
      // Dynamic pages can briefly detach/recreate nodes during animation.
    }

    if (!box) {
      stableFrames = 0;
      await waitForAnimationFrames(page, 1);
      continue;
    }

    const stable =
      lastBox &&
      Math.abs(lastBox.x - box.x) < 0.5 &&
      Math.abs(lastBox.y - box.y) < 0.5 &&
      Math.abs(lastBox.width - box.width) < 0.5 &&
      Math.abs(lastBox.height - box.height) < 0.5;

    stableFrames = stable ? stableFrames + 1 : 0;
    lastBox = box;

    if (stableFrames >= requiredStableFrames) {
      return;
    }

    await waitForAnimationFrames(page, 1);
  }

  throw new Error(`Element bounding box did not stabilize: ${selector}`);
}

/**
 * Wait for SPA/page readiness using load state, a rendered selector, fonts, and
 * animation frames. Prefer this before screenshots of dynamic pages.
 * @param {Object} page - Playwright page
 * @param {Object} options - Wait options
 */
async function waitForStablePage(page, options = {}) {
  const timeout = options.timeout || 30000;
  const waitUntil = options.waitUntil || "domcontentloaded";
  const selector = options.selector || options.waitForSelector;
  const selectorState = options.state || "visible";
  const animationFrames = options.animationFrames ?? 2;

  if (waitUntil) {
    try {
      await page.waitForLoadState(waitUntil, { timeout });
    } catch (_error) {
      log(
        `Page did not reach load state '${waitUntil}' before timeout; continuing...`,
      );
    }
  }

  if (selector) {
    await page.waitForSelector(selector, { state: selectorState, timeout });
  }

  if (options.fonts !== false) {
    try {
      await waitForFonts(page);
    } catch (_error) {
      log("Font readiness check failed; continuing...");
    }
  }

  await waitForAnimationFrames(page, animationFrames);

  if (selector && options.stableBoundingBox) {
    await waitForStableBoundingBox(page, selector, {
      timeout,
      frames: options.stableFrames || 2,
    });
  }
}

/**
 * Smart wait for page to be ready. Kept for compatibility; prefer
 * waitForStablePage for SPA screenshots.
 * @param {Object} page - Playwright page
 * @param {Object} options - Wait options
 */
async function waitForPageReady(page, options = {}) {
  await waitForStablePage(page, {
    waitUntil: options.waitUntil || "networkidle",
    selector: options.selector || options.waitForSelector,
    timeout: options.timeout || 30000,
    animationFrames: options.animationFrames ?? 2,
    fonts: options.fonts,
    stableBoundingBox: options.stableBoundingBox,
    stableFrames: options.stableFrames,
  });
}

/**
 * Safe click with retry logic.
 * @param {Object} page - Playwright page
 * @param {string} selector - Element selector
 * @param {Object} options - Click options
 */
async function safeClick(page, selector, options = {}) {
  const maxRetries = options.retries || 3;
  const retryDelay = options.retryDelay || 1000;

  for (let i = 0; i < maxRetries; i += 1) {
    try {
      await page.waitForSelector(selector, {
        state: "visible",
        timeout: options.timeout || 5000,
      });
      await page.click(selector, {
        force: options.force || false,
        timeout: options.timeout || 5000,
      });
      return true;
    } catch (error) {
      if (i === maxRetries - 1) {
        console.error(
          `Failed to click ${selector} after ${maxRetries} attempts`,
        );
        throw error;
      }
      log(`Retry ${i + 1}/${maxRetries} for clicking ${selector}`);
      await page.waitForTimeout(retryDelay);
    }
  }

  return false;
}

/**
 * Safe text input with clear before type.
 * @param {Object} page - Playwright page
 * @param {string} selector - Input selector
 * @param {string} text - Text to type
 * @param {Object} options - Type options
 */
async function safeType(page, selector, text, options = {}) {
  await page.waitForSelector(selector, {
    state: "visible",
    timeout: options.timeout || 10000,
  });

  if (options.clear !== false) {
    await page.fill(selector, "");
  }

  if (options.slow) {
    await page.type(selector, text, { delay: options.delay || 100 });
  } else {
    await page.fill(selector, text);
  }
}

/**
 * Extract text from multiple elements.
 * @param {Object} page - Playwright page
 * @param {string} selector - Elements selector
 */
async function extractTexts(page, selector) {
  await page.waitForSelector(selector, { timeout: 10000 });
  return await page.$$eval(selector, (elements) =>
    elements.map((el) => el.textContent?.trim()).filter(Boolean),
  );
}

function timestampedScreenshotPath(name) {
  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
  const parsed = path.parse(name);
  const stem = parsed.ext ? parsed.name : name;
  const filename = `${stem}-${timestamp}.png`;

  if (path.isAbsolute(name)) {
    return parsed.ext ? name : `${name}-${timestamp}.png`;
  }

  if (name.includes(path.sep) || name.includes("/")) {
    const resolved = path.resolve(process.cwd(), name);
    const resolvedParsed = path.parse(resolved);
    return resolvedParsed.ext ? resolved : `${resolved}-${timestamp}.png`;
  }

  return path.join(os.tmpdir(), `playwright-${filename}`);
}

/**
 * Take screenshot with timestamp. Simple names are saved under /tmp.
 * @param {Object} page - Playwright page
 * @param {string} name - Screenshot name or path
 * @param {Object} options - Screenshot options
 */
async function takeScreenshot(page, name, options = {}) {
  const filename = timestampedScreenshotPath(name);
  fs.mkdirSync(path.dirname(filename), { recursive: true });

  await page.screenshot({
    path: filename,
    fullPage: options.fullPage !== false,
    ...options,
  });

  log(`Screenshot saved: ${filename}`);
  return filename;
}

/**
 * Handle authentication.
 * @param {Object} page - Playwright page
 * @param {Object} credentials - Username and password
 * @param {Object} selectors - Login form selectors
 */
async function authenticate(page, credentials, selectors = {}) {
  const defaultSelectors = {
    username: 'input[name="username"], input[name="email"], #username, #email',
    password: 'input[name="password"], #password',
    submit:
      'button[type="submit"], input[type="submit"], button:has-text("Login"), button:has-text("Sign in")',
  };

  const finalSelectors = { ...defaultSelectors, ...selectors };

  await safeType(page, finalSelectors.username, credentials.username);
  await safeType(page, finalSelectors.password, credentials.password);
  await safeClick(page, finalSelectors.submit);

  await Promise.race([
    page.waitForNavigation({ waitUntil: "networkidle" }),
    page.waitForSelector(
      selectors.successIndicator || ".dashboard, .user-menu, .logout",
      { timeout: 10000 },
    ),
  ]).catch(() => {
    log("Login might have completed without navigation");
  });
}

/**
 * Scroll page.
 * @param {Object} page - Playwright page
 * @param {string} direction - 'down', 'up', 'top', 'bottom'
 * @param {number} distance - Pixels to scroll (for up/down)
 */
async function scrollPage(page, direction = "down", distance = 500) {
  switch (direction) {
    case "down":
      await page.evaluate((d) => window.scrollBy(0, d), distance);
      break;
    case "up":
      await page.evaluate((d) => window.scrollBy(0, -d), distance);
      break;
    case "top":
      await page.evaluate(() => window.scrollTo(0, 0));
      break;
    case "bottom":
      await page.evaluate(() => window.scrollTo(0, document.body.scrollHeight));
      break;
    default:
      throw new Error(`Invalid scroll direction: ${direction}`);
  }
  await waitForAnimationFrames(page, 2);
}

/**
 * Extract table data.
 * @param {Object} page - Playwright page
 * @param {string} tableSelector - Table selector
 */
async function extractTableData(page, tableSelector) {
  await page.waitForSelector(tableSelector);

  return await page.evaluate((selector) => {
    const table = document.querySelector(selector);
    if (!table) return null;

    const headers = Array.from(table.querySelectorAll("thead th")).map((th) =>
      th.textContent?.trim(),
    );

    const rows = Array.from(table.querySelectorAll("tbody tr")).map((tr) => {
      const cells = Array.from(tr.querySelectorAll("td"));
      if (headers.length > 0) {
        return cells.reduce((obj, cell, index) => {
          obj[headers[index] || `column_${index}`] = cell.textContent?.trim();
          return obj;
        }, {});
      }
      return cells.map((cell) => cell.textContent?.trim());
    });

    return { headers, rows };
  }, tableSelector);
}

/**
 * Wait for and dismiss cookie banners.
 * @param {Object} page - Playwright page
 * @param {number} timeout - Max time to wait
 */
async function handleCookieBanner(page, timeout = 3000) {
  const commonSelectors = [
    'button:has-text("Accept")',
    'button:has-text("Accept all")',
    'button:has-text("OK")',
    'button:has-text("Got it")',
    'button:has-text("I agree")',
    ".cookie-accept",
    "#cookie-accept",
    '[data-testid="cookie-accept"]',
  ];

  for (const selector of commonSelectors) {
    try {
      const element = await page.waitForSelector(selector, {
        timeout: timeout / commonSelectors.length,
        state: "visible",
      });
      if (element) {
        await element.click();
        log("Cookie banner dismissed");
        return true;
      }
    } catch (_error) {
      // Continue to next selector.
    }
  }

  return false;
}

/**
 * Retry a function with exponential backoff.
 * @param {Function} fn - Function to retry
 * @param {number} maxRetries - Maximum retry attempts
 * @param {number} initialDelay - Initial delay in ms
 */
async function retryWithBackoff(fn, maxRetries = 3, initialDelay = 1000) {
  let lastError;

  for (let i = 0; i < maxRetries; i += 1) {
    try {
      return await fn();
    } catch (error) {
      lastError = error;
      const delay = initialDelay * 2 ** i;
      log(`Attempt ${i + 1} failed, retrying in ${delay}ms...`);
      await new Promise((resolve) => setTimeout(resolve, delay));
    }
  }

  throw lastError;
}

/**
 * Create browser context with common settings.
 * @param {Object} browser - Browser instance
 * @param {Object} options - Context options
 */
async function createContext(browser, options = {}) {
  const defaultOptions = {
    viewport: { width: 1280, height: 720 },
    userAgent: options.mobile
      ? "Mozilla/5.0 (iPhone; CPU iPhone OS 14_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.2 Mobile/15E148 Safari/604.1"
      : undefined,
    permissions: options.permissions || [],
    geolocation: options.geolocation,
    locale: options.locale || "en-US",
    timezoneId: options.timezoneId || "America/New_York",
  };

  return await browser.newContext(
    getContextOptionsWithHeaders({ ...defaultOptions, ...options }),
  );
}

function requestUrl(port) {
  return `http://localhost:${port}`;
}

async function probeHttpPort(http, port) {
  return await new Promise((resolve) => {
    const req = http.request(
      {
        hostname: "localhost",
        port,
        path: "/",
        method: "HEAD",
        timeout: 500,
      },
      (res) => {
        resolve(res.statusCode < 500);
      },
    );

    req.on("error", () => resolve(false));
    req.on("timeout", () => {
      req.destroy();
      resolve(false);
    });

    req.end();
  });
}

/**
 * Detect running dev servers on common ports.
 * @param {Array<number>} customPorts - Additional ports to check
 * @returns {Promise<Array>} Array of detected server URLs
 */
async function detectDevServers(customPorts = []) {
  const http = require("http");
  const commonPorts = [
    3000, 3001, 3002, 3030, 4173, 4200, 4321, 5000, 5173, 5174, 6006, 8000,
    8080, 9000, 1234,
  ];
  const allPorts = [...new Set([...commonPorts, ...customPorts])];
  const detectedServers = [];

  log("🔍 Checking for running dev servers...");

  for (const port of allPorts) {
    try {
      if (await probeHttpPort(http, port)) {
        detectedServers.push(requestUrl(port));
        log(`  ✅ Found server on port ${port}`);
      }
    } catch (_error) {
      // Port not available, continue.
    }
  }

  if (detectedServers.length === 0) {
    log("  ❌ No dev servers detected");
  }

  return detectedServers;
}

module.exports = {
  ensurePlaywrightReady,
  launchBrowser,
  createPage,
  waitForPageReady,
  waitForStablePage,
  waitForAnimationFrames,
  waitForStableBoundingBox,
  safeClick,
  safeType,
  extractTexts,
  takeScreenshot,
  authenticate,
  scrollPage,
  extractTableData,
  handleCookieBanner,
  retryWithBackoff,
  createContext,
  detectDevServers,
  getExtraHeadersFromEnv,
  getContextOptionsWithHeaders,
};

const { execFileSync } = require("child_process");
const fs = require("fs");
const os = require("os");
const path = require("path");

const SCRIPT_DIR = path.resolve(__dirname, "..");
const PLAYWRIGHT_VERSION = "1.63.0";

function log(options, ...parts) {
  if (!options?.quiet) console.error(...parts);
}

function cacheDirectory(options = {}) {
  return (
    options.cacheDir ||
    path.join(
      process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache"),
      "cc-thingz",
      "playwright",
      PLAYWRIGHT_VERSION,
    )
  );
}

function resolvePlaywright(options = {}) {
  const projectDir = options.projectDir || process.cwd();
  const candidates = [
    () => require.resolve("playwright", { paths: [projectDir] }),
    () =>
      require.resolve("playwright", {
        paths: [require.resolve("@playwright/test", { paths: [projectDir] })],
      }),
    () =>
      require.resolve(
        path.join(cacheDirectory(options), "node_modules", "playwright"),
      ),
  ];
  for (const resolve of candidates) {
    try {
      return resolve();
    } catch (error) {
      if (error.code !== "MODULE_NOT_FOUND") throw error;
    }
  }
  return null;
}

function isPlaywrightInstalled(options = {}) {
  return resolvePlaywright(options) !== null;
}

function ensurePlaywrightInstalled(options = {}) {
  if (isPlaywrightInstalled(options)) return;
  const cacheDir = cacheDirectory(options);
  fs.mkdirSync(cacheDir, { recursive: true });
  log(options, `Installing Playwright ${PLAYWRIGHT_VERSION} in ${cacheDir}`);
  execFileSync(
    "npm",
    [
      "install",
      "--prefix",
      cacheDir,
      "--no-save",
      "--package-lock=false",
      "--ignore-scripts",
      `playwright@${PLAYWRIGHT_VERSION}`,
    ],
    { cwd: cacheDir, stdio: options.quiet ? "ignore" : "inherit" },
  );
  if (!isPlaywrightInstalled(options))
    throw new Error("Playwright installation failed");
}

function loadPlaywright(options = {}) {
  ensurePlaywrightInstalled(options);
  return require(resolvePlaywright(options));
}

function ensureBrowserAvailable(browser, browserName, options = {}) {
  if (!fs.existsSync(browser.executablePath())) {
    const entry = resolvePlaywright(options);
    const cli = path.join(path.dirname(entry), "cli.js");
    throw new Error(
      `Playwright package is ready but ${browserName} is missing. Install it with: node ${JSON.stringify(cli)} install ${browserName}`,
    );
  }
}

function sandboxOptions() {
  return process.env.PLAYWRIGHT_SKILL_NO_SANDBOX === "1"
    ? {
        chromiumSandbox: false,
        args: ["--no-sandbox", "--disable-setuid-sandbox"],
      }
    : { chromiumSandbox: true, args: [] };
}

module.exports = {
  SCRIPT_DIR,
  PLAYWRIGHT_VERSION,
  cacheDirectory,
  resolvePlaywright,
  ensurePlaywrightInstalled,
  isPlaywrightInstalled,
  loadPlaywright,
  ensureBrowserAvailable,
  sandboxOptions,
  log,
};

const fs = require("fs");
const os = require("os");
const path = require("path");
const runtime = require("./runtime");

const DEFAULT_TITLE_SELECTOR = 'h1, h2, [role="heading"]';

function parseInteger(value, name, options = {}) {
  if (value === undefined || value === null || value === "") {
    if (Object.prototype.hasOwnProperty.call(options, "defaultValue")) {
      return options.defaultValue;
    }
    throw new Error(`${name} is required`);
  }

  const number = Number(value);
  const min = options.min;

  if (!Number.isInteger(number) || (min !== undefined && number < min)) {
    const suffix = min === undefined ? "" : ` >= ${min}`;
    throw new Error(`${name} must be an integer${suffix}`);
  }

  return number;
}

function parseViewport(value) {
  if (!value) {
    return { width: 1280, height: 720 };
  }

  if (typeof value === "object") {
    const width = parseInteger(value.width, "viewport.width", { min: 1 });
    const height = parseInteger(value.height, "viewport.height", { min: 1 });
    return { ...value, width, height };
  }

  const match = String(value).match(/^(\d+)x(\d+)$/i);
  if (!match) {
    throw new Error(
      `Invalid viewport '${value}'. Use WIDTHxHEIGHT, e.g. 1280x720.`,
    );
  }

  return {
    width: parseInteger(match[1], "viewport width", { min: 1 }),
    height: parseInteger(match[2], "viewport height", { min: 1 }),
  };
}

function sanitizeFilename(value) {
  return String(value)
    .replace(/^https?:\/\//, "")
    .replace(/[^a-z0-9._-]+/gi, "-")
    .replace(/^-+|-+$/g, "")
    .slice(0, 120);
}

function defaultScreenshotPath(url) {
  const filename = sanitizeFilename(url) || "screenshot";
  return path.join(os.tmpdir(), `playwright-${filename}.png`);
}

function resolveOutputPath(outputPath, fallbackUrl) {
  const target = outputPath || defaultScreenshotPath(fallbackUrl);
  return path.isAbsolute(target) ? target : path.resolve(process.cwd(), target);
}

function ensureParentDir(filePath) {
  fs.mkdirSync(path.dirname(filePath), { recursive: true });
}

function attachDiagnostics(page) {
  const consoleErrors = [];
  const networkFailures = [];
  const badResponses = [];

  page.on("console", (message) => {
    if (message.type() !== "error") {
      return;
    }

    consoleErrors.push({
      type: message.type(),
      text: message.text(),
      location: message.location(),
    });
  });

  page.on("requestfailed", (request) => {
    networkFailures.push({
      url: request.url(),
      method: request.method(),
      failure: request.failure()?.errorText || "unknown",
    });
  });

  page.on("response", (response) => {
    if (response.status() < 400) {
      return;
    }

    badResponses.push({
      url: response.url(),
      status: response.status(),
      statusText: response.statusText(),
    });
  });

  return { consoleErrors, networkFailures, badResponses };
}

async function firstVisibleText(page, selector) {
  if (!selector) {
    return "";
  }

  const locator = page.locator(selector).filter({ hasText: /\S/ }).first();

  try {
    const text = await locator.textContent({ timeout: 1500 });
    return text?.trim() || "";
  } catch (_error) {
    return "";
  }
}

async function extractTitle(page, titleSelector) {
  const selectorTitle = await firstVisibleText(
    page,
    titleSelector === undefined ? DEFAULT_TITLE_SELECTOR : titleSelector,
  );

  if (selectorTitle) {
    return selectorTitle;
  }

  return (await page.title()).trim();
}

function normalizeLaunchOptions(options) {
  const browserName = options.browser || "chromium";
  const headless = options.headed ? false : options.headless !== false;

  return {
    browserName,
    headless,
    ...(browserName === "chromium" ? runtime.sandboxOptions() : {}),
  };
}

async function captureUrl(options) {
  if (!options.url) {
    throw new Error("--url is required");
  }

  const quiet = Boolean(options.quiet);
  const playwright = runtime.loadPlaywright({ quiet });
  const helpers = require("./helpers");
  helpers.ensurePlaywrightReady({ quiet });
  const launch = normalizeLaunchOptions(options);
  const browserType = playwright[launch.browserName];

  if (!browserType) {
    throw new Error(`Invalid browser '${launch.browserName}'`);
  }

  runtime.ensureBrowserAvailable(browserType, launch.browserName);

  const timeout = parseInteger(options.timeout, "--timeout", {
    defaultValue: 30000,
    min: 0,
  });
  const animationFrames = parseInteger(
    options.animationFrames,
    "--animation-frames",
    { defaultValue: 2, min: 0 },
  );
  const viewport = parseViewport(options.viewport);
  const screenshotPath = resolveOutputPath(options.out, options.url);
  ensureParentDir(screenshotPath);

  const browser = await browserType.launch({
    headless: launch.headless,
    args: launch.args,
    chromiumSandbox: launch.chromiumSandbox,
  });

  try {
    const context = await browser.newContext(
      helpers.getContextOptionsWithHeaders({ viewport }),
    );
    const page = await context.newPage();
    page.setDefaultTimeout(timeout);
    const diagnostics = attachDiagnostics(page);

    await page.goto(options.url, {
      waitUntil: options.gotoWaitUntil || "domcontentloaded",
      timeout,
    });

    await helpers.waitForStablePage(page, {
      selector: options.selector,
      waitUntil: options.waitUntil || "domcontentloaded",
      timeout,
      animationFrames,
      stableBoundingBox: options.stableBoundingBox || false,
    });

    const title = await extractTitle(page, options.titleSelector);

    await page.screenshot({
      path: screenshotPath,
      fullPage: options.fullPage !== false,
    });

    return {
      url: options.url,
      title,
      screenshotPath,
      selector: options.selector || null,
      viewport,
      fullPage: options.fullPage !== false,
      browser: launch.browserName,
      headless: launch.headless,
      consoleErrors: diagnostics.consoleErrors,
      networkFailures: diagnostics.networkFailures,
      badResponses: diagnostics.badResponses,
    };
  } finally {
    await browser.close();
  }
}

function urlForIndex(template, index) {
  if (!template.includes("{n}")) {
    throw new Error("--url-template must include {n}");
  }
  return template.replaceAll("{n}", String(index));
}

async function captureSequence(options) {
  if (!options.urlTemplate) {
    throw new Error("--url-template is required");
  }

  const from = parseInteger(options.from, "--from");
  const to = parseInteger(options.to, "--to");
  const step = parseInteger(options.step, "--step", {
    defaultValue: from <= to ? 1 : -1,
  });

  if (step === 0) {
    throw new Error("--step must not be 0");
  }

  if ((from < to && step < 0) || (from > to && step > 0)) {
    throw new Error("--step direction must move from --from toward --to");
  }

  const outDir = path.resolve(
    options.outDir || path.join(os.tmpdir(), "playwright-screenshots"),
  );
  fs.mkdirSync(outDir, { recursive: true });

  const padWidth = Math.max(
    String(Math.abs(from)).length,
    String(Math.abs(to)).length,
    2,
  );
  const prefix = options.prefix || "screenshot-";
  const manifestPath = options.manifest
    ? path.resolve(options.manifest)
    : path.join(outDir, "manifest.json");

  const results = [];
  const indices = [];

  if (step > 0) {
    for (let index = from; index <= to; index += step) indices.push(index);
  } else {
    for (let index = from; index >= to; index += step) indices.push(index);
  }

  if (indices.length === 0) {
    throw new Error("screenshot sequence is empty");
  }

  for (const index of indices) {
    const url = urlForIndex(options.urlTemplate, index);
    const screenshotPath = path.join(
      outDir,
      `${prefix}${String(index).padStart(padWidth, "0")}.png`,
    );

    try {
      const result = await captureUrl({
        ...options,
        url,
        out: screenshotPath,
      });
      results.push({ index, ...result });
    } catch (error) {
      const failed = {
        index,
        url,
        screenshotPath,
        error: error.message,
      };
      results.push(failed);

      if (!options.continueOnError) {
        const partialManifest = {
          urlTemplate: options.urlTemplate,
          from,
          to,
          step,
          outDir,
          results,
        };
        ensureParentDir(manifestPath);
        fs.writeFileSync(
          manifestPath,
          JSON.stringify(partialManifest, null, 2),
        );
        throw error;
      }
    }
  }

  const manifest = {
    urlTemplate: options.urlTemplate,
    from,
    to,
    step,
    outDir,
    results,
  };

  ensureParentDir(manifestPath);
  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));

  return { manifestPath, ...manifest };
}

function writeManifest(manifestPath, data) {
  if (!manifestPath) {
    return;
  }

  const resolved = path.resolve(manifestPath);
  ensureParentDir(resolved);
  fs.writeFileSync(resolved, JSON.stringify(data, null, 2));
}

module.exports = {
  captureSequence,
  captureUrl,
  extractTitle,
  parseInteger,
  parseViewport,
  writeManifest,
};