package demonchime

// import "core:math"
// import "core:math/rand"
// import "core:time"

import "base:runtime"

import "core:log"
import "core:fmt"
import "core:mem"

import rl "vendor:raylib"

import "draw"
import "phys"
import "tiled"

Vec2 :: [2]f32

Rect :: struct {
  start: Vec2,
  size: Vec2,
}

state: struct {
  player: Player,
  platform_list: Entity_List(Platform),
  
  room: tiled.Map,
}

init :: proc() {
  init_keybinds()

  draw.init()

  init_player(&state.player)

  room, err := tiled.load_map("res/room_begin.tmj")
  if err != .NONE {
    log.errorf("Error loading map (%v)", err)
  }
  state.room = room

  make_map_collisions :: proc(
    x: i32,
    y: i32,
    tile: tiled.Tile,
    tile_set: tiled.Tile_Set,
  ) {
    objs, is_object_layer := tile.object_group.layer.(tiled.Object_Layer)
    if !is_object_layer {
      return
    }

    for obj in objs {
      make_platform({
        Vec2{f32(x), f32(y)} + obj.position,
        obj.size,
      })
    }
  }

  tiled.iterate_map_tiles(state.room, make_map_collisions)
}

frame :: proc() {
  update_player(&state.player, rl.GetFrameTime())

  draw.new_frame()

  draw_player(state.player)
  tiled.draw_map(state.room)
  // draw_platforms()

  fps_text := fmt.caprintf(
    "FPS: %v", rl.GetFPS(),
    allocator = context.temp_allocator,
  )
  rl.DrawText(fps_text, 5, 5, 8, rl.GREEN)

  draw.end_frame()
}

cleanup :: proc() {
  delete_player(state.player)
  delete_entity_list(state.platform_list)
  tiled.delete_map(state.room)
  phys.destroy_world()
}

main :: proc() {
  	when ODIN_DEBUG {
		track: mem.Tracking_Allocator
		mem.tracking_allocator_init(&track, context.allocator)
		context.allocator = mem.tracking_allocator(&track)

		defer {
			if len(track.allocation_map) > 0 {
				fmt.eprintf(
          "=== %v allocations not freed: ===\n",
          len(track.allocation_map),
        )
        total := 0
				for _, entry in track.allocation_map {
					fmt.eprintf(
            "- %v bytes @ %v (%v, mode %v)\n",
            entry.size,
            entry.location,
            entry.err,
            entry.mode,
          )
          total += entry.size
				}

        fmt.eprintf("=== a total of %v bytes unfreed ===\n", total)
			}
			mem.tracking_allocator_destroy(&track)
		}
	}

  logger := log.create_console_logger()
  context.logger = logger
  defer log.destroy_console_logger(logger)

  rl.InitWindow(480 * 2, 360 * 2, "Demonchime")

  rl.SetWindowState({.WINDOW_RESIZABLE})

  init()

  for !rl.WindowShouldClose() {
    frame()

    free_all(context.temp_allocator)
  }

  cleanup()
}