package fw

import "core:log"
import "core:math/linalg"

import "vendor:glfw"

Vec2 :: [2]f32
Vec2i :: [2]i32
Vec3 :: [3]f32
Vec4 :: [4]f32
Color :: [4]f32
Mat4 :: matrix[4, 4]f32

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

Config :: struct {
  win_name: cstring,
  win_size: Vec2i,
  screen_size: Vec2i,
  renderer_backend: Renderer_Backend,
}

@(private) window: glfw.WindowHandle
@(private) last_frame: f64
@(private) dt: f64

rgba8 :: proc(r: u8, g: u8, b: u8, a: u8 = 255) -> Color {
  return Color{
    f32(r) / 255,
    f32(g) / 255,
    f32(b) / 255,
    f32(a) / 255,
  }
}

init :: proc(config: Config) {
  if !glfw.Init() {
    panic("could not init glfw window")
  }

  glfw.WindowHint(glfw.CONTEXT_VERSION_MAJOR, 3)
	glfw.WindowHint(glfw.CONTEXT_VERSION_MINOR, 3)
  glfw.WindowHint(glfw.RESIZABLE, false)
	glfw.WindowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)

  window = glfw.CreateWindow(
    config.win_size.x,
    config.win_size.y,
    config.win_name,
    nil,
    nil,
  )

  if window == nil {
    panic("could not create glfw window")
  }

  glfw.SwapInterval(1)

  _renderer_init(config)
}

deinit :: proc() {
  _renderer_deinit()

  glfw.DestroyWindow(window)
  glfw.Terminate()
}

next_frame :: proc() -> bool {
  // End the previous frame
  if can_flush() {
    flush_batch(&renderer.draw_call)
    new_batch(renderer.white_1x1.handle, .None, false)
  }

  view := renderer.view
  renderer.view = linalg.MATRIX4F32_IDENTITY
  renderer.vt.end_frame()
  renderer.view = view

  new_batch(renderer.white_1x1.handle, .None, false)

  renderer.draw_calls_count = renderer._draw_call_counter
  renderer._draw_call_counter = 0

  glfw.SwapBuffers(window)
  glfw.PollEvents()
  _update_input()

  // log.debugf("Draw calls: %v", renderer.draw_calls_count)

  // Begin next frame

  time := get_time()
  dt = time - last_frame
  last_frame = time

  renderer.vt.clear({0, 0, 0, 1})

  renderer.vt.start_frame()
  renderer.vt.clear(renderer.bg_col)

  return !bool(glfw.WindowShouldClose(window))
}

@(require_results)
get_time :: #force_inline proc() -> f64 {
  return glfw.GetTime()
}

@(require_results)
get_delta_time :: #force_inline proc() -> f64 {
  return dt
}