/**
 * Built chunk artifact contract: each lib/client-<name>.js must, when
 * executed as a classic script, assign its factory to the plugin-owned
 * global registry (globalThis.__dshChunks__[<name>]), and the factory must
 * be callable with a require that resolves the platform externals — the
 * exact shape the loader (src/client/chunk-loader.ts) depends on. Reads the
 * built lib/ output, so run `pnpm build` first (like manifest-consistency).
 * A missing lib/ (fresh clone before the first build) skips the whole suite
 * instead of crashing on ENOENT.
 */
import { existsSync, readFileSync } from 'node:fs'
import { describe, expect, it } from 'vitest'
// Browser globals first: chunk bodies probe `self`/`document` at evaluation
// (xterm's UMD wrapper, CodeMirror's UA probe).
import './browser-globals.ts'
import { CHUNK_EXTERNALS } from '../src/client/chunk-loader.ts'

const g = globalThis as Record<string, unknown>

const CHUNKS = ['terminal', 'editor', 'mermaid']

/** All chunk artifacts present (tsdown emits the whole lib/ in one run). */
const chunksBuilt = CHUNKS.every(name => existsSync(`lib/client-${name}.js`))

if (!chunksBuilt) {
  console.warn('[chunk-artifact] lib/ chunk artifacts missing — run `pnpm build` first; skipping this suite')
}

describe.skipIf(!chunksBuilt)('built chunk artifacts', () => {
  it('each chunk assigns its global registry slot when executed as a script', () => {
    g.window = g // classic-script globals
    // mermaid's core hooks window.addEventListener('load') at module scope
    // (its startOnLoad wiring); the Node global lacks the API, so stub it
    // exactly like browser-globals.ts does for its window stub.
    if (typeof g.addEventListener !== 'function') g.addEventListener = () => {}
    if (typeof g.removeEventListener !== 'function') g.removeEventListener = () => {}
    for (const name of CHUNKS) {
      const code = readFileSync(`lib/client-${name}.js`, 'utf8')
      expect(() => new Function(code)(), name).not.toThrow()
      const registry = g.__dshChunks__ as Record<string, unknown>
      expect(typeof registry[name], name).toBe('function')
    }
  })

  it('each chunk factory materializes through a require over the platform externals', () => {
    const registry = g.__dshChunks__ as Record<string, unknown>
    const table = new Map<string, unknown>(CHUNK_EXTERNALS.map(spec => [spec, { spec }]))
    for (const name of CHUNKS) {
      const factory = registry[name] as (require: (spec: string) => unknown) => Record<string, unknown>
      expect(() => factory((spec) => {
        if (!table.has(spec)) throw new Error(`require("${spec}") missed the module table`)
        return table.get(spec)
      }), name).not.toThrow()
    }
  })
})