#!/usr/bin/env node

/**
 * Lighthouse Testing Script
 *
 * This script builds the production bundle, starts the server, and runs Lighthouse tests.
 * Usage:
 *   npm run lighthouse:build  - Test production build
 *   npm run lighthouse:dev    - Test dev server (less accurate)
 */

const { execSync, spawn } = require("child_process")
const chromeLauncher = require("chrome-launcher")
const path = require("path")

// Dynamic import for lighthouse (ES module)
let lighthouse
async function getLighthouse() {
  if (!lighthouse) {
    const lighthouseModule = await import("lighthouse")
    lighthouse = lighthouseModule.default || lighthouseModule
  }
  return lighthouse
}

const PORT = 3000
const BASE_URL = `http://localhost:${PORT}`
const TEST_PAGES = ["/", "/vending-machines", "/services", "/service-areas"]

// Check if we should test dev server
const isDev = process.argv.includes("--dev")

async function buildProduction() {
  if (isDev) {
    console.log("⚠️  Testing dev server (less accurate for Lighthouse scores)")
    return
  }

  console.log("📦 Building production bundle...")
  try {
    execSync("pnpm run build", {
      stdio: "inherit",
      cwd: path.join(__dirname, ".."),
    })
    console.log("✅ Build complete\n")
  } catch (error) {
    console.error("❌ Build failed:", error.message)
    process.exit(1)
  }
}

async function startServer() {
  console.log(
    `🚀 Starting ${isDev ? "dev" : "production"} server on port ${PORT}...`
  )

  const command = isDev ? "pnpm run dev" : "pnpm run start"
  const serverProcess = spawn(command, [], {
    shell: true,
    stdio: "pipe",
    cwd: path.join(__dirname, ".."),
  })

  // Wait for server to be ready
  await new Promise((resolve, reject) => {
    const timeout = setTimeout(() => {
      serverProcess.kill()
      reject(new Error("Server startup timeout"))
    }, 60000)

    serverProcess.stdout.on("data", (data) => {
      const output = data.toString()
      if (
        output.includes("ready") ||
        output.includes("Local:") ||
        output.includes("started server")
      ) {
        clearTimeout(timeout)
        // Give server a moment to fully start
        setTimeout(resolve, 2000)
      }
    })

    serverProcess.stderr.on("data", (data) => {
      const output = data.toString()
      if (
        output.includes("ready") ||
        output.includes("Local:") ||
        output.includes("started server")
      ) {
        clearTimeout(timeout)
        setTimeout(resolve, 2000)
      }
    })
  })

  console.log("✅ Server ready\n")
  return serverProcess
}

async function runLighthouse(url, options = {}) {
  const deviceType = options.formFactor || "desktop"
  console.log(`🔍 Running Lighthouse on ${url} (${deviceType})...`)

  const lighthouseFn = await getLighthouse()
  const chrome = await chromeLauncher.launch({ chromeFlags: ["--headless"] })
  const runnerResult = await lighthouseFn(url, {
    port: chrome.port,
    output: "json",
    onlyCategories: ["performance", "accessibility", "best-practices", "seo"],
    ...options,
  })

  await chrome.kill()

  const scores = {
    performance: Math.round(
      runnerResult.lhr.categories.performance.score * 100
    ),
    accessibility: Math.round(
      runnerResult.lhr.categories.accessibility.score * 100
    ),
    "best-practices": Math.round(
      runnerResult.lhr.categories["best-practices"].score * 100
    ),
    seo: Math.round(runnerResult.lhr.categories.seo.score * 100),
  }

  const metrics = {
    fcp: runnerResult.lhr.audits["first-contentful-paint"].numericValue,
    lcp: runnerResult.lhr.audits["largest-contentful-paint"].numericValue,
    cls: runnerResult.lhr.audits["cumulative-layout-shift"].numericValue,
    tbt: runnerResult.lhr.audits["total-blocking-time"].numericValue,
    si: runnerResult.lhr.audits["speed-index"].numericValue,
  }

  // Get failing audits for debugging
  const failingAudits = Object.values(runnerResult.lhr.audits)
    .filter((audit) => audit.score !== null && audit.score < 1)
    .map((audit) => ({
      id: audit.id,
      title: audit.title,
      score: audit.score,
      displayValue: audit.displayValue,
    }))
    .sort((a, b) => (a.score || 0) - (b.score || 0))

  return { scores, metrics, lhr: runnerResult.lhr, deviceType, failingAudits }
}

