export interface Style extends Record<string, unknown> {
  type?: string
  parent?: string
}

export interface StyleSource {
  raw: Record<string, Style>
  constants?: Record<string, unknown>
  fonts?: Record<string, Style>
}

export interface StyleDump extends StyleSource {
  gameVersion: string
  resolved: Record<string, Style>
  constants: Record<string, unknown>
  fonts: Record<string, Style>
}

export type StyleState = 'default' | 'hovered' | 'clicked' | 'disabled' | 'selected'
  | 'selected_hovered' | 'selected_clicked' | 'unchecked' | 'checked' | 'disabled-checked'
  | 'hovered-checked' | 'clicked-checked' | 'intermediate' | 'disabled-intermediate'
export type Pair = [number, number]
export type RGBA = [number, number, number, number]
export type Rect = [number, number, number, number]
export type Sides = { top: number, right: number, bottom: number, left: number }
export const PIECES = ['left_top', 'top', 'right_top', 'left', 'center', 'right', 'left_bottom', 'bottom', 'right_bottom'] as const
export type PieceName = typeof PIECES[number]

export interface StyleSprite {
  filename: string
  position: Pair
  size: Pair
  scale: number
  tint: RGBA
  opacity: number
  blend_mode?: string
}

export interface StyleLayer extends StyleSprite {
  name: string
  corner_size?: Pair
  borders: Sides
  draw_type: 'inner' | 'outer'
  /** Positive distances outside the widget; shifts may produce negative values (insets). */
  outerExtent: Sides
  outerBorderShift: Sides
  pieces: Partial<Record<PieceName, StyleSprite>>
  tiling: Record<string, unknown>
  stretchMonolith: boolean
}

export interface ResolvedStyle {
  name: string
  state: StyleState
  metrics: Record<'minimal_width' | 'maximal_width' | 'natural_width' | 'minimal_height' | 'maximal_height' | 'natural_height', number>
  padding: Sides
  cellPadding: Sides
  offsets: Record<string, number>
  contentOffset: Pair
  font?: string
  fontDefinition?: Style
  fontColor?: RGBA
  layers: StyleLayer[]
  applyRowGraphicalSetPerColumn: boolean
}

function table(value: unknown): Style {
  return value && typeof value === 'object' && !Array.isArray(value) ? value as Style : {}
}

function number(value: unknown, fallback = 0): number {
  return typeof value === 'number' ? value : fallback
}

function pair(value: unknown, fallback = 0): Pair {
  if (typeof value === 'number') return [value, value]
  if (Array.isArray(value)) return [number(value[0], fallback), number(value[1], fallback)]
  const v = table(value)
  return [number(v.x, fallback), number(v.y, fallback)]
}

/** Factorio chooses the 0–255 range if any component exceeds 1, including alpha. */
export function rgba(value: unknown): RGBA {
  const v = Array.isArray(value) ? value : [table(value).r, table(value).g, table(value).b, table(value).a]
  const byte = v.some(c => typeof c === 'number' && c > 1)
  const scale = byte ? 1 : 255
  return [0, 1, 2, 3].map(i => Math.max(0, Math.min(255, number(v[i], i === 3 ? (byte ? 255 : 1) : 0) * scale))) as RGBA
}

function expand(style: Style): Style {
  const out = { ...style }
  for (const axis of ['width', 'height'] as const) {
    const i = axis === 'width' ? 0 : 1
    const fixed = style[axis] ?? (style.size === undefined ? undefined : pair(style.size)[i])
    for (const kind of ['minimal', 'maximal', 'natural'] as const) {
      const key = `${kind}_${axis}`
      if (style[key] === undefined && fixed !== undefined) out[key] = fixed
    }
    if (style.natural_size !== undefined && style[`natural_${axis}`] === undefined) out[`natural_${axis}`] = pair(style.natural_size)[i]
  }
  for (const side of ['top', 'right', 'bottom', 'left']) {
    for (const kind of ['padding', 'margin', 'cell_padding']) {
      if (style[kind] !== undefined && style[`${side}_${kind}`] === undefined) out[`${side}_${kind}`] = style[kind]
    }
  }
  return out
}

