#!/usr/bin/env node
// SSR smoke check: boots the fixture SEO API and the built playground
// server, then checks each line of an expectations file.
//
//   node testing/smoke-ssr.mjs --output <.output dir> --fixtures <dir> --expect <file> [--no-site] [--site-file NAME] [--env KEY=VALUE]...
//
// Expectation grammar, one check per line ('#' starts a comment line):
//   STATUS PATH [contains=TEXT] [notcontains=TEXT] [count=TEXT:N] [type=PREFIX]
//               [header=NAME: VALUE] [noheader=NAME] [reqheader=NAME: VALUE]
//   report PATH       a POST /notfound for PATH reached the API by the end of the run
//   noreport PATH     no POST /notfound for PATH reached the API by the end of the run
//   resolves PATH N   the API has seen exactly N resolve calls for PATH so far
//                     (PATH * counts every resolve call)
//   apicalls N        the API has seen exactly N requests so far
//   routereport N [has=PATH]... [lacks=PATH]...
//                     exactly N route reports (POST /registry/routes) reached
//                     the API by the end of the run, each with the token;
//                     every has= path is in the last one, no lacks= path is
//   log TEXT:N        the server's output holds exactly N occurrences of TEXT
//                     (waits up to 3 s for them; N after the last colon)
// A value runs until the next ` contains=`, ` notcontains=`, ` count=`,
// ` type=`, ` header=`, ` noheader=`, ` reqheader=` or the end of the line, so
// it may contain spaces. Every option may repeat on a line and every
// occurrence applies. count= wants exactly N occurrences of TEXT in the body
// (N is the number after the last colon). header= wants the response header
// NAME to equal VALUE (both trimmed); noheader= wants it absent; reqheader=
// adds a request header (a crafted Host or X-Forwarded-Host). The resolves
// and apicalls lines are checked in file order, between the requests; the
// report lines after the last request.
//
// Requests are plain GETs that do not follow redirects and carry
// `X-Forwarded-For: 203.0.113.7` and `Accept: text/html` (as a browser does,
// so errors render as pages); when the API saw any request, at least one
// must have carried that address (the SSR fetches forward the visitor's
// x-forwarded-for). The server is started with the fixture's 404 token and
// the fixture API as NUXT_SEO_API_BASE; --env overrides either. --no-site
// makes the fixture API answer /site (and the route report) with 404, as a
// backend before SEO v0.2.0 does; --site-file answers /site with another
// file of <fixtures>/seo.
//
// The same approach as vue-faq-layer's testing/smoke-ssr.mjs; plain .mjs
// with JSDoc types so it runs from node_modules unchanged.

import { readFileSync } from 'node:fs'
import { resolve } from 'node:path'
import { FIXTURE_NOTFOUND_TOKEN, startFixtureApi } from './fixture-api.mjs'
import { startNuxtServer } from './nuxt-server.mjs'

const VISITOR_IP = '203.0.113.7'
const API_PREFIX = '/_seo/api/v1'
const OPTION_KEYS = ['contains', 'notcontains', 'count', 'type', 'header', 'noheader', 'reqheader']

/** @param {string[]} argv */
function parseArgs(argv) {
  /** @type {{ output?: string, fixtures?: string, expect?: string, site: boolean, siteFile?: string, env: Record<string, string> }} */
  const out = { env: {}, site: true }
  for (let i = 0; i < argv.length; i++) {
    const arg = argv[i]
    const next = () => {
      const v = argv[++i]
      if (v === undefined) throw new Error(`${arg} needs a value`)
      return v
    }
    if (arg === '--output') out.output = next()
    else if (arg === '--fixtures') out.fixtures = next()
    else if (arg === '--expect') out.expect = next()
    else if (arg === '--no-site') out.site = false
    else if (arg === '--site-file') out.siteFile = next()
    else if (arg === '--env') {
      const kv = next()
      const eq = kv.indexOf('=')
      if (eq < 1) throw new Error(`--env expects KEY=VALUE, got ${kv}`)
      out.env[kv.slice(0, eq)] = kv.slice(eq + 1)
    } else throw new Error(`unknown argument ${arg}`)
  }
  if (!out.output || !out.fixtures || !out.expect) throw new Error('--output, --fixtures and --expect are required')
  return /** @type {{ output: string, fixtures: string, expect: string, site: boolean, siteFile?: string, env: Record<string, string> }} */ (out)
}

/**
 * @typedef {{ status: number, path: string, options: Array<{ key: string, value: string }> }} ExpectCheck
 */

/**
 * @param {string} line
 * @returns {ExpectCheck}
 */
