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 "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,
}

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},
  })

  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 = {i, 340},
  //   size = {20, 20}
  // })

  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()))

  draw.new_frame(&state.renderer)

  draw_player(state.player)

  draw_platforms()

  draw.end_frame(&state.renderer)

  free_all(context.temp_allocator)
}

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()

  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)
}