package topdown

import rl "vendor:raylib"
import "core:math"
import "core:math/rand"
import "core:fmt"

Vec2 :: [2]f32
Rect :: rl.Rectangle
Img :: rl.Image
Tex :: rl.Texture
Key :: rl.KeyboardKey

SCREEN_WIDTH : i32 = 1000
SCREEN_HEIGHT : i32 = 800
BW := f32(SCREEN_WIDTH)
BH := f32(SCREEN_HEIGHT)

IdleState :: struct {}

MovingState :: struct {
    velocity: Vec2,
}

SoldierState :: union #no_nil {
    IdleState,
    MovingState,
}

Soldier :: struct {
    position: Vec2,
    state: SoldierState,
    anim_player: SpriteAnimationPlayer,
}

GameState :: struct {
    dt: f32,
    keymap: map[string]Key,
    reticle: Tex,
    idle: Tex,
    run: Tex,
    soldier: Soldier,
    animations: [dynamic]SpriteAnimation,
} 

init_state :: proc() -> ^GameState {
    idle := rl.LoadImage("./Assets/Enemies/Jungle&City variant/Assault Soldier/idle.png")
    defer rl.UnloadImage(idle)
    run := rl.LoadImage("./Assets/Enemies/Jungle&City variant/Assault Soldier/walk.png")
    defer rl.UnloadImage(run)
    reticle := rl.LoadImage("Assets/reticle.png")
    defer rl.UnloadImage(reticle)

    keymap := make(map[string]Key)
    keymap["Left"] = .A
    keymap["Right"] = .D
    keymap["Up"] = .W
    keymap["Down"] = .S

    animations := make([dynamic]SpriteAnimation)
    idle_anim := SpriteAnimation {
        speed = 1 / 2.0,
        width = 16,
        height = 16,
        total_width = 32,
        row = 0,
        loop = true,
        total_frames = 2,
    }
    run_anim := SpriteAnimation {
        speed = 1 / 9.0,
        width = 16,
        height = 16,
        total_width = 64,
        row = 0,
        loop = true,
        total_frames = 4,
    }
    append(&animations, idle_anim)
    append(&animations, run_anim)
    soldier := Soldier {
        position = {100, 100},
        anim_player = SpriteAnimationPlayer{},
    }
    anim_player_start(&soldier.anim_player, &animations[0])

    state := GameState {
        reticle = rl.LoadTextureFromImage(reticle),
        idle = rl.LoadTextureFromImage(idle),
        run = rl.LoadTextureFromImage(run),
        keymap = keymap,
        soldier = soldier,
        animations = animations
    }
    cloned := new_clone(state)
    return cloned
}

player_input :: proc(s: ^GameState) {
    horizontal := rl.IsKeyDown(s.keymap["Left"]) ? -1 : rl.IsKeyDown(s.keymap["Right"]) ? 1 : 0
    vertical   := rl.IsKeyDown(s.keymap["Up"])   ? -1 : rl.IsKeyDown(s.keymap["Down"])  ? 1 : 0
    moving := horizontal != 0 || vertical != 0
    if moving {
        dir := rl.Vector2Normalize({f32(horizontal), f32(vertical)})
        velocity := dir * (250 * s.dt)
        moving_state := MovingState { velocity = velocity }
        if _, ok := s.soldier.state.(IdleState); ok {
            anim_player_start(&s.soldier.anim_player, &s.animations[1])
        }
        s.soldier.state = moving_state
        s.soldier.position += velocity
    } else if _, ok := s.soldier.state.(MovingState); ok {
        anim_player_start(&s.soldier.anim_player, &s.animations[0])
        s.soldier.state = IdleState {}
    }
}

update :: proc(s: ^GameState) {
    anim_player_tick(&s.soldier.anim_player)
}

draw2d :: proc(s: ^GameState) {
    mpos := rl.GetMousePosition() - {f32(s.reticle.width) / 2, f32(s.reticle.height) / 2}
    // rl.DrawTextureEx(s.idle, s.player.position, 0, 4, rl.WHITE)
    flip := mpos.x < s.soldier.position.x
    sprite :Tex
    if _, ok := s.soldier.state.(IdleState); ok {
        sprite = s.idle
    } else {
        sprite = s.run
    }
    draw_sprite(sprite, &s.soldier.anim_player, s.soldier.position, 4, flip)

    rl.DrawTextureV(s.reticle, mpos, rl.WHITE);
}

main :: proc() {
    rl.SetTraceLogLevel(.ERROR)
    rl.InitWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Asteroids")
    rl.HideCursor()
    rl.SetTargetFPS(60)

    state := init_state()
    defer free(state)

    for !rl.WindowShouldClose() {
        state.dt = rl.GetFrameTime()

        player_input(state)

        update(state)

        rl.BeginDrawing()
        rl.ClearBackground(rl.RAYWHITE)

        draw2d(state)

        rl.EndDrawing()
    }

    rl.UnloadTexture(state.reticle)
    rl.CloseWindow()
}