package demonchime

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

import "base:runtime"

import "core:log"

import sg "shared:sokol/gfx"
import sapp "shared:sokol/app"
import sglue "shared:sokol/glue"
import stime "shared:sokol/time"
import slog "shared:sokol/log"
import sdtxt "shared:sokol/debugtext"

import "draw"
import "phys"

Vec2 :: [2]f32

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

state: struct {
  player: Player,

  platform_list: Entity_List(Platform),

  renderer: draw.Renderer,
  physics_world: phys.World,

  input: Input,

  fps: f32,
  last_fps: f32,
  frames_rendered: int,
}

logger: log.Logger

default_context :: proc "contextless" () -> runtime.Context {
  ctx := runtime.default_context()
  ctx.logger = logger
  return ctx
}

init :: proc "c" () {
  context = default_context()
  
  stime.setup()

  sg.setup({
    environment = sglue.environment(),
    logger = {func=slog.func},
  })

  sdtxt.setup({
    fonts = {
      0 = sdtxt.font_kc853(),
      // sdtxt.font_kc854(),
      // sdtxt.font_z1013(),
      // sdtxt.font_cpc(),
      // sdtxt.font_c64(),
      // sdtxt.font_oric(),
    },
    logger = {func=slog.func},
  })

  init_keybinds(&state.input)

  draw.init(&state.renderer)

  init_player(&state.player)

  make_platform(Rect{
    start = {50, 50},
    size = {64, 20}
  })

  i := f32(20)
  for i < draw.SCREEN_WIDTH - 20 - 64 {
    make_platform(Rect{
      start = {i, 340},
      size = {64, 20}
    })
    i += 65
  }

  make_platform(Rect{
    start = {160, 320},
    size = {20, 20}
  })

  make_platform(Rect{
    start = {240, 280},
    size = {40, 20}
  })

  make_platform(Rect{
    start = {260, 260},
    size = {20, 20}
  })

  make_platform(Rect{
    start = {300, 220},
    size = {40, 20}
  })

  make_platform(Rect{
    start = {240, 180},
    size = {40, 20}
  })

  make_platform(Rect{
    start = {200, 140},
    size = {40, 20}
  })

  make_platform(Rect{
    start = {180, 100},
    size = {20, 20}
  })
  
  make_platform(Rect{
    start = {140, 100},
    size = {16, 16}
  })
}

frame :: proc "c" () {
  context = default_context()

  update_player(&state.player, f32(sapp.frame_duration()))

  // sdtxt.canvas(f32(sapp.width()), f32(sapp.height()))
  sdtxt.canvas(draw.SCREEN_WIDTH, draw.SCREEN_HEIGHT)
  sdtxt.origin(0.1, 0.1)
  sdtxt.home()
  sdtxt.font(0)

  stats := sg.query_frame_stats()
  sdtxt.printf("FPS: %f\n", state.fps)
  sdtxt.printf("Draw calls: %d\n", stats.num_draw)

  draw.new_frame(&state.renderer)

  draw_player(state.player)

  draw_platforms()

  draw.end_frame(&state.renderer)

  free_all(context.temp_allocator)

  state.frames_rendered += 1
  now := f32(stime.sec(stime.now()))
  if now - state.last_fps > 1 {
    state.fps = f32(state.frames_rendered) / (now - state.last_fps)
    state.last_fps = now
    state.frames_rendered = 0
  }
}

event :: proc "c" (event: ^sapp.Event) {
  context = default_context()

  if event.type == .KEY_DOWN && event.key_code == .ESCAPE {
    sapp.quit()
  }

  input_event(event, &state.input)
}

cleanup :: proc "c" () {
  context = default_context()
  sg.shutdown()
  sdtxt.shutdown()

  delete_entity_list(state.platform_list)
}

main :: proc() {
  logger = log.create_console_logger()
  context.logger = logger

  sapp.run({
    init_cb = init,
    frame_cb = frame,
    event_cb = event,
    cleanup_cb = cleanup,
    width = 800,
    height = 600,
    window_title = "Demonchime",
    icon = {sokol_default = true},
    logger = {func=slog.func},
  })

  log.destroy_console_logger(logger)
}