/**
 * Verification test for SpriteRenderer GPU resource lifecycle, deleteAtlas,
 * dispose, and WebGL context loss handling (Issue #9), plus the multi-texture
 * batching, indexed geometry and draw-call instrumentation added for Issue #16.
 */
import { SpriteRenderer, RendererError } from '../src/render/renderer.ts'
import { buildBounds, intersects, viewportRect } from '../src/render/cull.ts'

interface MockResource {
  id: number
  type: string
}

function createMockCanvas(): {
  canvas: any
  stats: {
    createdTextures: Set<MockResource>
    deletedTextures: Set<MockResource>
    createdBuffers: Set<MockResource>
    deletedBuffers: Set<MockResource>
    createdVAOs: Set<MockResource>
    deletedVAOs: Set<MockResource>
    createdPrograms: Set<MockResource>
    deletedPrograms: Set<MockResource>
    createdShaders: Set<MockResource>
    deletedShaders: Set<MockResource>
    eventListeners: Map<string, Set<EventListener>>
    glDrawCalls: number
    shaderSources: string[]
    texStorage2DCalls: number
    texSubImage2DCalls: number
    uniformUploadCalls: number
    uniformCameraCalls: number
    uniformViewportCalls: number
    uniformZoomCalls: number
  }
  setContextLost: (lost: boolean) => void
  dispatchMockEvent: (type: string) => { defaultPrevented: boolean }
} {
  let nextId = 1
  let contextLost = false

  const stats = {
    createdTextures: new Set<MockResource>(),
    deletedTextures: new Set<MockResource>(),
    createdBuffers: new Set<MockResource>(),
    deletedBuffers: new Set<MockResource>(),
    createdVAOs: new Set<MockResource>(),
    deletedVAOs: new Set<MockResource>(),
    createdPrograms: new Set<MockResource>(),
    deletedPrograms: new Set<MockResource>(),
    createdShaders: new Set<MockResource>(),
    deletedShaders: new Set<MockResource>(),
    eventListeners: new Map<string, Set<EventListener>>(),
    glDrawCalls: 0,
    shaderSources: [] as string[],
    texStorage2DCalls: 0,
    texSubImage2DCalls: 0,
    uniformUploadCalls: 0,
    uniformCameraCalls: 0,
    uniformViewportCalls: 0,
    uniformZoomCalls: 0,
  }

  const gl: any = {
    VERTEX_SHADER: 35633,
    FRAGMENT_SHADER: 35632,
    COMPILE_STATUS: 35713,
    LINK_STATUS: 35714,
    MAX_TEXTURE_SIZE: 3379,
    MAX_TEXTURE_IMAGE_UNITS: 34930,
    TEXTURE_2D: 3553,
    RGBA: 6408,
    RGBA8: 32856,
    R8: 33321,
    RED: 6403,
    UNSIGNED_BYTE: 5121,
    UNSIGNED_INT: 5125,
    FLOAT: 5126,
    ARRAY_BUFFER: 34962,
    ELEMENT_ARRAY_BUFFER: 34963,
    DYNAMIC_DRAW: 35048,
    STATIC_DRAW: 35044,
    TRIANGLES: 4,
    TEXTURE_MIN_FILTER: 10241,
    TEXTURE_MAG_FILTER: 10240,
    TEXTURE_WRAP_S: 10242,
    TEXTURE_WRAP_T: 10243,
    CLAMP_TO_EDGE: 33071,
    NEAREST: 9728,
    UNPACK_ALIGNMENT: 3317,
    BLEND: 3042,
    SRC_ALPHA: 770,
    ONE_MINUS_SRC_ALPHA: 771,
    DEPTH_TEST: 2929,
    COLOR_BUFFER_BIT: 16384,
    TEXTURE0: 33984,

    drawingBufferWidth: 800,
    drawingBufferHeight: 600,

    isContextLost: () => contextLost,

    createProgram: () => {
      const res: MockResource = { id: nextId++, type: 'program' }
      stats.createdPrograms.add(res)
      return res
    },
    deleteProgram: (p: MockResource) => { stats.deletedPrograms.add(p) },
    attachShader: () => {},
    detachShader: () => {},
    linkProgram: () => {},
    getProgramParameter: () => true,
    getProgramInfoLog: () => '',
    useProgram: () => {},

    createShader: (type: number) => {
      const res: MockResource = { id: nextId++, type: type === 35633 ? 'vertexShader' : 'fragmentShader' }
      stats.createdShaders.add(res)
      return res
    },
    shaderSource: (_shader: MockResource, source: string) => { stats.shaderSources.push(source) },
    compileShader: () => {},
    getShaderParameter: () => true,
    getShaderInfoLog: () => '',
    deleteShader: (s: MockResource) => { stats.deletedShaders.add(s) },

    createVertexArray: () => {
      const res: MockResource = { id: nextId++, type: 'vao' }
      stats.createdVAOs.add(res)
      return res
    },
    deleteVertexArray: (vao: MockResource) => { stats.deletedVAOs.add(vao) },
    bindVertexArray: () => {},

    createBuffer: () => {
      const res: MockResource = { id: nextId++, type: 'buffer' }
      stats.createdBuffers.add(res)
      return res
    },
    deleteBuffer: (b: MockResource) => { stats.deletedBuffers.add(b) },
    bindBuffer: () => {},
    bufferData: () => {},
    bufferSubData: () => {},

    getAttribLocation: (_p: any, name: string) => (
      name === 'a_position' ? 0 : name === 'a_uv' ? 1 : name === 'a_tint' ? 2 : 3
    ),
    enableVertexAttribArray: () => {},
    vertexAttribPointer: () => {},

    createTexture: () => {
      const res: MockResource = { id: nextId++, type: 'texture' }
      stats.createdTextures.add(res)
      return res
    },
    deleteTexture: (t: MockResource) => { stats.deletedTextures.add(t) },
    bindTexture: () => {},
    texParameteri: () => {},
    texImage2D: () => {},
    texStorage2D: () => { stats.texStorage2DCalls += 1 },
    texSubImage2D: () => { stats.texSubImage2DCalls += 1 },
    pixelStorei: () => {},

    getParameter: (param: number) => (param === 3379 ? 4096 : param === 34930 ? 16 : 0),
    getUniformLocation: (_p: any, name: string) => ({ name }),
    uniform2f: (loc: any) => {
      stats.uniformUploadCalls += 1
      if (loc?.name === 'u_camera') stats.uniformCameraCalls += 1
      if (loc?.name === 'u_viewport') stats.uniformViewportCalls += 1
    },
    uniform1f: (loc: any) => {
      stats.uniformUploadCalls += 1
      if (loc?.name === 'u_zoom') stats.uniformZoomCalls += 1
    },
    uniform1i: () => {},
    uniform1iv: () => {},

    enable: () => {},
    disable: () => {},
    blendFunc: () => {},
    viewport: () => {},
    clearColor: () => {},
    clear: () => {},
    activeTexture: () => {},
    drawArrays: () => { stats.glDrawCalls += 1 },
    drawElements: () => { stats.glDrawCalls += 1 },
  }

  const eventListeners = stats.eventListeners

  const canvas: any = {
    getContext: (type: string) => (type === 'webgl2' ? gl : null),
    addEventListener: (type: string, listener: EventListener) => {
      if (!eventListeners.has(type)) eventListeners.set(type, new Set())
      eventListeners.get(type)!.add(listener)
    },
    removeEventListener: (type: string, listener: EventListener) => {
      eventListeners.get(type)?.delete(listener)
    },
    drawingBufferWidth: 800,
    drawingBufferHeight: 600,
  }

  return {
    canvas,
    stats,
    setContextLost: (lost: boolean) => { contextLost = lost },
    dispatchMockEvent: (type: string) => {
      let defaultPrevented = false
      const event: any = {
        type,
        preventDefault: () => { defaultPrevented = true },
      }
      const set = eventListeners.get(type)
      if (set) {
        for (const listener of set) {
          listener(event)
        }
      }
      return { defaultPrevented }
    },
  }
}

