/**
 * Empirical Stress-Testing Harness for Scene Object Rendering Dispatch
 * Milestone 1 (R1): 场景物件与窗户透光加色混合支持
 *
 * Ground Truth Parity: Diablo II v1.13c
 * Playbook: solution_stress_testing (SKILL.md)
 * Archetype: EMPIRICAL CHALLENGER
 */

import fs from 'node:fs'
import path from 'node:path'
import {
  ADDITIVE_OBJECT_TOKENS,
  PERSISTENT_ILLUMINATION_TOKENS,
  computeObjectPhaseOffsetMs,
  type ObjectDrawable,
} from '../src/scene/act-scene.ts'
import { ADDITIVE_OBJECT_TOKENS as GAME_ADDITIVE_TOKENS } from '../src/game/objects.ts'

// Assert token set alignment between game/objects and scene/act-scene
if (ADDITIVE_OBJECT_TOKENS !== GAME_ADDITIVE_TOKENS) {
  throw new Error('ADDITIVE_OBJECT_TOKENS re-export mismatch in act-scene.ts!')
}

// -----------------------------------------------------------------------------
// TYPES & MOCK INFRASTRUCTURE
// -----------------------------------------------------------------------------

export interface PackFrame {
  x: number
  y: number
  width: number
  height: number
  offsetX?: number | undefined
  offsetY?: number | undefined
  page?: number | undefined
}

export interface PackObjectInput {
  id?: number | undefined
  token?: string | undefined
  name?: string | undefined
  frame?: {
    x: number
    y: number
    width: number
    height: number
    offsetX: number
    offsetY: number
    page: number
  } | null | undefined
  x: number
  y: number
  depth?: number | undefined
  trans?: number | undefined
  blendMode?: 'normal' | 'additive' | undefined
  frameDelta?: number | undefined
  cycleAnim?: boolean | undefined
  sync?: boolean | undefined
  animatedFrames?: readonly {
    x: number
    y: number
    width: number
    height: number
    page: number
    offsetX: number
    offsetY: number
  }[] | undefined
}

export interface SimulatedWall {
  frame: { x: number; y: number; width: number; height: number }
  x: number
  y: number
  cellX: number
  cellY: number
  page: number
  _depth?: number | undefined
}

export interface RecordedDraw {
  target: 'wall' | 'object'
  id?: number | string | undefined
  token?: string | undefined
  depth: number
  x: number
  y: number
  options: any
  blendMode?: 'normal' | 'additive' | undefined
}

export class MockRenderer {
  public readonly draws: RecordedDraw[] = []

  draw(frame: any, x: number, y: number, options: any = {}): void {
    const isObject = 'blendMode' in options
    this.draws.push({
      target: isObject ? 'object' : 'wall',
      id: frame._id,
      token: frame._token,
      depth: frame._depth ?? 0,
      x,
      y,
      options,
      blendMode: options.blendMode,
    })
  }
}

// -----------------------------------------------------------------------------
// EXACT IMPLEMENTATION SIMULATION (from src/scene/act-scene.ts)
// -----------------------------------------------------------------------------

export function buildObjectDrawables(packObjects: PackObjectInput[]): ObjectDrawable[] {
  const objectDrawables: ObjectDrawable[] = []
  for (const obj of packObjects) {
    if (!obj.frame) continue
    const animatedFrames = obj.animatedFrames && obj.animatedFrames.length > 1
      ? obj.animatedFrames.map(f => ({
          frame: {
            x: f.x,
            y: f.y,
            width: f.width,
            height: f.height,
          },
          page: f.page,
          offsetX: f.offsetX,
          offsetY: f.offsetY,
        }))
      : undefined
    const hasAnim = animatedFrames !== undefined && animatedFrames.length > 1
    const frameDurationMs = (
      obj.frameDelta !== undefined && obj.frameDelta > 0
        ? Math.round((256 / obj.frameDelta) * 40 * 100) / 100
        : 40
    )
    const isPersistentFire = obj.token !== undefined && PERSISTENT_ILLUMINATION_TOKENS.has(obj.token.trim().toUpperCase())
    const cycleAnim = isPersistentFire ? true : (obj.cycleAnim ?? true)

    let phaseOffsetMs = 0
    if (hasAnim && !obj.sync) {
      const totalDurationMs = obj.animatedFrames!.length * frameDurationMs
      phaseOffsetMs = computeObjectPhaseOffsetMs(obj.x, obj.y, totalDurationMs)
    }

    const tokenUpper = obj.token ? obj.token.trim().toUpperCase() : ''
    const isAdditive = obj.blendMode === 'additive' ||
      obj.trans === 7 ||
      obj.trans === 1 ||
      ADDITIVE_OBJECT_TOKENS.has(tokenUpper)
    const blendMode: 'normal' | 'additive' = isAdditive ? 'additive' : (obj.blendMode ?? 'normal')

    const depth = obj.depth ?? ((obj.x + obj.y) / 5)

    objectDrawables.push({
      id: obj.id,
      token: obj.token,
      name: obj.name,
      frame: {
        x: obj.frame.x,
        y: obj.frame.y,
        width: obj.frame.width,
        height: obj.frame.height,
        // attach debug metadata
        _id: obj.id,
        _token: obj.token,
        _depth: depth,
      } as any,
      x: obj.x + obj.frame.offsetX,
      y: obj.y + obj.frame.offsetY,
      depth,
      page: obj.frame.page,
      baseX: obj.x,
      baseY: obj.y,
      blendMode,
      trans: obj.trans,
      ...(animatedFrames ? {
        animatedFrames,
        frameDurationMs,
        cycleAnim,
        phaseOffsetMs,
        currentFrameIndex: 0,
      } : {}),
    })
  }
  objectDrawables.sort((a, b) => a.depth - b.depth)
  return objectDrawables
}