/** Nested values replace the inherited value. Deep merging is deliberately not assumed. */
export function inheritStyles(styles: Record<string, Style>): Record<string, Style> {
  const result: Record<string, Style> = {}
  const visiting = new Set<string>()
  const visit = (name: string): Style => {
    if (Object.hasOwn(result, name)) return result[name]!
    const own = Object.hasOwn(styles, name) ? styles[name] : undefined
    if (!own) throw new Error(`Unknown style: ${name}`)
    if (visiting.has(name)) throw new Error(`Style inheritance cycle: ${[...visiting, name].join(' -> ')}`)
    visiting.add(name)
    const root = own.type?.replace(/_style$/, '')
    const parent = own.parent ?? (root && root !== name && Object.hasOwn(styles, root) ? root : undefined)
    result[name] = { ...(parent ? visit(parent) : {}), ...expand(own) }
    visiting.delete(name)
    return result[name]!
  }
  for (const name of Object.keys(styles)) visit(name)
  return result
}

function sprite(value: Style, defaults: StyleSprite): StyleSprite {
  const size = value.size === undefined ? [number(value.width), number(value.height)] as Pair : pair(value.size)
  const ownTint = value.tint === undefined ? [255, 255, 255, 255] as RGBA : rgba(value.tint)
  return {
    filename: typeof value.filename === 'string' ? value.filename : defaults.filename,
    position: value.x !== undefined || value.y !== undefined ? [number(value.x), number(value.y)] : pair(value.position),
    size,
    scale: number(value.scale, defaults.scale),
    tint: ownTint.map((c, i) => c * defaults.tint[i]! / 255) as RGBA,
    opacity: number(value.opacity, 1) * defaults.opacity,
    blend_mode: typeof value.blend_mode === 'string' ? value.blend_mode : defaults.blend_mode,
  }
}

function layer(value: unknown, name: string, constants: Record<string, unknown>): StyleLayer | undefined {
  const v = table(value)
  if (v.type === 'none' || !Object.keys(v).length) return
  const defaults: StyleSprite = {
    filename: typeof constants.default_tileset === 'string' ? constants.default_tileset : '__core__/graphics/gui-new.png',
    scale: number(constants.default_sprite_scale, 0.5),
    position: [0, 0], size: [0, 0], tint: [255, 255, 255, 255], opacity: 1,
  }
  const base = sprite(v, defaults)
  const pieces: StyleLayer['pieces'] = {}
  let corner: Pair | undefined
  if (v.corner_size !== undefined) {
    corner = pair(v.corner_size)
    const [cx, cy] = corner
    const [x, y] = base.position
    const cw = number(v.center_width, 1), ch = number(v.center_height, 1)
    const rects: Record<PieceName, Rect> = {
      left_top: [x, y, cx, cy], top: [x + cx, y, number(v.top_width, 1), cy],
      right_top: [x + cx + cw, y, cx, cy], left: [x, y + cy, cx, number(v.left_height, 1)],
      center: [x + cx, y + cy, cw, ch], right: [x + cx + cw, y + cy, cx, number(v.right_height, 1)],
      left_bottom: [x, y + cy + ch, cx, cy], bottom: [x + cx, y + cy + ch, number(v.bottom_width, 1), cy],
      right_bottom: [x + cx + cw, y + cy + ch, cx, cy],
    }
    for (const key of PIECES) {
      const [px, py, w, h] = rects[key]
      if (w > 0 && h > 0) pieces[key] = { ...base, position: [px, py], size: [w, h] }
    }
    base.size = [2 * cx + cw, 2 * cy + ch]
  } else if (base.size[0] > 0 && base.size[1] > 0) {
    pieces.center = base
  }
  for (const key of PIECES) {
    if (v[key] !== undefined) {
      const piece = table(v[key])
      if (piece.type === 'none' || !Object.keys(piece).length) delete pieces[key]
      else pieces[key] = sprite(piece, base)
    }
  }
  const extent = (keys: PieceName[], axis: 0 | 1) => Math.max(0, ...keys.map(key => pieces[key] ? pieces[key]!.size[axis] * pieces[key]!.scale : 0))
  const borders: Sides = {
    top: number(v.top_border, number(v.border, extent(['left_top', 'top', 'right_top'], 1))),
    right: number(v.right_border, number(v.border, extent(['right_top', 'right', 'right_bottom'], 0))),
    bottom: number(v.bottom_border, number(v.border, extent(['left_bottom', 'bottom', 'right_bottom'], 1))),
    left: number(v.left_border, number(v.border, extent(['left_top', 'left', 'left_bottom'], 0))),
  }
  const outerBorderShift: Sides = {
    top: number(v.top_outer_border_shift), right: number(v.right_outer_border_shift),
    bottom: number(v.bottom_outer_border_shift), left: number(v.left_outer_border_shift),
  }
  const draw = v.draw_type === 'outer' ? 'outer' : 'inner'
  const outerExtent: Sides = { top: 0, right: 0, bottom: 0, left: 0 }
  if (draw === 'outer') {
    outerExtent.top = borders.top - outerBorderShift.top
    outerExtent.left = borders.left - outerBorderShift.left
    outerExtent.bottom = borders.bottom + outerBorderShift.bottom
    outerExtent.right = borders.right + outerBorderShift.right
  }
  return {
    ...base, name, corner_size: corner, borders, draw_type: draw, outerExtent, outerBorderShift, pieces,
    tiling: Object.fromEntries(Object.entries(v).filter(([key]) => key.includes('tiling'))),
    stretchMonolith: v.stretch_monolith_image_to_size !== false,
  }
}

