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 {
  camera: rl.Camera2D,
  platform_list: Entity_List(Platform),
}

logger: log.Logger

// raylib_log :: proc "c" (
//   msg_type: rl.TraceLogLevel,
//   fmt: cstring,
//   args: ^c.va_list,
// ) {
//   context = runtime.default_context()
//   context.logger = logger
//
//   fmt_len := libc.vsnprintf(nil, 0, fmt, args)
//
//   msg_bytes := make([]u8, fmt_len + 1, allocator = context.temp_allocator)
//   log.info(len(msg_bytes), raw_data(msg_bytes))
//   log.info(libc.vsnprintf(raw_data(msg_bytes), len(msg_bytes), fmt, args))
//
//   msg := string(msg_bytes)
//
//   #partial switch msg_type {
//   case .DEBUG: log.debug(msg)
//   case .INFO: log.info(msg)
//   case .WARNING: log.warn(msg)
//   case .ERROR: log.error(msg)
//   case .FATAL: log.fatal(msg)
//   }
// }

init :: proc() {
  state.camera.zoom = 1
  // state.camera.offset = {draw.SCREEN_WIDTH/2, draw.SCREEN_HEIGHT/2}

  init_keybinds()

  draw.init()

  init_player()

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

  tiled.load_world("res/map.world")
  tiled.open_new_room_at({0, 0})

  setup_map_collisions()
}

frame :: proc() {
  update_player(rl.GetFrameTime())

  draw.new_frame()
  
  rl.BeginMode2D(state.camera)

  draw_player()
  tiled.draw_map(tiled.current_room.tmap)
  // draw_platforms()

  rl.EndMode2D()

  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()
  delete_entity_list(state.platform_list)
  tiled.delete_world()
  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.SetTraceLogCallback(raylib_log)

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

  rl.SetWindowState({.WINDOW_RESIZABLE})

  init()

  for !rl.WindowShouldClose() {
    // pbody := phys.get_body(player.body_handle)
    // state.camera.target = {pbody.pos.x, pbody.pos.y}

    frame()

    free_all(context.temp_allocator)
  }

  cleanup()
}