package draw

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

import rl "vendor:raylib"

Vec2 :: [2]f32
Vec3 :: [3]f32

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

Mat4 :: matrix[4, 4]f32

Color :: [4]f32

SCREEN_WIDTH :: 480
SCREEN_HEIGHT :: 360

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

@(private)
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 :: proc() {
  renderer.screen = rl.LoadRenderTexture(SCREEN_WIDTH, SCREEN_HEIGHT)
  renderer.tint = Color{1, 1, 1, 1}
}

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

new_frame :: proc() {
  rl.BeginTextureMode(renderer.screen)
  rl.ClearBackground(color_to_rl(Color{0.2, 0.2, 0.2, 1}))
}

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

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

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

texture :: proc{
  texture_full,
  texture_quad,
}

texture_quad :: proc(
  img: rl.Texture2D,
  quad: Rect,
  position: Vec2,
  offset := Vec2{0, 0},
  rotation: f32 = 0,
  scale := Vec2{1, 1},
) {
  // assert(quad.size.x > 0 && quad.size.y > 0)

  quad := quad
  quad.size *= scale

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

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

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