package main

import "vendor:raylib"

TilemapSpritesheet :: struct {
	texture:     raylib.Texture2D,
	tile_width:  i32,
	tile_height: i32,
	tiles_x:     i32,
	tiles_y:     i32,
}

VisibleTileRange :: struct {
	start_x, start_y: int,
	end_x, end_y:     int,
}

Grid :: struct {
	width:  int,
	height: int,
	tiles:  []Tile,
}

load_tilemap_sheet :: proc(path: cstring, tile_width, tile_height: i32) -> TilemapSpritesheet {
	tex := raylib.LoadTexture(path)

	return TilemapSpritesheet {
		texture = tex,
		tile_width = tile_width,
		tile_height = tile_height,
		tiles_x = tex.width / tile_width,
		tiles_y = tex.height / tile_height,
	}
}

create_tile_grid :: proc(width, height: i32, fill_tile: Tile) -> Grid {
	w, h := int(width), int(height)
	grid_slice := make([]Tile, w * h)

	for i := 0; i < len(grid_slice); i += 1 {
		grid_slice[i] = fill_tile
	}

	return Grid{width = w, height = h, tiles = grid_slice}
}

update_tile_grid :: proc(grid: ^Grid, camera: ^raylib.Camera2D, tile_w, tile_h: f32, delta: f32) {
	range := get_visible_tile_range(grid, tile_w, tile_h, camera)

	for y := range.start_y; y <= range.end_y; y += 1 {
		for x := range.start_x; x <= range.end_x; x += 1 {
			tile := &grid.tiles[y * grid.width + x]
			update_tile_anim(tile, delta)
		}
	}
}

draw_tile_grid :: proc(
	sheet: ^TilemapSpritesheet,
	grid: ^Grid,
	camera: ^raylib.Camera2D,
	color: raylib.Color,
) {
	tile_w := f32(sheet.tile_width)
	tile_h := f32(sheet.tile_height)

	range := get_visible_tile_range(grid, tile_w, tile_h, camera)

	for y := range.start_y; y <= range.end_y; y += 1 {
		for x := range.start_x; x <= range.end_x; x += 1 {
			tile := &grid.tiles[y * grid.width + x]

			if tile.type == .NOTHING do continue

			pos := raylib.Vector2{f32(x) * tile_w, f32(y) * tile_h}
			draw_tile(sheet, tile, pos, color)
		}
	}
}

get_visible_tile_range :: proc(
	grid: ^Grid,
	tile_w, tile_h: f32,
	camera: ^raylib.Camera2D,
	padding: int = 1,
) -> VisibleTileRange {
	screen_w := f32(raylib.GetScreenWidth())
	screen_h := f32(raylib.GetScreenHeight())

	world_w := screen_w / camera.zoom
	world_h := screen_h / camera.zoom

	min_x := camera.target.x - world_w * 0.5
	min_y := camera.target.y - world_h * 0.5
	max_x := min_x + world_w
	max_y := min_y + world_h

	start_x := int(min_x / tile_w) - padding
	start_y := int(min_y / tile_h) - padding
	end_x := int(max_x / tile_w) + padding
	end_y := int(max_y / tile_h) + padding

	return VisibleTileRange {
		start_x = clamp(start_x, 0, grid.width - 1),
		start_y = clamp(start_y, 0, grid.height - 1),
		end_x = clamp(end_x, 0, grid.width - 1),
		end_y = clamp(end_y, 0, grid.height - 1),
	}
}

get_tile :: proc(grid: ^Grid, x, y: int) -> ^Tile {
	if x < 0 || x >= grid.width || y < 0 || y >= grid.height do return nil
	return &grid.tiles[y * grid.width + x]
}

set_tile :: proc(grid: ^Grid, x: int, y: int, tile: Tile) {
	if x < 0 || x >= grid.width || y < 0 || y >= grid.height do return
	grid.tiles[y * grid.width + x] = tile
}

delete_tile_grid :: proc(grid: ^Grid) {
	delete(grid.tiles)
	grid.width = 0
	grid.height = 0
}