export function parseExpectLine(line) {
  const m = /^(\d{3})\s+(\S+)(.*)$/.exec(line.trim())
  if (!m) throw new Error('expected "STATUS PATH [options]"')
  const rest = m[3]
  const re = new RegExp(`\\s(${OPTION_KEYS.join('|')})=`, 'g')
  /** @type {Array<{ key: string, start: number, valueStart: number }>} */
  const marks = []
  let hit
  while ((hit = re.exec(rest)) !== null) marks.push({ key: hit[1], start: hit.index, valueStart: re.lastIndex })
  if (marks.length === 0 && rest.trim() !== '') throw new Error(`unknown option text "${rest.trim()}"`)
  if (marks.length > 0 && rest.slice(0, marks[0].start).trim() !== '') {
    throw new Error(`unknown option text "${rest.slice(0, marks[0].start).trim()}"`)
  }
  const options = marks.map((mark, i) => {
    const end = i + 1 < marks.length ? marks[i + 1].start : rest.length
    return { key: mark.key, value: rest.slice(mark.valueStart, end).trim() }
  })
  return { status: Number(m[1]), path: m[2], options }
}

/** NAME: VALUE split at the first colon. @param {string} value */
function nameValue(value) {
  const colon = value.indexOf(':')
  return colon > 0 ? { name: value.slice(0, colon).trim(), value: value.slice(colon + 1).trim() } : { name: value.trim(), value: '' }
}

/** @param {string} body @param {string} text */
function occurrences(body, text) {
  if (text === '') return 0
  let n = 0
  for (let at = body.indexOf(text); at !== -1; at = body.indexOf(text, at + text.length)) n++
  return n
}

/**
 * The failures of one response against its check.
 * @param {ExpectCheck} check @param {{ status: number, headers: Headers, body: string }} res
 * @returns {string[]}
 */
export function checkResponse(check, res) {
  if (res.status !== check.status) return [`status ${res.status}, want ${check.status}`]
  /** @type {string[]} */
  const out = []
  const type = res.headers.get('content-type') ?? ''
  for (const { key, value } of check.options) {
    if (key === 'contains' && !res.body.includes(value)) out.push(`body lacks "${value}"`)
    else if (key === 'notcontains' && res.body.includes(value)) out.push(`body contains "${value}"`)
    else if (key === 'count') {
      const colon = value.lastIndexOf(':')
      const want = colon > 0 ? Number(value.slice(colon + 1)) : NaN
      if (!Number.isInteger(want)) {
        out.push(`count=${value}: want TEXT:N`)
        continue
      }
      const text = value.slice(0, colon)
      const got = occurrences(res.body, text)
      if (got !== want) out.push(`body has ${got} of "${text}", want ${want}`)
    } else if (key === 'type' && !type.startsWith(value)) out.push(`content-type "${type}", want prefix "${value}"`)
    else if (key === 'header') {
      const h = nameValue(value)
      const got = res.headers.get(h.name)
      if (got === null || got.trim() !== h.value) out.push(`header ${h.name} is ${JSON.stringify(got)}, want "${h.value}"`)
    } else if (key === 'noheader') {
      const got = res.headers.get(value)
      if (got !== null) out.push(`header ${value} is ${JSON.stringify(got)}, want none`)
    }
  }
  return out
}

