import { afterEach, describe, expect, test } from 'bun:test'
import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import path from 'node:path'
import { inheritStyles, resolve, type Style, type StyleDump } from '../src/core/gameStyle'
import { composeLayer, precomposePixel, ensurePieces, gameTint, piecesCurrent, writePieces, type PiecesIndex } from '../tools/pieces'
import { decodePng, encodePng, type Image } from '../tools/bench/png'

const dirs: string[] = []
const temp = () => {
  const dir = mkdtempSync(path.join(tmpdir(), 'factorio-pieces-'))
  dirs.push(dir)
  return dir
}
afterEach(() => { for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true }) })

const atlas: Image = { width: 17, height: 17, data: new Uint8Array(17 * 17 * 4) }
for (let y = 0; y < atlas.height; y++) {
  for (let x = 0; x < atlas.width; x++) atlas.data.set([x * 10, y * 10, 100, 255], (y * atlas.width + x) * 4)
}
const layer = (set: Style) => resolve({ raw: { box: { graphical_set: set } } }, 'box').layers[0]!

describe('atlas piece composition', () => {
  test('precomposes additive tint against its declared opaque backdrop', () => {
    const source = [255, 255, 255, 173] as [number, number, number, number]
    const tint = [135, 216, 139, 128] as [number, number, number, number]
    const backdrop = [49, 48, 49, 255] as [number, number, number, number]
    const actual = precomposePixel(source, tint, 1, backdrop)
    for (let c = 0; c < 3; c++) expect(Math.abs(actual[c]! - (tint[c]! * 173 / 255 + backdrop[c]! * (1 - 173 / 255 * 128 / 255)))).toBeLessThanOrEqual(1)
    expect(actual[3]).toBe(255)
    const dump = fixture()
    dump.raw.green_button = { graphical_set: { base: { position: [0, 0], corner_size: 8 }, glow: { position: [0, 0], corner_size: 8, tint, draw_type: 'outer' } } }
    const out = temp()
    const index = writePieces(dump, 1, out, () => atlas)
    expect(index.format).toBe(4)
    const p = index.pieces['green_button-hovered-precomposed']!
    expect(p.backdrop?.name).toBe('subheader')
    expect(p.backdrop?.color).toEqual([36, 35, 36, 255])
    const pixel = decodePng(readFileSync(path.join(out, '1', p.file))).data.slice(0, 4)
    // This corner lies outside the face: the synthetic atlas averages to
    // (5,5,100,255), and its glow is applied directly over the declared backdrop.
    for (let c = 0; c < 3; c++) {
      const expected = [5, 5, 100][c]! * tint[c]! / 255 + p.backdrop!.color[c]! * (1 - 128 / 255)
      expect(Math.abs(pixel[c]! - expected)).toBeLessThanOrEqual(1)
    }
    expect(pixel[3]).toBe(255)
  })

  test('uses truncation when composing an exact 2:1 atlas sprite', () => {
    const image: Image = { width: 2, height: 2, data: new Uint8Array([
      10, 20, 30, 255, 11, 21, 31, 255,
      11, 21, 31, 255, 11, 21, 31, 255,
    ]) }
    const piece = composeLayer(layer({ position: [0, 0], size: 2 }), 1, () => image)
    expect([...piece.image.data]).toEqual([10, 20, 30, 255])
  })

  test('aligns unequal tab-glow corners and straight bands at the outer edge', () => {
    const piece = composeLayer(layer({
      draw_type: 'outer',
      left_top: { position: [0, 0], size: 8 }, right_top: { position: [9, 0], size: 8 },
      top: { position: [8, 0], size: [1, 4] },
      left: { position: [0, 8], size: [4, 1] }, right: { position: [13, 8], size: [4, 1] },
    }), 1, () => atlas)
    expect([...piece.image.data.slice(4 * 4, 4 * 4 + 4)]).toEqual([80, 5, 100, 255])
    const side = 4 * piece.image.width * 4
    expect([...piece.image.data.slice(side, side + 4)]).toEqual([5, 80, 100, 255])
  })

  test('cuts regions and joins corners, edges and an overridden center in Slint order', () => {
    const result = composeLayer(layer({ position: [0, 0], corner_size: 8, center: { position: [16, 16], size: 1 } }), 1, () => atlas)
    expect(result.image.width).toBe(9)
    expect(result.image.height).toBe(9)
    expect([...result.image.data.slice(0, 4)]).toEqual([5, 5, 100, 255])
    expect([...result.image.data.slice((4 * 9 + 4) * 4, (4 * 9 + 4) * 4 + 4)]).toEqual([160, 160, 100, 255])
    expect(result.metadata.nineSlice).toEqual([4, 4, 4, 4])
    expect(result.metadata.source.center!.rect).toEqual([16, 16, 1, 1])
    expect(decodePng(encodePng(result.image))).toEqual(result.image)
  })

  test('uses exact 2:1 and 1.6:1 area weights at the requested scale', () => {
    const sprite = layer({ position: [0, 0], size: [8, 8] })
    const one = composeLayer(sprite, 1, () => atlas)
    const fractional = composeLayer(sprite, 1.25, () => atlas)
    expect(one.metadata.screenSize).toEqual([4, 4])
    expect([...one.image.data.slice(0, 4)]).toEqual([5, 5, 100, 255])
    expect(fractional.metadata.screenSize).toEqual([5, 5])
    // First footprint [0,1.6): weights 1 and .6; next [1.6,3.2): .4,1,.2.
    expect([...fractional.image.data.slice(0, 8)]).toEqual([4, 4, 100, 255, 19, 4, 100, 255])
    expect(composeLayer(layer({ position: [0, 0], corner_size: 8 }), 1.25, () => atlas).metadata.nineSlice).toEqual([5, 5, 5, 5])
  })

  test('filters premultiplied alpha before applying the game tint', () => {
    const image: Image = { width: 2, height: 2, data: new Uint8Array([200, 100, 50, 255, 0, 0, 255, 0, 200, 100, 50, 255, 0, 0, 255, 0]) }
    const piece = composeLayer(layer({ position: [0, 0], size: 2, tint: [32, 16, 8, 128], opacity: 0.5 }), 1, () => image)
    expect([...piece.image.data]).toEqual([50, 12, 3, 32])
    expect([...gameTint(image, [0, 0, 0, 0], 1).data]).toEqual(new Array(16).fill(0))
    expect(image.data[0]).toBe(200)
  })

  test('keeps fractional fixed-sprite screen dimensions separate from the integer PNG', () => {
    const piece = composeLayer(layer({ position: [0, 0], size: 12 }), 1.25, () => atlas)
    expect(piece.metadata.screenSize).toEqual([7.5, 7.5])
    expect(piece.metadata.rasterSize).toEqual([8, 8])
    expect(piece.metadata.nineSlice).toEqual([0, 0, 0, 0])
  })

  test('filters odd scrollbar caps together instead of rounding each cap independently', () => {
    const piece = composeLayer(layer({ top: { position: [0, 0], size: [8, 7] }, center: { position: [8, 0], size: [8, 8] }, bottom: { position: [0, 8], size: [8, 7] }, center_tiling_vertical: true }), 1, () => atlas)
    expect(piece.metadata.screenSize).toEqual([4, 11])
    expect(piece.metadata.rasterSize).toEqual([4, 11])
    expect([...piece.image.data.slice(3 * 4 * 4, 3 * 4 * 4 + 4)]).toEqual([45, 30, 100, 255])
  })

  test('scales outer extents, retaining shifts separately from nine-slice corners', () => {
    const piece = composeLayer(layer({ position: [0, 0], corner_size: 8, draw_type: 'outer', left_outer_border_shift: 2, bottom_outer_border_shift: -1 }), 1.25, () => atlas)
    expect(piece.metadata.outerExtent).toEqual({ top: 5, right: 5, bottom: 3.75, left: 2.5 })
    expect(piece.metadata.nineSlice).toEqual([5, 5, 5, 5])
  })

  test('assembles a full-height tip and the opposite straight side without stretching the tip vertically', () => {
    const set = layer({ left: { position: [0, 0], size: [8, 16] }, center: { position: [8, 0], size: [1, 16] }, right_top: { position: [9, 0], size: 2 }, right: { position: [9, 2], size: [2, 1] }, right_bottom: { position: [9, 3], size: 2 } })
    const piece = composeLayer(set, 1, () => atlas)
    expect(piece.metadata.screenSize).toEqual([6, 8])
    expect(piece.metadata.nineSlice).toEqual([0, 1, 0, 4])
    expect(piece.metadata.fixedHeight).toBe(8)
    expect([...piece.image.data.slice(0, 4)]).toEqual([5, 5, 100, 255])
  })

  test('rejects invalid geometry and out-of-atlas cuts', () => {
    expect(() => composeLayer(layer({ position: [16, 16], size: 4 }), 1, () => atlas)).toThrow('outside')
    expect(() => composeLayer(layer({ position: [0, 0], size: 4, scale: 0 }), 1, () => atlas)).toThrow('Invalid sprite geometry')
  })
})