async function testPages() {
  const results = []

  // Test desktop first
  console.log("\n" + "=".repeat(60))
  console.log("🖥️  TESTING DESKTOP")
  console.log("=".repeat(60) + "\n")

  for (const page of TEST_PAGES) {
    const url = `${BASE_URL}${page}`
    try {
      const result = await runLighthouse(url, {
        formFactor: "desktop",
        throttling: {
          rttMs: 40,
          throughputKbps: 10 * 1024,
          cpuSlowdownMultiplier: 1,
        },
        screenEmulation: {
          mobile: false,
          width: 1350,
          height: 940,
          deviceScaleFactor: 1,
        },
      })
      results.push({ page, ...result, device: "desktop" })

      console.log(`\n📊 Desktop Results for ${page}:`)
      console.log(`   Performance: ${result.scores.performance}/100`)
      console.log(`   Accessibility: ${result.scores.accessibility}/100`)
      console.log(`   Best Practices: ${result.scores["best-practices"]}/100`)
      console.log(`   SEO: ${result.scores.seo}/100`)
      console.log(`   FCP: ${result.metrics.fcp.toFixed(0)}ms`)
      console.log(`   LCP: ${result.metrics.lcp.toFixed(0)}ms`)
      console.log(`   CLS: ${result.metrics.cls.toFixed(3)}`)
      console.log(`   TBT: ${result.metrics.tbt.toFixed(0)}ms`)
      console.log(`   SI: ${result.metrics.si.toFixed(0)}ms`)

      // Show top failing audits if scores aren't 100%
      if (
        result.scores.performance < 100 ||
        result.scores.accessibility < 100 ||
        result.scores["best-practices"] < 100 ||
        result.scores.seo < 100
      ) {
        const topFailures = result.failingAudits.slice(0, 5)
        if (topFailures.length > 0) {
          console.log(`   Top Issues:`)
          topFailures.forEach((audit) => {
            console.log(
              `     - ${audit.title} (${(audit.score * 100).toFixed(0)}%)`
            )
          })
        }
      }
      console.log()
    } catch (error) {
      console.error(`❌ Failed to test ${page} (desktop):`, error.message)
      results.push({ page, error: error.message, device: "desktop" })
    }
  }

  // Test mobile
  console.log("\n" + "=".repeat(60))
  console.log("📱 TESTING MOBILE")
  console.log("=".repeat(60) + "\n")

  for (const page of TEST_PAGES) {
    const url = `${BASE_URL}${page}`
    try {
      const result = await runLighthouse(url, {
        formFactor: "mobile",
        throttling: {
          rttMs: 150,
          throughputKbps: 1.6 * 1024,
          cpuSlowdownMultiplier: 4,
        },
        screenEmulation: {
          mobile: true,
          width: 412,
          height: 823,
          deviceScaleFactor: 2.625,
        },
      })
      results.push({ page, ...result, device: "mobile" })

      console.log(`\n📊 Mobile Results for ${page}:`)
      console.log(`   Performance: ${result.scores.performance}/100`)
      console.log(`   Accessibility: ${result.scores.accessibility}/100`)
      console.log(`   Best Practices: ${result.scores["best-practices"]}/100`)
      console.log(`   SEO: ${result.scores.seo}/100`)
      console.log(`   FCP: ${result.metrics.fcp.toFixed(0)}ms`)
      console.log(`   LCP: ${result.metrics.lcp.toFixed(0)}ms`)
      console.log(`   CLS: ${result.metrics.cls.toFixed(3)}`)
      console.log(`   TBT: ${result.metrics.tbt.toFixed(0)}ms`)
      console.log(`   SI: ${result.metrics.si.toFixed(0)}ms`)

      // Show top failing audits if scores aren't 100%
      if (
        result.scores.performance < 100 ||
        result.scores.accessibility < 100 ||
        result.scores["best-practices"] < 100 ||
        result.scores.seo < 100
      ) {
        const topFailures = result.failingAudits.slice(0, 5)
        if (topFailures.length > 0) {
          console.log(`   Top Issues:`)
          topFailures.forEach((audit) => {
            console.log(
              `     - ${audit.title} (${(audit.score * 100).toFixed(0)}%)`
            )
          })
        }
      }
      console.log()
    } catch (error) {
      console.error(`❌ Failed to test ${page} (mobile):`, error.message)
      results.push({ page, error: error.message, device: "mobile" })
    }
  }

  return results
}