async function main() {
  const args = parseArgs(process.argv.slice(2))
  const lines = readFileSync(resolve(args.expect), 'utf8')
    .split('\n')
    .map((l) => l.trim())
    .filter((l) => l !== '' && !l.startsWith('#'))

  const reports = lines.filter((l) => l.startsWith('report ')).map((l) => l.slice('report '.length).trim())
  const noreports = lines.filter((l) => l.startsWith('noreport ')).map((l) => l.slice('noreport '.length).trim())
  const routeReports = lines.filter((l) => l.startsWith('routereport '))
  const steps = lines.filter((l) => !l.startsWith('report ') && !l.startsWith('noreport ') && !l.startsWith('routereport '))
  const api = await startFixtureApi({ dir: resolve(args.fixtures), site: args.site, ...(args.siteFile ? { siteFile: args.siteFile } : {}) })
  /** @type {{ url: string, close: () => Promise<void>, output: () => string } | null} */
  let nuxt = null
  const failures = /** @type {string[]} */ ([])
  try {
    nuxt = await startNuxtServer({
      outputDir: args.output,
      apiBase: `${api.url}${API_PREFIX}`,
      env: { NUXT_SEO_NOTFOUND_TOKEN: FIXTURE_NOTFOUND_TOKEN, ...args.env },
    })
    for (const line of steps) {
      const resolves = /^resolves\s+(\S+)\s+(\d+)$/.exec(line)
      if (resolves) {
        const got = api.resolveCount(resolves[1] === '*' ? undefined : resolves[1])
        if (got !== Number(resolves[2])) failures.push(`${line}: the API saw ${got} resolve calls`)
        continue
      }
      const log = /^log\s+(.+):(\d+)$/.exec(line)
      if (log) {
        const want = Number(log[2])
        const seen = () => occurrences(nuxt?.output() ?? '', log[1])
        for (let i = 0; i < 30 && seen() < want; i++) await new Promise((r) => setTimeout(r, 100))
        if (want === 0) await new Promise((r) => setTimeout(r, 500))
        if (seen() !== want) failures.push(`${line}: the server output has ${seen()}\n${nuxt?.output() ?? ''}`)
        continue
      }
      const calls = /^apicalls\s+(\d+)$/.exec(line)
      if (calls) {
        if (api.requests.length !== Number(calls[1])) failures.push(`${line}: the API saw ${api.requests.length} requests (${api.requests.map((r) => `${r.method} ${r.url}`).join(', ')})`)
        continue
      }
      let check
      try {
        check = parseExpectLine(line)
      } catch (err) {
        failures.push(`${line}: ${/** @type {Error} */ (err).message}`)
        continue
      }
      /** @type {Record<string, string>} */
      const headers = { 'X-Forwarded-For': VISITOR_IP, Accept: 'text/html' }
      for (const o of check.options) {
        if (o.key !== 'reqheader') continue
        const h = nameValue(o.value)
        headers[h.name] = h.value
      }
      let res
      try {
        res = await fetch(nuxt.url + check.path, { redirect: 'manual', headers, signal: AbortSignal.timeout(20000) })
      } catch (err) {
        failures.push(`${line}: request failed: ${/** @type {Error} */ (err).message}`)
        continue
      }
      const body = await res.text()
      for (const f of checkResponse(check, { status: res.status, headers: res.headers, body })) failures.push(`${line}: ${f}`)
    }
    // The 404 reports go out after the response; give them a moment.
    const reported = () => api.requests.filter((r) => r.method === 'POST' && r.url.endsWith('/notfound')).map((r) => /** @type {any} */ (r.body)?.url)
    for (let i = 0; i < 20 && reports.some((p) => !reported().includes(p)); i++) await new Promise((r) => setTimeout(r, 100))
    if (noreports.length > 0) await new Promise((r) => setTimeout(r, 500))
    for (const p of reports) {
      if (!reported().includes(p)) failures.push(`report ${p}: no 404 report reached the API (got ${JSON.stringify(reported())})`)
      const n = reported().filter((u) => u === p).length
      if (n > 1) failures.push(`report ${p}: reported ${n} times, want once per request`)
    }
    for (const p of noreports) {
      if (reported().includes(p)) failures.push(`noreport ${p}: a 404 report reached the API`)
    }
    const routePosts = () => api.requests.filter((r) => r.method === 'POST' && r.url.endsWith('/registry/routes'))
    for (const line of routeReports) {
      const m = /^routereport\s+(\d+)((?:\s+(?:has|lacks)=\S+)*)$/.exec(line)
      if (!m) {
        failures.push(`${line}: expected "routereport N [has=PATH]... [lacks=PATH]..."`)
        continue
      }
      const want = Number(m[1])
      for (let i = 0; i < 20 && routePosts().length < want; i++) await new Promise((r) => setTimeout(r, 100))
      if (want === 0) await new Promise((r) => setTimeout(r, 500))
      const posts = routePosts()
      if (posts.length !== want) failures.push(`${line}: the API saw ${posts.length} route reports`)
      if (posts.some((r) => r.authorization !== `Bearer ${FIXTURE_NOTFOUND_TOKEN}`)) failures.push(`${line}: a route report carried the wrong token`)
      const last = /** @type {any} */ (posts[posts.length - 1]?.body)?.routes ?? []
      for (const opt of (m[2] ?? '').trim().split(/\s+/).filter(Boolean)) {
        const [key, path] = [opt.slice(0, opt.indexOf('=')), opt.slice(opt.indexOf('=') + 1)]
        if (key === 'has' && !last.includes(path)) failures.push(`${line}: ${path} is not in the report ${JSON.stringify(last)}`)
        if (key === 'lacks' && last.includes(path)) failures.push(`${line}: ${path} is in the report ${JSON.stringify(last)}`)
      }
    }
    if (api.requests.some((r) => r.url.endsWith('/notfound') && r.authorization !== `Bearer ${FIXTURE_NOTFOUND_TOKEN}`)) {
      failures.push('a 404 report carried the wrong token')
    }
    if (api.requests.length > 0 && !api.requests.some((r) => (r.xff ?? '').includes(VISITOR_IP))) {
      failures.push('x-forwarded-for: the SSR fetches did not forward the visitor address')
    }
  } finally {
    if (nuxt) await nuxt.close()
    await api.close()
  }

  if (failures.length > 0) {
    for (const f of failures) console.error(`smoke-ssr: FAIL ${f}`)
    process.exit(1)
  }
  console.log(`smoke-ssr: ok (${lines.length} checks, ${args.expect})`)
}

main().catch((err) => {
  console.error(`smoke-ssr: FAIL setup: ${err instanceof Error ? err.message : String(err)}`)
  process.exit(1)
})