function fixture(): StyleDump {
  const raw: Record<string, Style> = {}
  const set = { position: [0, 0], corner_size: 8 }
  const names = ['frame', 'inside_shallow_frame', 'inside_deep_frame', 'mod_thumbnail_image', 'mod_explore_thumbnail_image', 'mods_scroll_pane', 'scroll_pane', 'subheader_frame', 'negative_message_frame', 'tabbed_pane_frame', 'button', 'green_button', 'red_button', 'back_button', 'confirm_button', 'dropdown_button', 'tool_button', 'tool_button_red', 'tab', 'table_with_selection', 'mods_explore_results_table', 'list_box_item', 'checkbox', 'black_checkbox']
  for (const name of names) raw[name] = { graphical_set: set }
  for (const name of ['draggable_space', 'draggable_space_header']) raw[name] = { graphical_set: { top: { position: [0, 0], size: [8, 7] }, center: { position: [8, 0], size: [8, 8] }, bottom: { position: [0, 8], size: [8, 8] }, center_tiling_horizontal: true } }
  for (const name of ['textbox', 'search_popup_textfield']) raw[name] = { default_background: set, active_background: set, disabled_background: set }
  for (const state of ['default', 'hover', 'press', 'disabled', 'selected']) raw.tab![`${state}_badge_graphical_set`] = set
  for (const name of ['vertical_scrollbar', 'horizontal_scrollbar']) raw[name] = { graphical_set: set, thumb_button_style: { default_graphical_set: set, hovered_graphical_set: set, clicked_graphical_set: set } }
  for (const name of ['line', 'bordered_table']) raw[name] = { border: { left_end: { position: [0, 0], size: 8 }, horizontal_line: { position: [8, 0], size: [1, 8] }, right_end: { position: [9, 0], size: 8 } } }
  raw.checkbox = { type: 'checkbox_style', default_graphical_set: set, selected_graphical_set: set, disabled_graphical_set: set, checkmark: { position: [0, 0], size: 8 }, disabled_checkmark: { position: [8, 8], size: 8 } }
  return { gameVersion: '2.0.test', raw, resolved: inheritStyles(raw), constants: {}, fonts: {} }
}