export interface DrawDispatchOptions {
  walls: readonly SimulatedWall[]
  objs: readonly ObjectDrawable[]
  maxDepthSteps: readonly number[]
  wallPages?: readonly (any | null | undefined)[]
  objPages?: readonly (any | null | undefined)[]
  visibleWall?: (idx: number) => boolean
  visibleObj?: (idx: number) => boolean
}

export function executeDepthDrawDispatch(
  renderer: MockRenderer,
  options: DrawDispatchOptions
): { culledDraws: number; skippedDraws: number } {
  let wallIdx = 0
  let objIdx = 0
  let culledDraws = 0
  let skippedDraws = 0

  const walls = options.walls
  const objs = options.objs
  const wallPages = options.wallPages ?? new Array(100).fill({})
  const objPages = options.objPages ?? new Array(100).fill({})
  const visibleWall = options.visibleWall ?? (() => true)
  const visibleObj = options.visibleObj ?? (() => true)

  const drawUpToDepth = (maxDepth: number): void => {
    while (wallIdx < walls.length || objIdx < objs.length) {
      const nextWall = wallIdx < walls.length ? walls[wallIdx]! : null
      const nextObj = objIdx < objs.length ? objs[objIdx]! : null

      const wallDepth = nextWall !== null ? nextWall.cellX + nextWall.cellY : Infinity
      const objDepth = nextObj !== null ? nextObj.depth : Infinity

      if (wallDepth > maxDepth && objDepth > maxDepth) break

      if (wallDepth <= objDepth) {
        if (!visibleWall(wallIdx)) {
          culledDraws += 1
        } else {
          const page = wallPages[nextWall!.page]
          if (page === null || page === undefined) {
            skippedDraws += 1
          } else {
            renderer.draw(nextWall!.frame, nextWall!.x, nextWall!.y, { atlas: page })
          }
        }
        wallIdx += 1
      } else {
        if (!visibleObj(objIdx)) {
          culledDraws += 1
        } else {
          const page = objPages[nextObj!.page]
          if (page === null || page === undefined) {
            skippedDraws += 1
          } else {
            renderer.draw(nextObj!.frame, nextObj!.x, nextObj!.y, {
              atlas: page,
              blendMode: nextObj!.blendMode ?? 'normal',
            })
          }
        }
        objIdx += 1
      }
    }
  }

  for (const maxDepth of options.maxDepthSteps) {
    drawUpToDepth(maxDepth)
  }

  return { culledDraws, skippedDraws }
}

// -----------------------------------------------------------------------------
// ASSERTION SYSTEM
// -----------------------------------------------------------------------------

let totalAssertions = 0
let passedAssertions = 0

function assert(condition: boolean, message: string): void {
  totalAssertions++
  if (condition) {
    passedAssertions++
  } else {
    console.error(`❌ STRESS TEST FAILURE: ${message}`)
    throw new Error(`Assertion failed: ${message}`)
  }
}

// -----------------------------------------------------------------------------
// TEST SUITES
// -----------------------------------------------------------------------------

