#!/usr/bin/env node
/**
 * embed-smoke.mjs — prove EVERY map embeds: load each generated profile page
 * headless and assert its custom element actually mounts.
 *
 * WHY: "embeddability works on all the maps" is the product promise. The build
 * guards prove the files exist; THIS proves each page boots — element defined,
 * shadow DOM populated, no ProfileLoader error card, and (for map profiles) a
 * WebGL canvas present.
 *
 * HOW: reads public/doxa-maps/manifest.json (the same registry partners use),
 * serves public/ itself if nothing is on --port, and drives Playwright
 * Chromium with SwiftShader software WebGL — CI boxes rarely have a GPU. (The
 * posters pipeline stays Firefox-only; this is a headless VERIFICATION harness,
 * not a rendering pipeline.)
 *
 * Usage:  node internal/embed-smoke.mjs [--port 4177] [--grep <substr>]
 * Exit:   0 all pass · 1 any fail (list printed)
 */
import { createServer } from 'node:http'
import { readFileSync, existsSync, statSync, createReadStream } from 'node:fs'
import { resolve, join, extname } from 'node:path'
import { fileURLToPath } from 'node:url'
import { chromium } from './lib/playwright-guarded.mjs'
import { TREE_NAME } from './_tree-name.mjs'

const __dirname = fileURLToPath(new URL('.', import.meta.url))
const PUB = resolve(__dirname, '..', 'public')
const args = process.argv.slice(2)
const argOf = (k, d) => { const i = args.indexOf(k); return i >= 0 ? args[i + 1] : d }
const PORT = Number(argOf('--port', 4177))
const GREP = argOf('--grep', '')

// ── tiny static server (no deps; mime enough for the pages) ─────────────────
const MIME = { '.html': 'text/html', '.js': 'text/javascript', '.mjs': 'text/javascript',
  '.css': 'text/css', '.json': 'application/json', '.geojson': 'application/geo+json',
  '.png': 'image/png', '.webp': 'image/webp', '.svg': 'image/svg+xml', '.csv': 'text/csv' }
const server = createServer((req, res) => {
  try {
    let p = decodeURIComponent(new URL(req.url, 'http://x').pathname)
    if (p.endsWith('/')) p += 'index.html'
    const f = join(PUB, p)
    if (!f.startsWith(PUB) || !existsSync(f) || !statSync(f).isFile()) { res.writeHead(404); return res.end() }
    res.writeHead(200, { 'content-type': MIME[extname(f)] || 'application/octet-stream' })
    createReadStream(f).pipe(res)
  } catch { res.writeHead(500); res.end() }
})