function checkScores(results) {
  console.log("\n" + "=".repeat(60))
  console.log("📈 FINAL SCORES SUMMARY")
  console.log("=".repeat(60) + "\n")

  let allPassed = true
  const minScore = 100

  // Group results by device
  const desktopResults = results.filter((r) => r.device === "desktop")
  const mobileResults = results.filter((r) => r.device === "mobile")

  console.log("🖥️  DESKTOP RESULTS:\n")
  for (const result of desktopResults) {
    if (result.error) {
      console.log(`❌ ${result.page}: ERROR - ${result.error}\n`)
      allPassed = false
      continue
    }

    const { scores } = result
    const passed =
      scores.performance >= minScore &&
      scores.accessibility >= minScore &&
      scores["best-practices"] >= minScore &&
      scores.seo >= minScore

    if (passed) {
      console.log(`✅ ${result.page}: All scores at 100%`)
    } else {
      console.log(`❌ ${result.page}:`)
      if (scores.performance < minScore)
        console.log(`   Performance: ${scores.performance}/100`)
      if (scores.accessibility < minScore)
        console.log(`   Accessibility: ${scores.accessibility}/100`)
      if (scores["best-practices"] < minScore)
        console.log(`   Best Practices: ${scores["best-practices"]}/100`)
      if (scores.seo < minScore) console.log(`   SEO: ${scores.seo}/100`)
      allPassed = false
    }
    console.log()
  }

  console.log("\n📱 MOBILE RESULTS:\n")
  for (const result of mobileResults) {
    if (result.error) {
      console.log(`❌ ${result.page}: ERROR - ${result.error}\n`)
      allPassed = false
      continue
    }

    const { scores } = result
    const passed =
      scores.performance >= minScore &&
      scores.accessibility >= minScore &&
      scores["best-practices"] >= minScore &&
      scores.seo >= minScore

    if (passed) {
      console.log(`✅ ${result.page}: All scores at 100%`)
    } else {
      console.log(`❌ ${result.page}:`)
      if (scores.performance < minScore)
        console.log(`   Performance: ${scores.performance}/100`)
      if (scores.accessibility < minScore)
        console.log(`   Accessibility: ${scores.accessibility}/100`)
      if (scores["best-practices"] < minScore)
        console.log(`   Best Practices: ${scores["best-practices"]}/100`)
      if (scores.seo < minScore) console.log(`   SEO: ${scores.seo}/100`)
      allPassed = false
    }
    console.log()
  }

  if (allPassed) {
    console.log(
      "🎉 All pages passed with 100% scores on both desktop and mobile!\n"
    )
  } else {
    console.log(
      "⚠️  Some pages did not achieve 100% scores. Review the results above.\n"
    )
    process.exit(1)
  }
}

async function main() {
  try {
    await buildProduction()
    const serverProcess = await startServer()

    try {
      const results = await testPages()
      checkScores(results)
    } finally {
      console.log("🛑 Stopping server...")
      serverProcess.kill()
    }
  } catch (error) {
    console.error("❌ Error:", error.message)
    process.exit(1)
  }
}

main()