// Copyright (c) 2026 Delyan Angelov. All rights reserved.
// The use of this source code is governed by the MIT license.
module main

import gg
import os.asset
import rand

const n = 4
const tile = 110
const gap = 10
const pad = 24
const head = 52
const r = f32(18)
const speed = f32(0.14)
const board_px = n * tile + (n - 1) * gap
const width = pad * 2 + board_px
const height = head + board_px + 62
const wcolor = gg.rgb(104, 93, 79)

@[heap]
struct Game {
mut:
	ctx   &gg.Context = unsafe { nil }
	board []int
	moves int
	won   bool
	anim  bool
	t     f32
	from  int = -1
	to    int = -1
	val   int
}

fn main() {
	mut g := &Game{}
	g.shuffle()
	g.ctx = gg.new_context(
		bg_color:     gg.rgb(247, 244, 235)
		width:        width
		height:       height
		sample_count: 4
		window_title: '15 Puzzle'
		user_data:    g
		frame_fn:     frame
		event_fn:     event
		font_path:    asset.get_path('../assets', 'fonts/Graduate-Regular.ttf')
	)
	g.ctx.run()
}

fn frame(mut g Game) {
	g.step()
	g.ctx.begin()
	g.header()
	g.board()
	g.ctx.end()
}

fn event(e &gg.Event, mut g Game) {
	if e.typ == .key_down {
		match e.key_code {
			.escape {
				g.ctx.quit()
			}
			.r {
				g.shuffle()
			}
			.up, .w {
				if !g.anim {
					g.slide(1, 0)
				}
			}
			.down, .s {
				if !g.anim {
					g.slide(-1, 0)
				}
			}
			.left, .a {
				if !g.anim {
					g.slide(0, 1)
				}
			}
			.right, .d {
				if !g.anim {
					g.slide(0, -1)
				}
			}
			else {}
		}

		return
	}
	if !g.anim && e.typ == .mouse_down && e.mouse_button == .left {
		if i := g.hit(int(e.mouse_x), int(e.mouse_y)) {
			g.move(i)
		}
	}
}

fn (mut g Game) header() {
	g.ctx.draw_text(width / 2, 16, if g.won {
		'Solved in ${g.moves} moves. Press R to reshuffle.'
	} else {
		'Moves: ${g.moves}'
	},
		size:  if g.won { 16 } else { 20 }
		bold:  true
		align: .center
		color: if g.won { wcolor } else { gg.rgb(48, 44, 37) }
	)
}

fn (mut g Game) board() {
	g.ctx.draw_rect_filled(pad - 8, head - 8, board_px + 16, board_px + 16, gg.rgb(218, 206, 188))
	for i, v in g.board {
		if g.anim && i == g.from {
			continue
		}
		x, y := xy(i)
		g.tile(x, y, v, v != 0 && v == i + 1)
	}
	if g.anim {
		x0, y0 := xy(g.from)
		x1, y1 := xy(g.to)
		g.tile(int(f32(x0) + f32(x1 - x0) * g.t), int(f32(y0) + f32(y1 - y0) * g.t), g.val, false)
	}
	g.ctx.draw_text(pad, head + board_px + 22,
		'Arrow keys / WASD or click a tile next to the empty space.',
		size:  16
		color: wcolor
	)
	g.ctx.draw_text(width / 2, height - 18, '[R] Shuffle  [Esc] Quit',
		size:           16
		bold:           true
		align:          .center
		vertical_align: .middle
		color:          wcolor
	)
}

fn (mut g Game) tile(x int, y int, v int, ok bool) {
	fill, border := if v == 0 {
		gg.rgb(238, 232, 220), gg.rgb(210, 202, 191)
	} else if ok {
		gg.rgb(214, 173, 108), gg.rgb(168, 121, 56)
	} else {
		gg.rgb(84, 110, 122), gg.rgb(48, 66, 74)
	}
	g.ctx.draw_rounded_rect_filled(x, y, tile, tile, r, fill)
	g.ctx.draw_rounded_rect_empty(x, y, tile, tile, r, border)
	if v != 0 {
		g.ctx.draw_text(x + tile / 2, y + tile / 2, v.str(),
			size:           42
			bold:           true
			align:          .center
			vertical_align: .middle
			color:          gg.white
		)
	}
}

fn (mut g Game) shuffle() {
	g.board = []int{len: n * n}
	for i in 0 .. g.board.len - 1 {
		g.board[i] = i + 1
	}
	for _ in 0 .. 300 {
		e := g.board.index(0)
		ns := neighbors(e)
		j := ns[rand.intn(ns.len) or { 0 }]
		g.board[e], g.board[j] = g.board[j], g.board[e]
	}
	if done(g.board) {
		g.board[g.board.len - 2], g.board[g.board.len - 3] = g.board[g.board.len - 3], g.board[g.board.len - 2]
	}
	g.moves, g.won, g.anim, g.t, g.from, g.to, g.val = 0, false, false, 0, -1, -1, 0
}

fn (mut g Game) slide(dr int, dc int) {
	e := g.board.index(0)
	row, col := e / n + dr, e % n + dc
	if row >= 0 && row < n && col >= 0 && col < n {
		g.move(row * n + col)
	}
}

fn (mut g Game) move(i int) bool {
	if g.won || g.anim || i < 0 || i >= g.board.len || g.board[i] == 0 {
		return false
	}
	e := g.board.index(0)
	dr, dc := i / n - e / n, i % n - e % n
	if !((dr == 0 && (dc == 1 || dc == -1)) || (dc == 0 && (dr == 1 || dr == -1))) {
		return false
	}
	g.anim, g.t, g.from, g.to, g.val = true, 0, i, e, g.board[i]
	return true
}

fn (mut g Game) step() {
	if !g.anim {
		return
	}
	g.t += speed
	if g.t < 1 {
		return
	}
	g.board[g.to], g.board[g.from] = g.val, 0
	g.moves++
	g.won = done(g.board)
	g.anim, g.t, g.from, g.to, g.val = false, 0, -1, -1, 0
}

fn (g &Game) hit(mx int, my int) ?int {
	if mx < pad || my < head || mx >= pad + board_px || my >= head + board_px {
		return none
	}
	x, y := mx - pad, my - head
	col, row := x / (tile + gap), y / (tile + gap)
	if x % (tile + gap) >= tile || y % (tile + gap) >= tile {
		return none
	}
	return row * n + col
}

fn neighbors(i int) []int {
	row, col := i / n, i % n
	mut ns := []int{}
	if row > 0 {
		ns << i - n
	}
	if row + 1 < n {
		ns << i + n
	}
	if col > 0 {
		ns << i - 1
	}
	if col + 1 < n {
		ns << i + 1
	}
	return ns
}

fn xy(i int) (int, int) {
	return pad + (i % n) * (tile + gap), head + (i / n) * (tile + gap)
}

fn done(b []int) bool {
	for i in 0 .. b.len - 1 {
		if b[i] != i + 1 {
			return false
		}
	}
	return b[b.len - 1] == 0
}