describe('piece index and startup cache in temporary directories', () => {
  test('writes PNGs, source metadata, ordered checkmarks, and phase-correct rib tiles', () => {
    const out = temp()
    const index = writePieces(fixture(), 1, out, () => atlas, 'fixture')
    expect(index.gameVersion).toBe('2.0.test')
    expect(index.entries['checkbox:disabled-checked']).toEqual(['checkbox-disabled-checked-base', 'checkbox-disabled-checked-checkmark'])
    expect(index.pieces['checkbox-disabled-checked-checkmark']!.source.center!.rect).toEqual([8, 8, 8, 8])
    const ribs = decodePng(readFileSync(path.join(out, '1/draggable_space-24-base.png')))
    expect([ribs.width, ribs.height]).toEqual([4, 24])
    // Output row 3 averages source top row 6 with the first centre row, not two capped rows.
    expect([...ribs.data.slice(3 * 4 * 4, 3 * 4 * 4 + 4)]).toEqual([45, 30, 100, 255])
    expect(piecesCurrent(index, '2.0.test', 1, 'fixture', path.join(out, '1'))).toBe(true)
    expect(piecesCurrent(index, '2.1', 1, 'fixture', path.join(out, '1'))).toBe(false)
    expect(piecesCurrent(index, '2.0.test', 1.25, 'fixture', path.join(out, '1'))).toBe(false)
    expect(piecesCurrent(index, '2.0.test', 1, 'changed', path.join(out, '1'))).toBe(false)
    expect(piecesCurrent({ ...index, format: 0 }, '2.0.test', 1, 'fixture', path.join(out, '1'))).toBe(false)
    rmSync(path.join(out, '1/checkbox-disabled-checked-checkmark.png'))
    expect(piecesCurrent(index, '2.0.test', 1, 'fixture', path.join(out, '1'))).toBe(false)
  })

  test('ensurePieces reuses a current cache and repairs corrupt, missing, or stale indexes', async () => {
    const dir = temp()
    const install = path.join(dir, 'install')
    const styles = path.join(dir, 'styles.json')
    const out = path.join(dir, 'pieces')
    const files: Record<string, string | Uint8Array> = {
      'data/base/info.json': JSON.stringify({ version: '2.0.test' }),
      'data/core/prototypes/style.lua': '', 'data/core/prototypes/fonts.lua': '', 'data/core/locale/en/info.json': '{}',
      'data/core/graphics/gui-new.png': encodePng(atlas),
    }
    for (const [file, data] of Object.entries(files)) {
      mkdirSync(path.dirname(path.join(install, file)), { recursive: true })
      writeFileSync(path.join(install, file), data)
    }
    writeFileSync(styles, JSON.stringify(fixture()))
    const options = { install, styles, out }
    const first = await ensurePieces(1, options)
    const indexPath = path.join(out, '1/index.json')
    const time = statSync(indexPath).mtimeMs
    expect(await ensurePieces(1, options)).toEqual(first)
    expect(statSync(indexPath).mtimeMs).toBe(time)
    writeFileSync(indexPath, '{broken')
    expect(await ensurePieces(1, options)).toEqual(first)
    const png = path.join(out, '1/button-default-base.png')
    rmSync(png)
    await ensurePieces(1, options)
    expect(existsSync(png)).toBe(true)
    const changed = fixture()
    changed.raw.button!.graphical_set = { position: [0, 0], size: 8 }
    writeFileSync(styles, JSON.stringify(changed))
    const next = await ensurePieces(1, options)
    expect(next.fingerprint).not.toBe(first.fingerprint)
    expect(next.pieces['button-default-base']!.screenSize).toEqual([4, 4])
    const stale = JSON.parse(readFileSync(indexPath, 'utf8')) as PiecesIndex
    stale.gameVersion = 'old'
    writeFileSync(indexPath, JSON.stringify(stale))
    expect((await ensurePieces(1, options)).gameVersion).toBe('2.0.test')
    await expect(ensurePieces(2 as 1, options)).rejects.toThrow('Scale must be 1 or 1.25')
  })
})
