module main

import gg
import rand
import os.asset

const header_size = 30

enum Cell {
	empty
	n1
	n2
	n3
	n4
	n5
	n6
	n7
	n8
	mine
}

@[heap]
struct Game {
mut:
	ctx           &gg.Context = unsafe { nil }
	grid          [][]Cell
	flags         [][]bool
	revealed      [][]bool
	size          int = 10 // in cells
	csize         int = 30 // in pixels
	game_over     bool
	first_click   bool = true
	mines         int  = 10
	mines_flagged int
}

@[inline]
fn (mut g Game) in_grid(cy int, cx int) bool {
	return cx >= 0 && cx < g.size && cy >= 0 && cy < g.size
}

fn (mut g Game) generate_mines(first_y int, first_x int) {
	mut mines_placed := 0
	for mines_placed < g.mines {
		x, y := rand.intn(g.size) or { 0 }, rand.intn(g.size) or { 0 }
		// avoid placing mines at the position of the first click
		if (x == first_x && y == first_y) || g.grid[y][x] == .mine {
			continue
		}
		g.grid[y][x] = .mine
		mines_placed++
	}
	for y in 0 .. g.size {
		for x in 0 .. g.size {
			if g.grid[y][x] == .mine {
				continue
			}
			mut count := 0
			for dy in -1 .. 2 {
				for dx in -1 .. 2 {
					cy, cx := y + dy, x + dx
					if g.in_grid(cy, cx) {
						if g.grid[cy][cx] == .mine {
							count++
						}
					}
				}
			}
			g.grid[y][x] = unsafe { Cell(count) }
		}
	}
}

fn (mut g Game) reveal(y int, x int) {
	if !g.in_grid(y, x) {
		return
	}
	if g.revealed[y][x] {
		return
	}
	g.revealed[y][x] = true
	if g.grid[y][x] == .mine {
		g.game_over = true
		return
	}
	if g.grid[y][x] == .empty {
		for dy in -1 .. 2 {
			for dx in -1 .. 2 {
				g.reveal(y + dy, x + dx)
			}
		}
	}
}

fn (mut g Game) restart() {
	g.grid = [][]Cell{len: g.size, init: []Cell{len: g.size}}
	g.flags = [][]bool{len: g.size, init: []bool{len: g.size}}
	g.revealed = [][]bool{len: g.size, init: []bool{len: g.size}}
	g.game_over = false
	g.first_click = true
	g.mines_flagged = 0
}

fn on_event(e &gg.Event, mut g Game) {
	if e.typ == .key_down {
		match e.key_code {
			.escape { g.ctx.quit() }
			.r { g.restart() }
			else {}
		}
		return
	}
	if g.game_over {
		return
	}
	if e.typ != .mouse_down {
		return
	}
	x := int(e.mouse_x / g.csize)
	y := int((e.mouse_y - header_size) / g.csize)
	if e.mouse_button == .left {
		if g.first_click {
			g.generate_mines(y, x)
			g.first_click = false
		}
		g.reveal(y, x)
	}
	if e.mouse_button == .right {
		if !g.revealed[y][x] {
			old := g.flags[y][x]
			g.flags[y][x] = !old
			g.mines_flagged += if old { -1 } else { 1 }
		}
	}
	if e.mouse_button == .middle {
		if g.revealed[y][x] {
			count := g.act_on_neighbors(y, x, fn (mut g Game, cy int, cx int) int {
				if g.in_grid(cy, cx) {
					return int(g.flags[cy][cx])
				}
				return 0
			})
			if int(g.grid[y][x]) == count {
				g.act_on_neighbors(y, x, fn (mut g Game, cy int, cx int) int {
					if g.in_grid(cy, cx) && !g.flags[cy][cx] {
						g.reveal(cy, cx)
					}
					return 0
				})
			}
		}
	}
}

fn (mut g Game) act_on_neighbors(y int, x int, f fn (mut g Game, cy int, cx int) int) int {
	mut count := 0
	for dy in -1 .. 2 {
		for dx in -1 .. 2 {
			if dy == 0 && dx == 0 {
				continue
			}
			cy, cx := y + dy, x + dx
			count += f(mut g, cy, cx)
		}
	}
	return count
}

fn (mut g Game) draw_cell(y int, x int) {
	o := header_size
	rect_x, rect_y := x * g.csize, y * g.csize
	if g.revealed[y][x] {
		if g.grid[y][x] == .mine {
			g.ctx.draw_rect_filled(rect_x, o + rect_y, g.csize, g.csize, gg.red)
			g.ctx.draw_text(rect_x + 10, o + rect_y + 5, '*', color: gg.black)
		} else if int(g.grid[y][x]) > 0 {
			g.ctx.draw_rect_filled(rect_x, o + rect_y, g.csize, g.csize, gg.light_gray)
			n := int(g.grid[y][x]).str()
			g.ctx.draw_text(rect_x + 10, o + rect_y + 5, n, color: gg.black)
		} else {
			c := gg.rgb(240, 240, 240)
			g.ctx.draw_rect_filled(rect_x, o + rect_y, g.csize, g.csize, c)
		}
	} else if g.flags[y][x] {
		g.ctx.draw_rect_filled(rect_x, o + rect_y, g.csize, g.csize, gg.gray)
		g.ctx.draw_text(rect_x + 10, o + rect_y + 5, 'F', color: gg.white)
	} else {
		g.ctx.draw_rect_filled(rect_x, o + rect_y, g.csize, g.csize, gg.gray)
	}
	g.ctx.draw_rect_empty(rect_x, o + rect_y, g.csize, g.csize, gg.black)
}

fn on_frame(mut g Game) {
	g.ctx.begin()
	for y in 0 .. g.size {
		for x in 0 .. g.size {
			g.draw_cell(y, x)
		}
	}
	message := 'Flagged: ${g.mines_flagged:02}/${g.mines:02}               (r)estart (ESC)ape'
	g.ctx.draw_text(5, 7, message, color: gg.green)
	g.ctx.end()
}

fn main() {
	mut g := &Game{}
	g.restart()
	g.ctx = gg.new_context(
		bg_color:     gg.black
		width:        g.size * g.csize
		height:       header_size + g.size * g.csize
		window_title: 'V Minesweeper'
		user_data:    g
		frame_fn:     on_frame
		event_fn:     on_event
		font_path:    asset.get_path('../assets', 'fonts/RobotoMono-Regular.ttf')
	)
	g.ctx.run()
}