// ── the page list: every profile page in the manifest ───────────────────────
const manifest = JSON.parse(readFileSync(join(PUB, TREE_NAME, 'manifest.json'), 'utf8'))
const targets = []
for (const b of manifest.bundles) for (const p of b.profiles) {
  // iframeUrl is ./-relative to the tree root
  const url = p.iframeUrl.replace(/^\.\//, `/${TREE_NAME}/`)
  targets.push({ bundle: b.bundle, profile: p.profile, element: p.element, url })
  // Preconfigured instances are embeddable pages too — verify them the same way.
  for (const inst of (p.instances || [])) {
    targets.push({ bundle: b.bundle, profile: `${p.profile}/${inst.id}`, element: inst.element || p.element,
      url: inst.iframeUrl.replace(/^\.\//, `/${TREE_NAME}/`) })
  }
}
const list = GREP ? targets.filter(t => (t.bundle + '/' + t.profile).includes(GREP)) : targets

await new Promise(r => server.listen(PORT, '127.0.0.1', r))
console.log(`[embed-smoke] serving ${PUB} on :${PORT} — ${list.length} profile page(s)`)

const browser = await chromium.launch({ args: ['--enable-unsafe-swiftshader', '--use-gl=angle', '--use-angle=swiftshader'] })

// MAPBOX TOKEN — without it, EVERY map profile fails the mount assertion below and this
// gate reports a wall of "mount timeout" that looks like 13 broken plugins. It is not:
// measured 2026-09-21, my-upg-100-list/upg-100-list mounts at 1440x900 with
// "195 polys · 27/27 zones · 2107 pins" the moment a token is supplied. The same
// omission was fixed in verify-map-paint.mjs earlier; this script never had the wiring.
//
// BOTH channels are required and they are not interchangeable (measured):
//   ?tk=          reaches only the TOP-LEVEL element's profile-config
//   window.MAP_TOKEN   is what NESTED children read
// A composite profile mounts with ?tk= alone but its children stay blank, so set both.
//
// No token is NOT a failure — the run degrades to DOM-only coverage and says so, rather
// than reporting map profiles as broken. Get one with:
//   MAPBOX_TOKEN=$(curl -s -A "Mozilla/5.0" https://doxa.life/api/maps/token \
//     | python3 -c "import json,sys;print(json.load(sys.stdin)['token'])")
const TOKEN = process.env.MAPBOX_TOKEN || ''
if (!TOKEN) {
  console.log('[embed-smoke] NO MAPBOX_TOKEN — map profiles cannot mount; expect them to time out.')
  console.log('[embed-smoke] Set MAPBOX_TOKEN for full coverage (see the comment in this file).')
}

const results = []
for (const t of list) {
  const ctx = await browser.newContext({ viewport: { width: 1100, height: 750 } })
  const page = await ctx.newPage()
  if (TOKEN) await page.addInitScript(tk => { window.MAP_TOKEN = tk }, TOKEN)
  const errors = []
  page.on('pageerror', e => errors.push(String(e).slice(0, 160)))
  const r = { ...t, ok: false, why: '' }
  try {
    const sep = t.url.includes('?') ? '&' : '?'
    const url = `http://127.0.0.1:${PORT}${t.url}${TOKEN ? `${sep}tk=${TOKEN}` : ''}`
    await page.goto(url, { waitUntil: 'load', timeout: 30000 })
    // give the element time to define + mount + (maybe) paint a canvas
    await page.waitForFunction((tag) => {
      const el = document.querySelector(tag)
      return el && el.shadowRoot && el.shadowRoot.childElementCount > 0
    }, t.element, { timeout: 25000 })
    await page.waitForTimeout(4000)
    // ★ THE NODE COUNT IS A MOUNT SIGNAL, NOT A QUALITY SIGNAL — do not read it as "how much
    // rendered". This counts ONE shadow level, so a composite that nests its children BY TAG (the
    // stack-demo element/src contract, used by research-map-plus-grid to avoid bypassing the child
    // bundle's own index.js) reports only its wrapper: 12 nodes, no canvas, while a recursive walk
    // of the same page finds 518 nodes, 1 canvas, both children present and 13,867px of content.
    // That reads as a broken composite beside dashboard-plus-grid's 1,499, and it is not one —
    // measured 2026-09-23 after chasing it as a defect. Shadow DOM does not pierce; a single-level
    // querySelectorAll cannot see a tag-composed child. The `< 5` bar below is still the right
    // assertion, because it catches a mount that produced NOTHING, which is what this gate is for.
    const verdict = await page.evaluate((tag) => {
      const el = document.querySelector(tag)
      const sr = el.shadowRoot
      return {
        errorCard: !!sr.querySelector('.profile-error'),
        canvas: !!sr.querySelector('canvas'),
        nodes: sr.querySelectorAll('*').length,
      }
    }, t.element)
    if (verdict.errorCard) r.why = 'ProfileLoader error card shown'
    else if (verdict.nodes < 5) r.why = `shadow DOM nearly empty (${verdict.nodes} nodes)`
    else { r.ok = true; r.why = `${verdict.nodes} nodes${verdict.canvas ? ' + canvas' : ' (no canvas — DOM profile)'}` }
  } catch (e) {
    // ★ DO NOT COLLAPSE EVERY REJECTION INTO "mount timeout" — that is a DIAGNOSIS, and it was
    // the WRONG one. A malformed @element in the manifest made querySelector throw a SyntaxError;
    // reported as "mount timeout", it accused big-picture (tab-1 of the cap-5 SPA) of being a
    // broken plugin for as long as this suite has existed. The plugin was fine; the SELECTOR was
    // invalid. Name what actually happened and let the reader diagnose.
    const msg = String(e.message || e)
    if (/SyntaxError|is not a valid selector|failed to execute 'queryselector'/i.test(msg)) {
      r.why = `INVALID SELECTOR — @element is not a bare tag: ${JSON.stringify(t.element)} ` +
              '(fix the @element JSDoc in the bundle\'s root .vue; it is copied verbatim into manifest.json)'
    } else if (/Timeout|exceeded/i.test(msg)) {
      r.why = 'mount timeout / ' + msg.slice(0, 100)
    } else {
      r.why = 'error / ' + msg.slice(0, 100)
    }
  }
  if (errors.length && r.ok) r.why += ` · ${errors.length} pageerror(s): ${errors[0]}`
  results.push(r)
  console.log(`  ${r.ok ? '✓' : '✗'} ${t.bundle}/${t.profile} <${t.element}> — ${r.why}`)
  await ctx.close()
}
await browser.close(); server.close()

const failed = results.filter(r => !r.ok)
console.log(`\n[embed-smoke] ${results.length - failed.length}/${results.length} pages mount cleanly`)
if (failed.length) { console.log('FAILED:'); failed.forEach(f => console.log(`  ✗ ${f.bundle}/${f.profile} — ${f.why}`)); process.exit(1) }