/**
 * Make a throwaway atlas page handle.
 *
 * @param renderer - the renderer to allocate on.
 * @returns a handle backed by a real (mock) texture.
 */
function page(renderer: SpriteRenderer): ReturnType<SpriteRenderer['addAtlas']> {
  return renderer.addAtlas({ pixels: new Uint8ClampedArray(16 * 16 * 4), width: 16, height: 16 })
}

function runTests(): void {
  console.log('== Running SpriteRenderer Lifecycle Verification ==\n')

  let passed = 0
  let failed = 0

  function assert(condition: boolean, name: string): void {
    if (condition) {
      console.log(`  ✓ ${name}`)
      passed += 1
    } else {
      console.error(`  ✗ ${name}`)
      failed += 1
    }
  }

  // Test 1: Shader cleanup after compilation
  {
    const mock = createMockCanvas()
    const renderer = new SpriteRenderer(mock.canvas)

    assert(mock.stats.createdShaders.size === 2, 'Two shaders created (VS & FS)')
    assert(mock.stats.deletedShaders.size === 2, 'Both shaders detached and deleted right after program link')
    assert(mock.stats.createdPrograms.size === 1, 'Program created')
    assert(mock.stats.createdVAOs.size === 1, 'VAO created')
    assert(mock.stats.createdBuffers.size === 2, 'Vertex and index buffers created')
    assert(mock.stats.createdTextures.size === 3, 'Initial textures created (atlas + white + palette)')
    assert(renderer.isDisposed === false, 'Renderer is active and not disposed')

    renderer.dispose()
  }

  // Test 2: addAtlas & deleteAtlas
  {
    const mock = createMockCanvas()
    const renderer = new SpriteRenderer(mock.canvas)

    const extra = renderer.addAtlas({ pixels: new Uint8ClampedArray(64 * 64 * 4), width: 64, height: 64 })
    assert(mock.stats.createdTextures.size === 4, 'addAtlas creates a new GPU texture (4 total)')

    // Draw with this extra atlas
    renderer.begin({ x: 0, y: 0, zoom: 1 })
    renderer.draw({ x: 0, y: 0, width: 32, height: 32 }, 0, 0, { atlas: extra })

    // Now delete this atlas
    const deleted = renderer.deleteAtlas(extra)
    assert(deleted === true, 'deleteAtlas returned true for managed handle')
    assert(mock.stats.deletedTextures.has(extra.texture as any), 'GPU texture was deleted via gl.deleteTexture')

    // Deleting again should be safe and return false
    const deletedAgain = renderer.deleteAtlas(extra)
    assert(deletedAgain === false, 'deleteAtlas returned false on already deleted handle')

    renderer.dispose()
  }

  // Test 3: dispose() cleans up all resources
  {
    const mock = createMockCanvas()
    const renderer = new SpriteRenderer(mock.canvas)
    const extra1 = renderer.addAtlas({ pixels: new Uint8ClampedArray(32 * 32 * 4), width: 32, height: 32 })
    const extra2 = renderer.addAtlas({ pixels: new Uint8ClampedArray(32 * 32 * 4), width: 32, height: 32 })
    void extra1
    void extra2

    assert(mock.stats.createdTextures.size === 5, '5 total textures created before dispose')

    renderer.dispose()
    assert(renderer.isDisposed === true, 'isDisposed is true after dispose()')
    assert(mock.stats.deletedTextures.size === 5, 'All 5 textures were deleted on dispose()')
    assert(mock.stats.deletedBuffers.size === 2, 'Vertex and index buffers were deleted on dispose()')
    assert(mock.stats.deletedVAOs.size === 1, 'VAO was deleted on dispose()')
    assert(mock.stats.deletedPrograms.size === 1, 'Program was deleted on dispose()')

    // Idempotent dispose
    renderer.dispose()
    assert(mock.stats.deletedPrograms.size === 1, 'Second dispose() is safe and idempotent')

    // Calling methods after dispose throws RendererError
    let threwOnBegin = false
    try {
      renderer.begin({ x: 0, y: 0, zoom: 1 })
    } catch (err) {
      if (err instanceof RendererError) threwOnBegin = true
    }
    assert(threwOnBegin, 'begin() throws RendererError when called on disposed renderer')

    let threwOnAdd = false
    try {
      renderer.addAtlas({ pixels: new Uint8ClampedArray(16), width: 2, height: 2 })
    } catch (err) {
      if (err instanceof RendererError) threwOnAdd = true
    }
    assert(threwOnAdd, 'addAtlas() throws RendererError when called on disposed renderer')
  }

  // Test 4: WebGL Context Lost & Restored
  {
    const mock = createMockCanvas()
    const tracker = { lostFired: false, restoredFired: false }

    const renderer = new SpriteRenderer(mock.canvas, {
      onContextLost: () => { tracker.lostFired = true },
      onContextRestored: () => { tracker.restoredFired = true },
    })

    const lostEvent = mock.dispatchMockEvent('webglcontextlost')
    assert(lostEvent.defaultPrevented === true, 'webglcontextlost calls event.preventDefault() to allow recovery')
    assert(tracker.lostFired === true, 'onContextLost callback fired')

    mock.dispatchMockEvent('webglcontextrestored')
    assert(tracker.restoredFired === true, 'onContextRestored callback fired')

    // Dispose cleans up event listeners
    renderer.dispose()
    assert(mock.stats.eventListeners.get('webglcontextlost')?.size === 0, 'Context lost listener removed on dispose')
    assert(mock.stats.eventListeners.get('webglcontextrestored')?.size === 0, 'Context restored listener removed on dispose')
  }

  // Test 5: Dispose when context is already lost
  {
    const mock = createMockCanvas()
    const renderer = new SpriteRenderer(mock.canvas)
    mock.setContextLost(true)

    // Dispose should not attempt invalid GL deletes when context is lost
    renderer.dispose()
    assert(renderer.isDisposed === true, 'dispose() safely completes when context is already lost')
  }

  // Test 6 (Issue #16): several atlas pages interleaved in painter's order stay
  // in ONE draw call. This is the regression that mattered: sorting by texture
  // is not an option here, because draw order *is* the depth order.
  {
    const mock = createMockCanvas()
    const renderer = new SpriteRenderer(mock.canvas)
    const a = page(renderer)
    const b = page(renderer)
    const c = page(renderer)
    const frame = { x: 0, y: 0, width: 8, height: 8 }

    renderer.begin({ x: 0, y: 0, zoom: 1 })
    const before = mock.stats.glDrawCalls
    // Worst case for the old batcher: every quad switches page.
    for (let i = 0; i < 60; i += 1) {
      renderer.draw(frame, i, i, { atlas: i % 3 === 0 ? a : i % 3 === 1 ? b : c })
    }
    renderer.flush()

    assert(mock.stats.glDrawCalls - before === 1, '60 quads ping-ponging across 3 pages cost exactly 1 draw call')
    assert(renderer.drawCalls === 1, 'renderer.drawCalls reports the real measured count')
    assert(renderer.quadsSubmitted === 60, 'renderer.quadsSubmitted counts every queued quad')

    renderer.dispose()
  }

  // Test 7 (Issue #16): solid rectangles batch together with sprites rather
  // than forcing a flush per colour or per texture switch.
  {
    const mock = createMockCanvas()
    const renderer = new SpriteRenderer(mock.canvas)
    const a = page(renderer)
    const frame = { x: 0, y: 0, width: 8, height: 8 }

    renderer.begin({ x: 0, y: 0, zoom: 1 })
    const before = mock.stats.glDrawCalls
    renderer.draw(frame, 0, 0, { atlas: a })
    renderer.drawSolid(0, 0, 4, 4, [1, 0, 0, 1])
    renderer.draw(frame, 8, 8, { atlas: a })
    renderer.drawSolid(8, 8, 4, 4, [0, 1, 0, 1])
    renderer.flush()

    assert(mock.stats.glDrawCalls - before === 1, 'Sprites and solid rects interleave in a single draw call')
    renderer.dispose()
  }

  // Test 8 (Issue #16): the batch only splits once it runs out of texture units.
  {
    const mock = createMockCanvas()
    const renderer = new SpriteRenderer(mock.canvas)
    const units = renderer.textureUnits
    const frame = { x: 0, y: 0, width: 8, height: 8 }
    // One more distinct page than there are units: the extra one must flush.
    const pages = Array.from({ length: units + 1 }, () => page(renderer))

    renderer.begin({ x: 0, y: 0, zoom: 1 })
    const before = mock.stats.glDrawCalls
    for (const atlas of pages) renderer.draw(frame, 0, 0, { atlas })
    renderer.flush()

    assert(units >= 8, `Context exposes a usable number of texture units (${String(units)})`)
    assert(mock.stats.glDrawCalls - before === 2, 'Exceeding the texture-unit budget costs exactly one extra draw call')
    renderer.dispose()
  }

  // Test 9 (Issue #16): begin() resets the per-frame counters, so the HUD reads
  // this frame's cost rather than an ever-growing total.
  {
    const mock = createMockCanvas()
    const renderer = new SpriteRenderer(mock.canvas)
    const a = page(renderer)
    const frame = { x: 0, y: 0, width: 8, height: 8 }

    renderer.begin({ x: 0, y: 0, zoom: 1 })
    renderer.draw(frame, 0, 0, { atlas: a })
    renderer.flush()
    assert(renderer.drawCalls === 1 && renderer.quadsSubmitted === 1, 'First frame counted')

    renderer.begin({ x: 0, y: 0, zoom: 1 })
    assert(renderer.drawCalls === 0 && renderer.quadsSubmitted === 0, 'begin() resets the per-frame counters')
    renderer.dispose()
  }

  // Test 10 (Issue #16): indexed geometry and the generated sampler switch.
  {
    const mock = createMockCanvas()
    const renderer = new SpriteRenderer(mock.canvas)
    const fragment = mock.stats.shaderSources.find(source => source.includes('u_textures')) ?? ''
    const vertex = mock.stats.shaderSources.find(source => source.includes('a_position')) ?? ''

    assert(fragment.includes('switch (v_unit)'), 'Fragment shader selects the sampler by a constant-case switch')
    assert(
      fragment.includes(`u_textures[${String(renderer.textureUnits)}]`),
      'Sampler array is sized to the units the context actually reports',
    )
    assert(vertex.includes('flat out int v_unit'), 'Texture unit is carried per-vertex, flat-interpolated')
    renderer.dispose()
  }

  // Test 11 (Issue #20): Immutable texture storage (texStorage2D + texSubImage2D)
  {
    const mock = createMockCanvas()
    const renderer = new SpriteRenderer(mock.canvas)

    // In constructor: whiteTexture and setPalette(defaultPal) should have used texStorage2D + texSubImage2D
    assert(mock.stats.texStorage2DCalls >= 2, 'texStorage2D called for initial whiteTexture and paletteTexture')
    assert(mock.stats.texSubImage2DCalls >= 2, 'texSubImage2D called for initial whiteTexture and paletteTexture')

    const beforeStorage = mock.stats.texStorage2DCalls
    const beforeSub = mock.stats.texSubImage2DCalls

    // setAtlas uses texStorage2D on first upload
    const atlas = {
      pixels: new Uint8ClampedArray(64 * 64 * 4),
      width: 64,
      height: 64,
      groups: [],
    }
    renderer.setAtlas(atlas)
    assert(mock.stats.texStorage2DCalls === beforeStorage + 1, 'setAtlas allocates immutable storage via texStorage2D')
    assert(mock.stats.texSubImage2DCalls === beforeSub + 1, 'setAtlas uploads data via texSubImage2D')

    // Calling setAtlas again with SAME dimensions reuses storage (no extra texStorage2D, only texSubImage2D)
    renderer.setAtlas(atlas)
    assert(mock.stats.texStorage2DCalls === beforeStorage + 1, 'setAtlas with same dimensions reuses immutable storage')
    assert(mock.stats.texSubImage2DCalls === beforeSub + 2, 'setAtlas with same dimensions uploads data via texSubImage2D')

    // addAtlas uses texStorage2D and texSubImage2D
    renderer.addAtlas({ pixels: new Uint8ClampedArray(32 * 32 * 4), width: 32, height: 32 })
    assert(mock.stats.texStorage2DCalls === beforeStorage + 2, 'addAtlas allocates immutable storage via texStorage2D')
    assert(mock.stats.texSubImage2DCalls === beforeSub + 3, 'addAtlas uploads data via texSubImage2D')

    // createAtlas alias also uses texStorage2D and texSubImage2D
    renderer.createAtlas({ pixels: new Uint8ClampedArray(16 * 16 * 4), width: 16, height: 16 })
    assert(mock.stats.texStorage2DCalls === beforeStorage + 3, 'createAtlas allocates immutable storage via texStorage2D')
    assert(mock.stats.texSubImage2DCalls === beforeSub + 4, 'createAtlas uploads data via texSubImage2D')

    // addIndexedAtlas uses texStorage2D (R8) and texSubImage2D (RED)
    renderer.addIndexedAtlas(new Uint8Array(16 * 16), 16, 16)
    assert(mock.stats.texStorage2DCalls === beforeStorage + 4, 'addIndexedAtlas allocates immutable storage via texStorage2D')
    assert(mock.stats.texSubImage2DCalls === beforeSub + 5, 'addIndexedAtlas uploads data via texSubImage2D')

    renderer.dispose()
  }

  // Test 12 (Issue #20): Uniform dirty checking and caching in flush()
  {
    const mock = createMockCanvas()
    const renderer = new SpriteRenderer(mock.canvas)
    const frame = { x: 0, y: 0, width: 8, height: 8 }

    renderer.begin({ x: 100, y: 200, zoom: 1.5 })
    renderer.draw(frame, 0, 0)
    renderer.flush()

    assert(mock.stats.uniformCameraCalls === 1, 'First flush uploads camera uniform')
    assert(mock.stats.uniformViewportCalls === 1, 'First flush uploads viewport uniform')
    assert(mock.stats.uniformZoomCalls === 1, 'First flush uploads zoom uniform')

    // Second flush with identical camera/viewport/zoom should NOT re-upload any uniforms
    renderer.draw(frame, 8, 8)
    renderer.flush()

    assert(mock.stats.uniformCameraCalls === 1, 'Consecutive flush with same camera skips camera uniform upload')
    assert(mock.stats.uniformViewportCalls === 1, 'Consecutive flush with same viewport skips viewport uniform upload')
    assert(mock.stats.uniformZoomCalls === 1, 'Consecutive flush with same zoom skips zoom uniform upload')

    // Change only camera
    renderer.begin({ x: 150, y: 200, zoom: 1.5 })
    renderer.draw(frame, 0, 0)
    renderer.flush()

    assert(mock.stats.uniformCameraCalls === 2, 'Only camera uniform is uploaded when camera changes')
    assert(mock.stats.uniformViewportCalls === 1, 'Viewport uniform is not uploaded when viewport did not change')
    assert(mock.stats.uniformZoomCalls === 1, 'Zoom uniform is not uploaded when zoom did not change')

    // Change only zoom
    renderer.begin({ x: 150, y: 200, zoom: 2.0 })
    renderer.draw(frame, 0, 0)
    renderer.flush()

    assert(mock.stats.uniformCameraCalls === 2, 'Camera uniform is not uploaded when camera did not change')
    assert(mock.stats.uniformZoomCalls === 2, 'Only zoom uniform is uploaded when zoom changes')

    renderer.dispose()
  }

  // Test 13 (Issue #20): Configurable shader alphaDiscard option
  {
    const mockDefault = createMockCanvas()
    const rendererDefault = new SpriteRenderer(mockDefault.canvas)
    assert(rendererDefault.alphaDiscard === true, 'alphaDiscard defaults to true')
    const fsDefault = mockDefault.stats.shaderSources.find(s => s.includes('outColor')) ?? ''
    assert(fsDefault.includes('discard;'), 'Default shader includes discard for transparent fragments')
    rendererDefault.dispose()

    const mockNoDiscard = createMockCanvas()
    const rendererNoDiscard = new SpriteRenderer(mockNoDiscard.canvas, { alphaDiscard: false })
    assert(rendererNoDiscard.alphaDiscard === false, 'alphaDiscard can be disabled via RendererOptions')
    const fsNoDiscard = mockNoDiscard.stats.shaderSources.find(s => s.includes('outColor')) ?? ''
    assert(!fsNoDiscard.includes('discard;'), 'Shader with alphaDiscard=false omits discard instructions for mobile GPU optimization')
    assert(fsNoDiscard.includes('outColor = texel * v_tint;'), 'Pure alpha blending used when alphaDiscard=false')
    rendererNoDiscard.dispose()
  }

  // Test 14 (Issue #16): Multi-page level maintains draw calls <= 1 (within batch limits)
  {
    const mock = createMockCanvas()
    const renderer = new SpriteRenderer(mock.canvas)
    // A complex multi-page level with 8 pages:
    // Floors (2 pages), Walls (2 pages), Roofs (1 page), Objects (1 page), Character (1 page), Monsters (1 page)
    const pages = Array.from({ length: 8 }, () => page(renderer))
    const frame = { x: 0, y: 0, width: 16, height: 16 }

    renderer.begin({ x: 0, y: 0, zoom: 1 })
    const beforeDrawCalls = mock.stats.glDrawCalls

    // Simulate drawing a full frame in painter's order across these 8 pages (1200 quads total)
    // 1. Floors (pages 0 & 1)
    for (let i = 0; i < 400; i += 1) {
      renderer.draw(frame, i * 4, 0, { atlas: pages[i % 2] })
    }
    // 2. Walls and objects interleaved (pages 2, 3, 5)
    for (let i = 0; i < 500; i += 1) {
      const pageIndex = i % 3 === 0 ? 5 : i % 3 === 1 ? 2 : 3
      renderer.draw(frame, i * 4, 100, { atlas: pages[pageIndex] })
    }
    // 3. Characters and monsters (pages 6, 7)
    for (let i = 0; i < 100; i += 1) {
      renderer.draw(frame, i * 10, 200, { atlas: pages[6 + (i % 2)] })
    }
    // 4. Roofs (page 4)
    for (let i = 0; i < 200; i += 1) {
      renderer.draw(frame, i * 4, 300, { atlas: pages[4] })
    }
    renderer.flush()

    assert(renderer.quadsSubmitted === 1200, 'Multi-page level submitted all 1200 quads')
    assert(mock.stats.glDrawCalls - beforeDrawCalls === 1, 'Multi-page level (8 pages) rendered in exactly 1 draw call')
    assert(renderer.drawCalls === 1, 'renderer.drawCalls reports 1 draw call')

    // Now verify when distinct pages exceed the hardware texture unit budget
    const overBudgetPages = Array.from({ length: renderer.textureUnits + 4 }, () => page(renderer))
    renderer.begin({ x: 0, y: 0, zoom: 1 })
    const beforeOverCalls = mock.stats.glDrawCalls
    for (let i = 0; i < overBudgetPages.length; i += 1) {
      renderer.draw(frame, i * 16, 0, { atlas: overBudgetPages[i] })
    }
    renderer.flush()
    const extraCalls = mock.stats.glDrawCalls - beforeOverCalls
    assert(
      extraCalls <= Math.ceil(overBudgetPages.length / renderer.textureUnits),
      'Exceeding texture unit budget flushes minimally within batch unit limits',
    )

    renderer.dispose()
  }

  // Test 15 (Issue #16): Viewport culling achieves > 80% quad culling ratio on large levels
  {
    // Generate an 80x80 level (6400 quads) with standard tile size 80x40
    const quads: { x: number; y: number; frame: { width: number; height: number } }[] = []
    const gridCols = 80
    const gridRows = 80
    for (let y = 0; y < gridRows; y += 1) {
      for (let x = 0; x < gridCols; x += 1) {
        quads.push({
          x: x * 80,
          y: y * 40,
          frame: { width: 80, height: 40 },
        })
      }
    }
    const totalQuads = quads.length // 6400
    const bounds = buildBounds(quads)

    // Center camera at (3200, 1600) with standard 1280x720 viewport and zoom = 1
    const view1x = viewportRect(3200, 1600, 1280, 720, 1.0)
    let visible1x = 0
    let culled1x = 0
    const visibleIndices: number[] = []

    for (let i = 0; i < totalQuads; i += 1) {
      if (intersects(bounds, i, view1x)) {
        visible1x += 1
        visibleIndices.push(i)
      } else {
        culled1x += 1
      }
    }

    const cullingRatio1x = culled1x / totalQuads
    assert(totalQuads === 6400, 'Large level has 6400 quads')
    assert(visible1x + culled1x === totalQuads, 'All quads accounted for in culling pass')
    assert(
      cullingRatio1x > 0.80,
      `Viewport culling achieves > 80% culling ratio on 80x80 level (measured: ${(cullingRatio1x * 100).toFixed(1)}%)`,
    )

    // Verify painter's order preservation: visible indices must be strictly monotonic
    let monotonic = true
    for (let i = 1; i < visibleIndices.length; i += 1) {
      if (visibleIndices[i]! <= visibleIndices[i - 1]!) {
        monotonic = false
        break
      }
    }
    assert(monotonic, "Culled stream maintains strictly monotonic painter's order")

    // Test with zoom = 2.0 (tighter viewport -> even higher culling ratio)
    const view2x = viewportRect(3200, 1600, 1280, 720, 2.0)
    let culled2x = 0
    for (let i = 0; i < totalQuads; i += 1) {
      if (!intersects(bounds, i, view2x)) culled2x += 1
    }
    const cullingRatio2x = culled2x / totalQuads
    assert(
      cullingRatio2x > cullingRatio1x && cullingRatio2x > 0.80,
      `Zooming in increases culling ratio (measured: ${(cullingRatio2x * 100).toFixed(1)}%)`,
    )
  }

  // Test 16 (Issue #16): HUD displays accurate measured metrics rather than hardcoded dummies
  {
    const mock = createMockCanvas()
    const renderer = new SpriteRenderer(mock.canvas)
    const a = page(renderer)
    const frame = { x: 0, y: 0, width: 16, height: 16 }

    // Frame 1: Render 120 quads
    const t0 = performance.now()
    renderer.begin({ x: 0, y: 0, zoom: 1 })
    for (let i = 0; i < 120; i += 1) {
      renderer.draw(frame, i, i, { atlas: a })
    }
    renderer.flush()
    const renderMs1 = performance.now() - t0

    const state1 = {
      drawCalls: renderer.drawCalls,
      quadsDrawn: renderer.quadsSubmitted,
      culledDraws: 880,
      renderMs: renderMs1,
    }

    const hudText1 = `${String(state1.quadsDrawn)} 图元 / ${String(state1.drawCalls)} 批次（剔除 ${String(state1.culledDraws)}）· ${state1.renderMs.toFixed(1)} ms`
    assert(state1.drawCalls === 1, 'HUD state drawCalls accurately records 1 draw call')
    assert(state1.quadsDrawn === 120, 'HUD state quadsDrawn accurately records 120 quads')
    assert(state1.culledDraws === 880, 'HUD state culledDraws accurately records 880 culled quads')
    assert(state1.renderMs >= 0, 'HUD state renderMs is a valid measured frame duration')
    assert(hudText1.includes('120 图元 / 1 批次（剔除 880）'), 'HUD string accurately formats measured metrics')

    // Frame 2: Render with over-budget pages to force 2 draw calls and 250 quads
    const overPages = Array.from({ length: renderer.textureUnits + 1 }, () => page(renderer))
    const t1 = performance.now()
    renderer.begin({ x: 0, y: 0, zoom: 1 })
    for (let i = 0; i < 200; i += 1) {
      renderer.draw(frame, i, i, { atlas: overPages[i % renderer.textureUnits] })
    }
    for (let i = 0; i < 50; i += 1) {
      renderer.draw(frame, i, i, { atlas: overPages[renderer.textureUnits] })
    }
    renderer.flush()
    const renderMs2 = performance.now() - t1

    const state2 = {
      drawCalls: renderer.drawCalls,
      quadsDrawn: renderer.quadsSubmitted,
      culledDraws: 1750,
      renderMs: renderMs2,
    }

    const hudText2 = `${String(state2.quadsDrawn)} 图元 / ${String(state2.drawCalls)} 批次（剔除 ${String(state2.culledDraws)}）· ${state2.renderMs.toFixed(1)} ms`
    assert(state2.drawCalls === 2, 'HUD state drawCalls dynamically updates to 2 (not a hardcoded dummy)')
    assert(state2.quadsDrawn === 250, 'HUD state quadsDrawn dynamically updates to 250 (not a hardcoded dummy)')
    assert(state2.culledDraws === 1750, 'HUD state culledDraws dynamically updates to 1750')
    assert(hudText2.includes('250 图元 / 2 批次（剔除 1750）'), 'HUD string reflects dynamic update without hardcoded values')

    renderer.dispose()
  }

  // Test 17 (Issue #16): Memory allocation and performance regression audit
  {
    const mock = createMockCanvas()
    const renderer = new SpriteRenderer(mock.canvas)
    const a = page(renderer)
    const frame = { x: 0, y: 0, width: 8, height: 8 }

    // 1. Buffer growth audit: submitting > INITIAL_CAPACITY (8192) quads
    renderer.begin({ x: 0, y: 0, zoom: 1 })
    for (let i = 0; i < 9000; i += 1) {
      renderer.draw(frame, i % 100, i % 100, { atlas: a })
    }
    assert(renderer.quadsSubmitted === 9000, 'Batch buffer dynamically grows past initial capacity (9000 quads)')
    renderer.flush()
    assert(renderer.drawCalls === 1, 'Large batch (>8192 quads) flushed in single draw call without memory error')

    // 2. Texture cleanup audit on deleteAtlas
    const tempAtlas = page(renderer)
    const texturesBefore = mock.stats.deletedTextures.size
    renderer.deleteAtlas(tempAtlas)
    assert(mock.stats.deletedTextures.size === texturesBefore + 1, 'deleteAtlas promptly frees GPU texture memory')

    renderer.dispose()
  }
  console.log(`\n== Summary: ${String(passed)} passed, ${String(failed)} failed ==`)
  if (failed > 0) process.exit(1)
}

runTests()