package demonchime

import "core:c"
import "core:math"

import rl "vendor:raylib"

Color :: [4]f32

SCREEN_WIDTH :: 320
SCREEN_HEIGHT :: 320
SCREEN_SIZE :: Vec2{SCREEN_WIDTH, SCREEN_HEIGHT}

renderer: struct {
  screen: rl.RenderTexture2D,
  tint: Color,
}

@(private = "file")
_color_to_rl :: proc(col: Color) -> rl.Color {
  return rl.Color {
    u8(col.r * 255),
    u8(col.g * 255),
    u8(col.b * 255),
    u8(col.a * 255),
  }
}

init_draw :: proc() {
  renderer.screen = rl.LoadRenderTexture(SCREEN_WIDTH, SCREEN_HEIGHT)
  renderer.tint = Color{1, 1, 1, 1}
}

deinit_draw :: proc() {
  rl.UnloadRenderTexture(renderer.screen)
}

draw_new_frame :: proc() {
  rl.BeginTextureMode(renderer.screen)
  rl.ClearBackground(rl.BLACK)
  // rl.ClearBackground(rl.GRAY)
}

draw_end_frame :: proc() {
  rl.EndTextureMode()

  rl.BeginDrawing()
  {
    rl.ClearBackground(_color_to_rl(Color{0, 0, 0, 1}))
    scale := math.min(
      f32(rl.GetScreenWidth()) / f32(SCREEN_WIDTH),
      f32(rl.GetScreenHeight()) / f32(SCREEN_HEIGHT),
    )
    screen_start := Vec2 {
      (f32(rl.GetScreenWidth()) - (SCREEN_WIDTH * scale)) / 2,
      (f32(rl.GetScreenHeight()) - (SCREEN_HEIGHT * scale)) / 2,
    }

    draw_texture_full(
      renderer.screen.texture,
      screen_start,
      scale = Vec2{scale, scale},
    )
  }
  rl.EndDrawing()
}

draw_circle :: proc(pos: Vec2, rad: f32) {
  rl.DrawCircle(i32(pos.x), i32(pos.y), rad, _color_to_rl(renderer.tint))
}

draw_rect :: proc(rect: Rect) {
  assert(rect.size.x > 0 && rect.size.y > 0)

  rl.DrawRectangle(
    c.int(rect.start.x),
    c.int(rect.start.y),
    c.int(rect.size.x),
    c.int(rect.size.y),
    _color_to_rl(renderer.tint),
  )
}

draw_linerect :: proc(rect: Rect) {
  assert(rect.size.x > 0 && rect.size.y > 0)

  rl.DrawRectangleLines(
    c.int(rect.start.x),
    c.int(rect.start.y),
    c.int(rect.size.x),
    c.int(rect.size.y),
    _color_to_rl(renderer.tint),
  )
}

draw_texture :: proc {
  draw_texture_full,
  draw_texture_quad,
}

draw_texture_quad :: proc(
  img: rl.Texture2D,
  quad: Rect,
  position: Vec2,
  offset := Vec2{0, 0},
  rotation: f32 = 0,
  scale := Vec2{1, 1},
) {
  quad := quad
  if scale.x < 0 {
    quad.size.x *= -1
  }
  if scale.y < 0 {
    quad.size.y *= -1
  }

  rl.DrawTexturePro(
    img,
    transmute(rl.Rectangle)quad,
    rl.Rectangle {
      position.x,
      position.y,
      quad.size.x * scale.x,
      quad.size.y * scale.y,
    },
    offset,
    rotation,
    _color_to_rl(renderer.tint),
  )
}

draw_texture_full :: proc(
  img: rl.Texture2D,
  position: Vec2,
  offset := Vec2{0, 0},
  rotation: f32 = 0,
  scale := Vec2{1, 1},
) {
  size := Vec2{f32(img.width), -f32(img.height)}

  draw_texture_quad(img, Rect{Vec2{0, 0}, size}, position, offset, rotation, scale)
}