export function resolve(styles: StyleSource, name: string, state: StyleState = 'default'): ResolvedStyle {
  const s = inheritStyles(styles.raw)[name]
  if (!s) throw new Error(`Unknown style: ${name}`)
  const constants = styles.constants ?? {}
  const layers: StyleLayer[] = []
  const add = (value: unknown, prefix = '') => {
    const set = table(value)
    if (['shadow', 'base', 'glow'].some(key => key in set)) {
      for (const key of ['shadow', 'base', 'glow']) {
        const item = layer(set[key], prefix + key, constants)
        if (item) layers.push(item)
      }
    } else {
      const item = layer(set, prefix + 'base', constants)
      if (item) layers.push(item)
    }
  }
  const visualState = state.startsWith('disabled') ? 'disabled' : state === 'checked' ? 'selected'
    : state === 'hovered-checked' ? 'selected_hovered' : state === 'clicked-checked' ? 'selected_clicked'
    : state === 'unchecked' || state === 'intermediate' ? 'default' : state
  const fallback = visualState.startsWith('selected_') ? s.selected_graphical_set : undefined
  add(s.background_graphical_set, 'background.')
  add(s[`${visualState}_graphical_set`] ?? fallback ?? s.default_graphical_set ?? s.default_row_graphical_set ?? s.graphical_set)
  if (s.type === 'checkbox_style' || s.type === 'radiobutton_style') {
    for (const item of layers) item.stretchMonolith = false
  }
  const mark = state.includes('intermediate') ? s.intermediate_mark : state === 'checked' || state.endsWith('-checked') ? (visualState === 'disabled' ? s.disabled_checkmark ?? s.checkmark : s.checkmark) : undefined
  if (mark !== undefined) {
    const item = layer(mark, state.includes('intermediate') ? 'intermediate_mark' : 'checkmark', constants)
    if (item) { item.stretchMonolith = false; layers.push(item) }
  }
  const metrics = {} as ResolvedStyle['metrics']
  for (const key of ['minimal_width', 'maximal_width', 'natural_width', 'minimal_height', 'maximal_height', 'natural_height'] as const) metrics[key] = number(s[key])
  const padding = { top: number(s.top_padding), right: number(s.right_padding), bottom: number(s.bottom_padding), left: number(s.left_padding) }
  const cellPadding = { top: number(s.top_cell_padding), right: number(s.right_cell_padding), bottom: number(s.bottom_cell_padding), left: number(s.left_cell_padding) }
  const offsets = Object.fromEntries(Object.entries(s).filter(([k, v]) => k.endsWith('_offset') && typeof v === 'number')) as Record<string, number>
  const fontColor = s[`${visualState}_font_color`] ?? (visualState.startsWith('selected_') ? s.selected_font_color : undefined) ?? s.default_font_color ?? s.font_color
  const font = typeof s.font === 'string' ? s.font : undefined
  return {
    name, state, metrics, padding, cellPadding, offsets,
    contentOffset: [number(s[`${visualState}_horizontal_offset`]), number(s[`${visualState}_vertical_offset`])],
    font, fontDefinition: font ? styles.fonts?.[font] : undefined,
    fontColor: fontColor === undefined ? undefined : rgba(fontColor), layers,
    applyRowGraphicalSetPerColumn: s.apply_row_graphical_set_per_column === true,
  }
}