async function runEmpiricalStressHarness(): Promise<void> {
  console.log('================================================================================')
  console.log('🔥 EMPIRICAL STRESS TEST HARNESS: SCENE OBJECT RENDERING DISPATCH')
  console.log('Target: src/scene/act-scene.ts | Milestone 1 (R1)')
  console.log('================================================================================')

  // ---------------------------------------------------------------------------
  // SUITE 1: Ground Truth Token & Classification Matrix
  // ---------------------------------------------------------------------------
  console.log('\n--- [Suite 1] Ground Truth Token & Classification Matrix ---')
  {
    const canonicalAdditiveTokens = ['11', '12', 'R1', 'R2', 'R3', 'R4', 'R5', '1R', '2R', '3R', '4R', 'HA']
    for (const token of canonicalAdditiveTokens) {
      assert(ADDITIVE_OBJECT_TOKENS.has(token), `ADDITIVE_OBJECT_TOKENS must contain canonical token ${token}`)
    }

    // Test case variations, whitespace, and fallback combinations
    const testCases: {
      input: PackObjectInput
      expectedBlend: 'additive' | 'normal'
      desc: string
    }[] = [
      // Direct token matches (all 12 tokens)
      ...canonicalAdditiveTokens.map(tok => ({
        input: { x: 10, y: 20, token: tok, frame: { x: 0, y: 0, width: 32, height: 32, offsetX: 0, offsetY: 0, page: 0 } },
        expectedBlend: 'additive' as const,
        desc: `Token ${tok} without trans/blendMode must resolve to additive`,
      })),
      // Lowercase & whitespace variations
      {
        input: { x: 10, y: 20, token: '  11 ', frame: { x: 0, y: 0, width: 32, height: 32, offsetX: 0, offsetY: 0, page: 0 } },
        expectedBlend: 'additive',
        desc: 'Trimmed token "  11 " must resolve to additive',
      },
      {
        input: { x: 10, y: 20, token: 'r3', frame: { x: 0, y: 0, width: 32, height: 32, offsetX: 0, offsetY: 0, page: 0 } },
        expectedBlend: 'additive',
        desc: 'Lower-cased token "r3" must resolve to additive',
      },
      {
        input: { x: 10, y: 20, token: 'ha', frame: { x: 0, y: 0, width: 32, height: 32, offsetX: 0, offsetY: 0, page: 0 } },
        expectedBlend: 'additive',
        desc: 'Lower-cased token "ha" must resolve to additive',
      },
      // Trans values (Ground Truth 7 and 1) with unknown or empty tokens
      {
        input: { x: 10, y: 20, token: 'UNKNOWN', trans: 7, frame: { x: 0, y: 0, width: 32, height: 32, offsetX: 0, offsetY: 0, page: 0 } },
        expectedBlend: 'additive',
        desc: 'Unknown token with trans=7 must resolve to additive',
      },
      {
        input: { x: 10, y: 20, token: '', trans: 1, frame: { x: 0, y: 0, width: 32, height: 32, offsetX: 0, offsetY: 0, page: 0 } },
        expectedBlend: 'additive',
        desc: 'Empty token with trans=1 must resolve to additive',
      },
      {
        input: { x: 10, y: 20, token: undefined, trans: 7, frame: { x: 0, y: 0, width: 32, height: 32, offsetX: 0, offsetY: 0, page: 0 } },
        expectedBlend: 'additive',
        desc: 'Undefined token with trans=7 must resolve to additive',
      },
      // Explicit blendMode in serialized JSON
      {
        input: { x: 10, y: 20, token: 'CRATE', blendMode: 'additive', frame: { x: 0, y: 0, width: 32, height: 32, offsetX: 0, offsetY: 0, page: 0 } },
        expectedBlend: 'additive',
        desc: 'Explicit blendMode: "additive" must resolve to additive regardless of token',
      },
      // Backwards-compatible override: if JSON has blendMode: "normal" but token is 11, ground truth overrides to additive
      {
        input: { x: 10, y: 20, token: '11', blendMode: 'normal', frame: { x: 0, y: 0, width: 32, height: 32, offsetX: 0, offsetY: 0, page: 0 } },
        expectedBlend: 'additive',
        desc: 'Token 11 with accidental blendMode: "normal" must be corrected to additive',
      },
      // Regular / non-additive objects
      {
        input: { x: 10, y: 20, token: 'CHEST', trans: 0, frame: { x: 0, y: 0, width: 32, height: 32, offsetX: 0, offsetY: 0, page: 0 } },
        expectedBlend: 'normal',
        desc: 'Regular chest must resolve to normal',
      },
      {
        input: { x: 10, y: 20, token: 'TO', trans: 0, frame: { x: 0, y: 0, width: 32, height: 32, offsetX: 0, offsetY: 0, page: 0 } },
        expectedBlend: 'normal',
        desc: 'Persistent torch "TO" must resolve to normal',
      },
      {
        input: { x: 10, y: 20, token: 'BARREL', trans: 2, frame: { x: 0, y: 0, width: 32, height: 32, offsetX: 0, offsetY: 0, page: 0 } },
        expectedBlend: 'normal',
        desc: 'Regular barrel with trans=2 must resolve to normal',
      },
      {
        input: { x: 10, y: 20, token: undefined, trans: 0, frame: { x: 0, y: 0, width: 32, height: 32, offsetX: 0, offsetY: 0, page: 0 } },
        expectedBlend: 'normal',
        desc: 'Object with undefined token and trans=0 must resolve to normal',
      },
    ]

    for (const tc of testCases) {
      const drawables = buildObjectDrawables([tc.input])
      assert(drawables.length === 1, `Must create exactly 1 drawable for ${tc.desc}`)
      assert(drawables[0]!.blendMode === tc.expectedBlend, `${tc.desc}: expected ${tc.expectedBlend}, got ${drawables[0]!.blendMode}`)
    }

    // Frame-less objects must be ignored
    const noFrame = buildObjectDrawables([{ x: 10, y: 20, token: '11', frame: null }])
    assert(noFrame.length === 0, 'Object without frame must not produce an ObjectDrawable')
  }

  // ---------------------------------------------------------------------------
  // SUITE 2: Depth Sorting & Mixed Stream Draw Loop Verification
  // ---------------------------------------------------------------------------
  console.log('\n--- [Suite 2] Depth Sorting & Mixed Stream Draw Loop ---')
  {
    // Build an interleaved array of walls and objects
    // Depths:
    // Wall 0: cellX=2, cellY=3 -> depth 5
    // Object 0 (normal): depth 2
    // Object 1 (additive, Token 11): depth 4
    // Wall 1: cellX=4, cellY=2 -> depth 6
    // Object 2 (additive, Token 12): depth 6 (Tie with Wall 1!)
    // Wall 2: cellX=5, cellY=2 -> depth 7
    // Object 3 (normal): depth 9
    // Wall 3: cellX=6, cellY=4 -> depth 10

    const rawObjects: PackObjectInput[] = [
      { id: 101, depth: 9, token: 'BOX', frame: { x: 0, y: 0, width: 10, height: 10, offsetX: 0, offsetY: 0, page: 0 }, x: 45, y: 0 },
      { id: 102, depth: 2, token: 'POT', frame: { x: 0, y: 0, width: 10, height: 10, offsetX: 0, offsetY: 0, page: 0 }, x: 10, y: 0 },
      { id: 103, depth: 6, token: '12', frame: { x: 0, y: 0, width: 10, height: 10, offsetX: 0, offsetY: 0, page: 0 }, x: 30, y: 0 },
      { id: 104, depth: 4, token: '11', frame: { x: 0, y: 0, width: 10, height: 10, offsetX: 0, offsetY: 0, page: 0 }, x: 20, y: 0 },
    ]

    const objectDrawables = buildObjectDrawables(rawObjects)
    assert(objectDrawables.length === 4, 'Must create 4 drawables')

    // Verify buildObjectDrawables sorted them by depth
    for (let i = 1; i < objectDrawables.length; i++) {
      assert(objectDrawables[i]!.depth >= objectDrawables[i - 1]!.depth, 'objectDrawables must be pre-sorted by depth ascending')
    }

    const walls: SimulatedWall[] = [
      { frame: { x: 0, y: 0, width: 32, height: 32, _id: 'w1', _depth: 5 } as any, x: 0, y: 0, cellX: 2, cellY: 3, page: 0 },
      { frame: { x: 0, y: 0, width: 32, height: 32, _id: 'w2', _depth: 6 } as any, x: 0, y: 0, cellX: 4, cellY: 2, page: 0 },
      { frame: { x: 0, y: 0, width: 32, height: 32, _id: 'w3', _depth: 7 } as any, x: 0, y: 0, cellX: 5, cellY: 2, page: 0 },
      { frame: { x: 0, y: 0, width: 32, height: 32, _id: 'w4', _depth: 10 } as any, x: 0, y: 0, cellX: 6, cellY: 4, page: 0 },
    ]

    const renderer = new MockRenderer()
    executeDepthDrawDispatch(renderer, {
      walls,
      objs: objectDrawables,
      maxDepthSteps: [Infinity],
    })

    assert(renderer.draws.length === 8, `All 4 walls and 4 objects must be drawn (total 8, got ${renderer.draws.length})`)

    // Verify depth ordering: painter's order must be strictly non-decreasing
    for (let i = 1; i < renderer.draws.length; i++) {
      const prev = renderer.draws[i - 1]!
      const curr = renderer.draws[i]!
      assert(curr.depth >= prev.depth, `Draw #${i} (${curr.target} depth=${curr.depth}) must be >= Draw #${i - 1} (${prev.target} depth=${prev.depth})`)
    }

    // Verify specific blend modes:
    // Object 102 (POT, depth 2): normal
    // Object 104 (11, depth 4): additive
    // Wall w1 (depth 5): blendMode undefined
    // Wall w2 (depth 6): blendMode undefined (depth tie with Object 103, wall draws first due to wallDepth <= objDepth)
    // Object 103 (12, depth 6): additive
    // Wall w3 (depth 7): blendMode undefined
    // Object 101 (BOX, depth 9): normal
    // Wall w4 (depth 10): blendMode undefined

    const expectedSequence: { target: 'wall' | 'object'; id: number | string; blend: 'additive' | 'normal' | undefined; depth: number }[] = [
      { target: 'object', id: 102, blend: 'normal', depth: 2 },
      { target: 'object', id: 104, blend: 'additive', depth: 4 },
      { target: 'wall', id: 'w1', blend: undefined, depth: 5 },
      { target: 'wall', id: 'w2', blend: undefined, depth: 6 },
      { target: 'object', id: 103, blend: 'additive', depth: 6 },
      { target: 'wall', id: 'w3', blend: undefined, depth: 7 },
      { target: 'object', id: 101, blend: 'normal', depth: 9 },
      { target: 'wall', id: 'w4', blend: undefined, depth: 10 },
    ]

    for (let i = 0; i < expectedSequence.length; i++) {
      const exp = expectedSequence[i]!
      const actual = renderer.draws[i]!
      assert(actual.target === exp.target, `Step ${i}: target mismatch (exp ${exp.target}, got ${actual.target})`)
      assert(actual.id === exp.id, `Step ${i}: id mismatch (exp ${exp.id}, got ${actual.id})`)
      assert(actual.depth === exp.depth, `Step ${i}: depth mismatch (exp ${exp.depth}, got ${actual.depth})`)
      assert(actual.blendMode === exp.blend, `Step ${i}: blendMode mismatch (exp ${exp.blend}, got ${actual.blendMode})`)
    }
  }

  // ---------------------------------------------------------------------------
  // SUITE 3: Incremental Depth Stepping (Simulating Entity Depth Loops)
  // ---------------------------------------------------------------------------
  console.log('\n--- [Suite 3] Incremental Depth Stepping (Simulating Entity Loop) ---')
  {
    // In act-scene.ts, entities are sorted by depth, then drawUpToDepth(entity.depth)
    // is called before each entity is drawn, followed by drawUpToDepth(Infinity).
    // We simulate player at depth 5.5 and monster at depth 8.

    const rawObjects: PackObjectInput[] = [
      { id: 1, depth: 1, token: '11', frame: { x: 0, y: 0, width: 10, height: 10, offsetX: 0, offsetY: 0, page: 0 }, x: 5, y: 0 },
      { id: 2, depth: 5, token: '12', frame: { x: 0, y: 0, width: 10, height: 10, offsetX: 0, offsetY: 0, page: 0 }, x: 25, y: 0 },
      { id: 3, depth: 7, token: 'CHEST', frame: { x: 0, y: 0, width: 10, height: 10, offsetX: 0, offsetY: 0, page: 0 }, x: 35, y: 0 },
      { id: 4, depth: 12, token: 'R1', frame: { x: 0, y: 0, width: 10, height: 10, offsetX: 0, offsetY: 0, page: 0 }, x: 60, y: 0 },
    ]
    const objs = buildObjectDrawables(rawObjects)

    const walls: SimulatedWall[] = [
      { frame: { x: 0, y: 0, width: 32, height: 32, _id: 'w1', _depth: 2 } as any, x: 0, y: 0, cellX: 1, cellY: 1, page: 0 },
      { frame: { x: 0, y: 0, width: 32, height: 32, _id: 'w2', _depth: 5.5 } as any, x: 0, y: 0, cellX: 2.5, cellY: 3, page: 0 },
      { frame: { x: 0, y: 0, width: 32, height: 32, _id: 'w3', _depth: 9 } as any, x: 0, y: 0, cellX: 4, cellY: 5, page: 0 },
    ]

    const renderer = new MockRenderer()
    // Steps:
    // 1. maxDepth = 5.5 (draws up to player depth)
    // 2. maxDepth = 8.0 (draws up to monster depth)
    // 3. maxDepth = Infinity (draws rest)
    executeDepthDrawDispatch(renderer, {
      walls,
      objs,
      maxDepthSteps: [5.5, 8.0, Infinity],
    })

    assert(renderer.draws.length === 7, `Expected all 7 draws, got ${renderer.draws.length}`)

    // Verify monotonic depth ordering across stepped calls
    for (let i = 1; i < renderer.draws.length; i++) {
      assert(renderer.draws[i]!.depth >= renderer.draws[i - 1]!.depth, 'Stepped draw depth must remain non-decreasing')
    }

    // Verify items in step 1 had depth <= 5.5
    // Draws: Obj 1 (d=1), Wall w1 (d=2), Obj 2 (d=5), Wall w2 (d=5.5)
    for (let i = 0; i < 4; i++) {
      assert(renderer.draws[i]!.depth <= 5.5, `Draw #${i} must have depth <= 5.5`)
    }

    // Verify items in step 2 had depth > 5.5 and <= 8.0
    // Draws: Obj 3 (d=7)
    assert(renderer.draws[4]!.depth === 7 && renderer.draws[4]!.target === 'object', 'Step 2 must draw Obj 3')

    // Verify items in step 3 had depth > 8.0
    // Draws: Wall w3 (d=9), Obj 4 (d=12)
    assert(renderer.draws[5]!.depth === 9 && renderer.draws[5]!.target === 'wall', 'Step 3 must draw Wall w3')
    assert(renderer.draws[6]!.depth === 12 && renderer.draws[6]!.target === 'object', 'Step 3 must draw Obj 4')
    assert(renderer.draws[6]!.blendMode === 'additive', 'Obj 4 (R1) must have blendMode: additive')
  }

  // ---------------------------------------------------------------------------
  // SUITE 4: Boundary, Degenerate & Stress Conditions
  // ---------------------------------------------------------------------------
  console.log('\n--- [Suite 4] Boundary, Degenerate & Stress Conditions ---')
  {
    // 4.1 Empty lists
    const emptyRenderer = new MockRenderer()
    executeDepthDrawDispatch(emptyRenderer, { walls: [], objs: [], maxDepthSteps: [Infinity] })
    assert(emptyRenderer.draws.length === 0, 'Empty lists must produce 0 draws')

    // 4.2 Only walls (0 objects)
    const wallsOnlyRenderer = new MockRenderer()
    const sampleWalls: SimulatedWall[] = [
      { frame: { x: 0, y: 0, width: 32, height: 32, _depth: 1 } as any, x: 0, y: 0, cellX: 0, cellY: 1, page: 0 },
      { frame: { x: 0, y: 0, width: 32, height: 32, _depth: 3 } as any, x: 0, y: 0, cellX: 1, cellY: 2, page: 0 },
    ]
    executeDepthDrawDispatch(wallsOnlyRenderer, { walls: sampleWalls, objs: [], maxDepthSteps: [Infinity] })
    assert(wallsOnlyRenderer.draws.length === 2, 'Walls-only must produce all wall draws')

    // 4.3 Only objects (0 walls) - all additive
    const objsOnlyRenderer = new MockRenderer()
    const additiveObjs = buildObjectDrawables([
      { id: 1, token: '11', depth: 10, frame: { x: 0, y: 0, width: 10, height: 10, offsetX: 0, offsetY: 0, page: 0 }, x: 0, y: 0 },
      { id: 2, token: 'HA', depth: 20, frame: { x: 0, y: 0, width: 10, height: 10, offsetX: 0, offsetY: 0, page: 0 }, x: 0, y: 0 },
    ])
    executeDepthDrawDispatch(objsOnlyRenderer, { walls: [], objs: additiveObjs, maxDepthSteps: [Infinity] })
    assert(objsOnlyRenderer.draws.length === 2, 'Objects-only must produce all object draws')
    assert(objsOnlyRenderer.draws.every(d => d.blendMode === 'additive'), 'All draws must be additive')

    // 4.4 Massive depth tie stress (100 walls and 100 objects all at depth = 50)
    const tieWalls: SimulatedWall[] = Array.from({ length: 100 }, (_, i) => ({
      frame: { x: 0, y: 0, width: 32, height: 32, _id: `w_tie_${i}`, _depth: 50 } as any,
      x: i,
      y: i,
      cellX: 25,
      cellY: 25,
      page: 0,
    }))
    const tieObjs = buildObjectDrawables(Array.from({ length: 100 }, (_, i) => ({
      id: i,
      token: i % 2 === 0 ? '11' : 'BOX',
      depth: 50,
      frame: { x: 0, y: 0, width: 10, height: 10, offsetX: 0, offsetY: 0, page: 0 },
      x: i,
      y: i,
    })))

    const tieRenderer = new MockRenderer()
    executeDepthDrawDispatch(tieRenderer, {
      walls: tieWalls,
      objs: tieObjs,
      maxDepthSteps: [50, Infinity],
    })
    assert(tieRenderer.draws.length === 200, `Massive tie: must draw all 200 items (got ${tieRenderer.draws.length})`)
    // Because wallDepth <= objDepth, all 100 walls must be drawn before the 100 objects
    for (let i = 0; i < 100; i++) {
      assert(tieRenderer.draws[i]!.target === 'wall', `Tie #${i} must be wall`)
    }
    for (let i = 100; i < 200; i++) {
      assert(tieRenderer.draws[i]!.target === 'object', `Tie #${i} must be object`)
      const isEven = (i - 100) % 2 === 0
      const expectedBlend = isEven ? 'additive' : 'normal'
      assert(tieRenderer.draws[i]!.blendMode === expectedBlend, `Tie #${i} object blendMode mismatch`)
    }

    // 4.5 Negative and extreme depths
    const extremeObjs = buildObjectDrawables([
      { id: 1, depth: -1000, token: '11', frame: { x: 0, y: 0, width: 10, height: 10, offsetX: 0, offsetY: 0, page: 0 }, x: 0, y: 0 },
      { id: 2, depth: 1000000, token: 'BOX', frame: { x: 0, y: 0, width: 10, height: 10, offsetX: 0, offsetY: 0, page: 0 }, x: 0, y: 0 },
    ])
    const extremeWalls: SimulatedWall[] = [
      { frame: { x: 0, y: 0, width: 32, height: 32, _depth: -500 } as any, x: 0, y: 0, cellX: -200, cellY: -300, page: 0 },
      { frame: { x: 0, y: 0, width: 32, height: 32, _depth: 500000 } as any, x: 0, y: 0, cellX: 200000, cellY: 300000, page: 0 },
    ]
    const extremeRenderer = new MockRenderer()
    executeDepthDrawDispatch(extremeRenderer, {
      walls: extremeWalls,
      objs: extremeObjs,
      maxDepthSteps: [0, Infinity],
    })
    assert(extremeRenderer.draws.length === 4, 'Extreme depth items must all be drawn')
    assert(extremeRenderer.draws[0]!.depth === -1000, 'Lowest negative depth drawn first')
    assert(extremeRenderer.draws[1]!.depth === -500, 'Second negative depth drawn second')
    assert(extremeRenderer.draws[2]!.depth === 500000, 'Large positive depth drawn third')
    assert(extremeRenderer.draws[3]!.depth === 1000000, 'Largest depth drawn last')

    // 4.6 Viewport culling preservation: culling skips draw but does NOT stall or desync cursors
    const cullingObjs = buildObjectDrawables([
      { id: 1, depth: 10, token: '11', frame: { x: 0, y: 0, width: 10, height: 10, offsetX: 0, offsetY: 0, page: 0 }, x: 0, y: 0 },
      { id: 2, depth: 20, token: 'BOX', frame: { x: 0, y: 0, width: 10, height: 10, offsetX: 0, offsetY: 0, page: 0 }, x: 0, y: 0 },
      { id: 3, depth: 30, token: '12', frame: { x: 0, y: 0, width: 10, height: 10, offsetX: 0, offsetY: 0, page: 0 }, x: 0, y: 0 },
    ])
    const cullingWalls: SimulatedWall[] = [
      { frame: { x: 0, y: 0, width: 32, height: 32, _depth: 15 } as any, x: 0, y: 0, cellX: 5, cellY: 10, page: 0 },
      { frame: { x: 0, y: 0, width: 32, height: 32, _depth: 25 } as any, x: 0, y: 0, cellX: 10, cellY: 15, page: 0 },
    ]

    const cullingRenderer = new MockRenderer()
    // Cull Object 2 (idx 1) and Wall 1 (idx 0)
    const res = executeDepthDrawDispatch(cullingRenderer, {
      walls: cullingWalls,
      objs: cullingObjs,
      maxDepthSteps: [Infinity],
      visibleObj: idx => idx !== 1,
      visibleWall: idx => idx !== 0,
    })
    assert(res.culledDraws === 2, `Expected 2 culled draws, got ${res.culledDraws}`)
    assert(cullingRenderer.draws.length === 3, `Expected 3 drawn items, got ${cullingRenderer.draws.length}`)
    // Drawn items should be: Obj 1 (depth 10), Wall 2 (depth 25), Obj 3 (depth 30)
    assert(cullingRenderer.draws[0]!.depth === 10 && cullingRenderer.draws[0]!.target === 'object', 'First draw is Obj 1')
    assert(cullingRenderer.draws[1]!.depth === 25 && cullingRenderer.draws[1]!.target === 'wall', 'Second draw is Wall 2')
    assert(cullingRenderer.draws[2]!.depth === 30 && cullingRenderer.draws[2]!.target === 'object', 'Third draw is Obj 3')
    assert(cullingRenderer.draws[0]!.blendMode === 'additive', 'Obj 1 must be additive')
    assert(cullingRenderer.draws[2]!.blendMode === 'additive', 'Obj 3 must be additive')

    // 4.7 Missing page skipping: page=null skips draw but advances cursors
    const missingPageRenderer = new MockRenderer()
    const missingPageRes = executeDepthDrawDispatch(missingPageRenderer, {
      walls: cullingWalls,
      objs: cullingObjs,
      maxDepthSteps: [Infinity],
      objPages: [null], // object page 0 missing
      wallPages: [{}],  // wall page 0 valid
    })
    assert(missingPageRes.skippedDraws === 3, `Expected 3 skipped object draws, got ${missingPageRes.skippedDraws}`)
    assert(missingPageRenderer.draws.length === 2, `Expected 2 wall draws, got ${missingPageRenderer.draws.length}`)
    assert(missingPageRenderer.draws[0]!.depth === 15 && missingPageRenderer.draws[1]!.depth === 25, 'Wall depths preserved')
  }

  // ---------------------------------------------------------------------------
  // SUITE 5: Differential Fuzzing vs Independent Naive Oracle (10,000 Iterations)
  // ---------------------------------------------------------------------------
  console.log('\n--- [Suite 5] Differential Fuzzing vs Naive Oracle (10,000 Iterations) ---')
  {
    const TOKEN_POOL = [
      '11', '12', 'R1', 'R2', 'R3', 'R4', 'R5', '1R', '2R', '3R', '4R', 'HA', // Additive
      'to', 'a1', 'a2', 'box', 'chest', 'urn', 'barrel', 'column', 'statue', // Normal
      '', '   ', 'r1', 'ha', ' 11 ', // Variants
      undefined,
    ]
    const TRANS_POOL = [0, 1, 7, 2, 3, undefined]
    const BLEND_POOL = ['normal' as const, 'additive' as const, undefined]

    // Simple, obviously correct Oracle for differential testing
    function naiveOracleSort(
      walls: SimulatedWall[],
      objs: PackObjectInput[],
      maxDepthSteps: number[]
    ): RecordedDraw[] {
      // 1. Resolve objects
      const resolvedObjs: { target: 'object'; depth: number; blendMode: 'normal' | 'additive'; id: any; x: number; y: number }[] = []
      for (const o of objs) {
        if (!o.frame) continue
        const tokenUpper = o.token ? o.token.trim().toUpperCase() : ''
        const isAdditive = o.blendMode === 'additive' || o.trans === 7 || o.trans === 1 || ADDITIVE_OBJECT_TOKENS.has(tokenUpper)
        const blendMode = isAdditive ? 'additive' : (o.blendMode ?? 'normal')
        const depth = o.depth ?? ((o.x + o.y) / 5)
        resolvedObjs.push({
          target: 'object',
          depth,
          blendMode,
          id: o.id,
          x: o.x + (o.frame.offsetX ?? 0),
          y: o.y + (o.frame.offsetY ?? 0),
        })
      }
      // Stable sort objects by depth
      resolvedObjs.sort((a, b) => a.depth - b.depth)

      // 2. Resolve walls
      const resolvedWalls = walls.map(w => ({
        target: 'wall' as const,
        depth: w.cellX + w.cellY,
        blendMode: undefined,
        id: (w.frame as any)._id,
        x: w.x,
        y: w.y,
      }))
      resolvedWalls.sort((a, b) => a.depth - b.depth)

      // 3. Two-pointer merge identically to Painter's algorithm
      const allDrawn: RecordedDraw[] = []
      let wIdx = 0
      let oIdx = 0

      for (const maxD of maxDepthSteps) {
        while (wIdx < resolvedWalls.length || oIdx < resolvedObjs.length) {
          const w = wIdx < resolvedWalls.length ? resolvedWalls[wIdx]! : null
          const o = oIdx < resolvedObjs.length ? resolvedObjs[oIdx]! : null

          const wDepth = w !== null ? w.depth : Infinity
          const oDepth = o !== null ? o.depth : Infinity

          if (wDepth > maxD && oDepth > maxD) break

          if (wDepth <= oDepth) {
            allDrawn.push({
              target: 'wall',
              depth: w!.depth,
              id: w!.id,
              x: w!.x,
              y: w!.y,
              options: {},
              blendMode: undefined,
            })
            wIdx++
          } else {
            allDrawn.push({
              target: 'object',
              depth: o!.depth,
              id: o!.id,
              x: o!.x,
              y: o!.y,
              options: { blendMode: o!.blendMode },
              blendMode: o!.blendMode,
            })
            oIdx++
          }
        }
      }
      return allDrawn
    }

    const NUM_ITERATIONS = 10000
    let lastReport = 0

    for (let seed = 1; seed <= NUM_ITERATIONS; seed++) {
      // Deterministic PRNG (Mulberry32)
      let a = seed ^ 0x9e3779b9
      const rand = () => {
        let t = (a += 0x6d2b79f5)
        t = Math.imul(t ^ (t >>> 15), t | 1)
        t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
        return ((t ^ (t >>> 14)) >>> 0) / 4294967296
      }

      // Generate random small-to-medium scene
      const numWalls = Math.floor(rand() * 25)
      const numObjs = Math.floor(rand() * 25)

      const walls: SimulatedWall[] = []
      for (let i = 0; i < numWalls; i++) {
        const cx = Math.floor(rand() * 20) - 5
        const cy = Math.floor(rand() * 20) - 5
        walls.push({
          frame: { x: 0, y: 0, width: 32, height: 32, _id: `w_${seed}_${i}`, _depth: cx + cy } as any,
          x: cx * 10,
          y: cy * 10,
          cellX: cx,
          cellY: cy,
          page: 0,
        })
      }
      // In D2 map generation, walls are always sorted by cellY + cellX
      walls.sort((a, b) => (a.cellX + a.cellY) - (b.cellX + b.cellY) || a.cellY - b.cellY)

      const packObjs: PackObjectInput[] = []
      for (let i = 0; i < numObjs; i++) {
        const hasFrame = rand() > 0.05
        const token = TOKEN_POOL[Math.floor(rand() * TOKEN_POOL.length)]
        const trans = TRANS_POOL[Math.floor(rand() * TRANS_POOL.length)]
        const blend = BLEND_POOL[Math.floor(rand() * BLEND_POOL.length)]
        const x = Math.floor(rand() * 200) - 50
        const y = Math.floor(rand() * 200) - 50
        const depth = rand() > 0.3 ? (Math.floor(rand() * 30) - 10) : undefined

        packObjs.push({
          id: i,
          token,
          trans,
          blendMode: blend,
          x,
          y,
          depth,
          frame: hasFrame ? { x: 0, y: 0, width: 16, height: 16, offsetX: 0, offsetY: 0, page: 0 } : null,
        })
      }

      // Random depth steps
      const steps = [
        Math.floor(rand() * 10) - 5,
        Math.floor(rand() * 20),
        Infinity,
      ].sort((x, y) => x - y)

      // Run oracle
      const expected = naiveOracleSort(walls, packObjs, steps)

      // Run actual implementation simulation
      const objDrawables = buildObjectDrawables(packObjs)
      const mockRenderer = new MockRenderer()
      executeDepthDrawDispatch(mockRenderer, {
        walls,
        objs: objDrawables,
        maxDepthSteps: steps,
      })

      const actual = mockRenderer.draws

      // Assert parity between implementation and oracle
      assert(actual.length === expected.length, `Iteration ${seed}: Length mismatch (expected ${expected.length}, got ${actual.length})`)

      for (let j = 0; j < actual.length; j++) {
        const exp = expected[j]!
        const act = actual[j]!
        assert(act.target === exp.target, `Iteration ${seed}, Draw #${j}: Target mismatch (${act.target} vs ${exp.target})`)
        assert(act.depth === exp.depth, `Iteration ${seed}, Draw #${j}: Depth mismatch (${act.depth} vs ${exp.depth})`)
        assert(act.blendMode === exp.blendMode, `Iteration ${seed}, Draw #${j}: BlendMode mismatch (${act.blendMode} vs ${exp.blendMode})`)
      }

      // Check depth monotonically non-decreasing
      for (let j = 1; j < actual.length; j++) {
        assert(actual[j]!.depth >= actual[j - 1]!.depth, `Iteration ${seed}: Depth monotonicity violated at draw #${j}`)
      }

      if (seed - lastReport >= 2500) {
        lastReport = seed
        console.log(`  ... completed ${seed} / ${NUM_ITERATIONS} differential fuzzing iterations`)
      }
    }
    console.log(`✅ Successfully completed ${NUM_ITERATIONS} differential fuzzing cases with 0 mismatches`)
  }

  // ---------------------------------------------------------------------------
  // SUITE 6: Full Audit on Real Scene Packs (Level 108 Chaos Sanctuary)
  // ---------------------------------------------------------------------------
  console.log('\n--- [Suite 6] Real Scene Pack Audit: Level 108 Chaos Sanctuary ---')
  {
    const packVariants = [
      'samples/d2-packs/act4/108-act-4-diablo-1-var1/scene.json',
      'samples/d2-packs/act4/108-act-4-diablo-1-var2/scene.json',
      'samples/d2-packs/act4/108-act-4-diablo-1-var3/scene.json',
    ]

    for (const packPath of packVariants) {
      if (!fs.existsSync(packPath)) {
        console.warn(`Pack path not found: ${packPath}`)
        continue
      }
      const rawData = fs.readFileSync(packPath, 'utf8')
      const scene = JSON.parse(rawData)

      // Convert pack scene.walls to SimulatedWall
      const walls: SimulatedWall[] = scene.walls.map((row: any[]) => ({
        frame: { x: 0, y: 0, width: 32, height: 32, _depth: (row[3] ?? 0) + (row[4] ?? 0) } as any,
        x: row[1] ?? 0,
        y: row[2] ?? 0,
        cellX: row[3] ?? 0,
        cellY: row[4] ?? 0,
        page: scene.framePlacement[row[0] ?? 0]?.[0] ?? 0,
      }))

      // Convert pack scene.objects to PackObjectInput
      const packObjects: PackObjectInput[] = scene.objects.map((obj: any) => ({
        ...obj,
      }))

      const objectDrawables = buildObjectDrawables(packObjects)
      const mockRenderer = new MockRenderer()

      executeDepthDrawDispatch(mockRenderer, {
        walls,
        objs: objectDrawables,
        maxDepthSteps: [Infinity],
      })

      // Count window light rays (tokens 11 and 12)
      const rays = objectDrawables.filter(d => d.token === '11' || d.token === '12')
      assert(rays.length > 0, `${packPath}: Must contain window light rays`)
      for (const ray of rays) {
        assert(ray.blendMode === 'additive', `${packPath}: Ray ${ray.id} (token ${ray.token}) must be additive`)
      }

      // Check all draws for window rays in renderer
      const rayDraws = mockRenderer.draws.filter(d => d.token === '11' || d.token === '12')
      assert(rayDraws.length === rays.length, `${packPath}: All rays must be drawn by renderer`)
      for (const d of rayDraws) {
        assert(d.blendMode === 'additive', `${packPath}: Renderer ray draw must pass blendMode: 'additive'`)
      }

      // Check depth ordering of all draws in real scene
      for (let i = 1; i < mockRenderer.draws.length; i++) {
        assert(
          mockRenderer.draws[i]!.depth >= mockRenderer.draws[i - 1]!.depth,
          `${packPath}: Depth ordering violated at draw #${i} (${mockRenderer.draws[i]!.depth} < ${mockRenderer.draws[i - 1]!.depth})`
        )
      }

      console.log(`  ✓ ${path.basename(path.dirname(packPath))}: ${walls.length} walls, ${objectDrawables.length} objects (${rays.length} rays), all verified additive and depth-sorted`)
    }
  }

  console.log('\n================================================================================')
  console.log('🎉 ALL EMPIRICAL CHALLENGER STRESS TESTS PASSED!')
  console.log(`Total Assertions Executed: ${totalAssertions}`)
  console.log(`Assertions Passed: ${passedAssertions}`)
  console.log('Explicit Verdict: APPROVE')
  console.log('================================================================================')
}

runEmpiricalStressHarness().catch(err => {
  console.error('Empirical Stress Harness Failure:', err)
  process.exit(1)
})