// Copyright (c) 2025 Delyan Angelov. All rights reserved.
// The use of this source code is governed by an MIT license that
// can be found in the LICENSE file.
module main

import gg
import math
import rand
import os.asset
import math.vec

type V2 = vec.Vec2[f32]

fn rads(degrees f32) f32 {
    return f32(math.radians(degrees))
}

fn (a V2) offset(angle f32, scale f32) V2 {
    return a + V2{math.cosf(angle) * scale, math.sinf(angle) * scale}
}

fn (mut a V2) wrap(b V2) {
    a.x = f32(math.mod(a.x + b.x, b.x))
    a.y = f32(math.mod(a.y + b.y, b.y))
}

fn V2.random(b V2) V2 {
    return V2{rand.f32() * b.x, rand.f32() * b.y}
}

struct Body {
mut:
    pos      V2
    vel      V2
    rotation f32
    radius   f32
    active   bool = true
}

struct Bullet {
    Body
}

struct Asteroid {
    Body
mut:
    segments      int
    offsets       []f32
    points        []f32
    rotation_step f32 = 1.0
}

struct Player {
    Body
mut:
    is_engine_on    bool
    bullets         int = 99
    bullets_limit   int = 99
    fuel            int = 9999
    fuel_limit      int = 9999
    cooldown        int
    cooldown_frames int   = 15
    points          []f32 = []f32{len: 8}
}

struct Game {
mut:
    gg        &gg.Context = unsafe { nil }
    screen    V2          = V2{800, 600}
    player    Player
    bullets   []Bullet
    asteroids []Asteroid
    score     int
    highscore int
    ships     int = 5
    level     int = 1
    is_up     bool

    msg Message
}

@[params]
struct Message {
mut:
    frames int
    text   string
    size   int = 40
    color  gg.Color
    align  gg.HorizontalAlign = .center
}

fn (mut a Asteroid) setup() {
    a.segments = int(a.radius / 10) * 10
    a.offsets = []f32{len: a.segments}
    a.points = []f32{len: 2 * a.segments}
    for i in 0 .. a.segments {
        a.offsets[i] = a.radius + 25 * (0.5 - rand.f32())
    }
}

fn (mut p Player) reset(screen V2) {
    p.bullets, p.fuel = p.bullets_limit, p.fuel_limit
    p.pos, p.vel = screen.div_scalar(2), V2{0, 0}
    p.radius, p.rotation = 15, -90
    p.active = true
}

fn (mut game Game) handle_input() {
    mut p := &game.player
    p.is_engine_on = false
    if game.gg.is_key_down(.escape) {
        exit(0)
    }
    if !p.active {
        return
    }
    game.is_up = game.gg.is_key_down(.up) || game.gg.is_key_down(.w)
    is_fire := game.gg.is_key_down(.space)
    is_left := game.gg.is_key_down(.left) || game.gg.is_key_down(.a)
    is_right := game.gg.is_key_down(.right) || game.gg.is_key_down(.d)
    if is_fire && p.cooldown <= 0 && p.active {
        game.add_bullet()
        p.cooldown = p.cooldown_frames
    }
    if p.fuel >= 10 {
        if game.is_up && p.active {
            angle := rads(p.rotation)
            p.vel += V2{0, 0}.offset(angle, 0.1)
            p.fuel -= 10
            p.is_engine_on = true
        }
    }
    if p.fuel >= 1 {
        if is_left {
            p.rotation -= 2
            p.fuel--
        }
        if is_right {
            p.rotation += 2
            p.fuel--
        }
    }
}

fn (mut game Game) update() {
    game.msg.frames = int_max(0, game.msg.frames - 1)
    mut p := &game.player
    p.cooldown = int_max(0, p.cooldown - 1)
    p.pos += p.vel
    p.pos.wrap(game.screen)
    for mut b in game.bullets {
        if !b.active {
            continue
        }
        b.pos += b.vel
        if b.pos.x < 0 || b.pos.x > game.screen.x || b.pos.y < 0 || b.pos.y > game.screen.y {
            b.active = false
        }
    }
    for mut a in game.asteroids {
        if !a.active {
            continue
        }
        a.pos += a.vel
        a.pos.wrap(game.screen)
        a.rotation += a.rotation_step
        if p.active && p.pos.distance(a.pos) <= (p.radius + a.radius) {
            // player/asteroids collision
            p.active = false
            a.active = false
            game.split_asteroid(a, p.vel.mul_scalar(0.5))
            game.player.reset(game.screen)
            game.score += 50
            game.show_message(text: 'Your ship was destroyed.', color: gg.red, frames: 90)
            game.ships--
            if game.ships <= 0 {
                game.ships = 5
                game.score = 0
                game.asteroids = []
                game.add_asteroids(10)
            }
        }
    }
    for mut b in game.bullets {
        if !b.active {
            continue
        }
        for mut a in game.asteroids {
            if !a.active {
                continue
            }
            if b.active && b.pos.distance(a.pos) <= (b.radius + a.radius) {
                // bullet/asteroid collision
                b.active = false
                a.active = false
                game.score += 100
                game.split_asteroid(a, b.vel.mul_scalar(0.2))
            }
        }
    }
    if game.bullets.any(!it.active) {
        game.bullets = game.bullets.filter(it.active)
    }
    if game.asteroids.any(!it.active) {
        game.asteroids = game.asteroids.filter(it.active)
    }
    if game.asteroids.len == 0 {
        game.level++
        game.ships++
        game.player.reset(game.screen)
        game.add_asteroids(10)
        game.show_message(text: 'YOU WIN', color: gg.green, frames: 90)
    }
    game.highscore = int_max(game.score, game.highscore)
}

fn (mut game Game) show_message(params Message) {
    game.msg = params
}

fn (mut game Game) split_asteroid(a &Asteroid, vel V2) {
    if a.radius < 30 {
        return
    }
    shrink_factor := 0.5 + 0.3 * rand.f32()
    mut a1 := Asteroid{
        ...*a
        active:        true
        radius:        a.radius * shrink_factor
        rotation_step: -a.rotation_step
    }
    mut a2 := Asteroid{
        ...*a
        active:        true
        radius:        a.radius * (1 - shrink_factor)
        rotation_step: 2 * a.rotation_step
    }
    a1.vel = a1.vel.mul_scalar(shrink_factor) * vel
    a2.vel = a2.vel.mul_scalar(1 - shrink_factor) * (V2{0, 0} - vel)
    a1.setup()
    a2.setup()
    game.asteroids << a1
    game.asteroids << a2
}

fn (mut game Game) draw() {
    ws := gg.window_size()
    game.screen = V2{ws.width, ws.height}
    game.gg.draw_rect_filled(0, 0, game.screen.x, game.screen.y, gg.rgba(20, 20, 20, 255))
    game.draw_ship()
    for b in game.bullets {
        game.gg.draw_circle_filled(b.pos.x, b.pos.y, 3, gg.yellow)
    }
    for mut a in game.asteroids {
        game.draw_asteroid(mut a)
    }
    scenter := game.screen.div_scalar(2)
    label1 := 'Level: ${game.level} Ships: ${game.ships}'
    game.gg.draw_text(5, 10, label1, size: 20, color: gg.white, align: .left)
    label2 := 'B: ${game.player.bullets:02} F: ${game.player.fuel:04}'
    game.gg.draw_text(int(scenter.x), 10, label2, size: 20, color: gg.green, align: .center)
    label3 := 'Score: ${game.score} Highscore: ${game.highscore}'
    game.gg.draw_text(int(game.screen.x) - 5, 10, label3, size: 20, color: gg.white, align: .right)
    if game.msg.frames > 0 {
        game.gg.draw_text(int(scenter.x), int(scenter.y / 2), game.msg.text,
            size:  game.msg.size
            color: game.msg.color
            align: game.msg.align
        )
    }
    label4 := 'Use arrows + space to control your ship. Use Escape to end the game.'
    game.gg.draw_text(int(game.screen.x - 5), int(game.screen.y - 20), label4,
        size:  16
        color: gg.gray
        align: .right
    )
}

fn (game &Game) draw_ship() {
    mut p := &game.player
    if !p.active {
        return
    }
    angle := rads(p.rotation)
    p1 := p.pos.offset(angle, p.radius)
    p2 := p.pos.offset(angle + 2.5, 0.6 * p.radius)
    p3 := p.pos.offset(angle, -0.3 * p.radius)
    p4 := p.pos.offset(angle - 2.5, 0.6 * p.radius)
    p.points[0] = p1.x
    p.points[1] = p1.y
    p.points[2] = p2.x
    p.points[3] = p2.y
    p.points[4] = p3.x
    p.points[5] = p3.y
    p.points[6] = p4.x
    p.points[7] = p4.y
    game.gg.draw_convex_poly(p.points, gg.white)
    if p.is_engine_on {
        engine := p.pos.offset(angle + math.pi, 0.7 * p.radius)
        game.gg.draw_circle_filled(engine.x, engine.y, 6, gg.yellow)
    }
}

fn (mut game Game) draw_asteroid(mut a Asteroid) {
    if !a.active {
        return
    }
    game.gg.draw_circle_filled(a.pos.x, a.pos.y, a.radius, gg.rgba(235, 235, 255, 215))
    for i in 0 .. a.segments {
        angle := rads(a.rotation + f32(i) * 360 / a.segments)
        p := a.pos.offset(angle, a.offsets[i])
        a.points[i * 2], a.points[i * 2 + 1] = p.x, p.y
    }
    game.gg.draw_convex_poly(a.points, gg.rgba(155, 155, 148, 245))
}

fn (mut game Game) add_bullet() {
    if game.player.bullets <= 0 {
        return
    }
    game.player.bullets--
    angle := rads(game.player.rotation)
    game.bullets << Bullet{
        pos:    game.player.pos
        radius: 3
        vel:    game.player.vel.offset(angle, 10)
        active: true
    }
}

fn (mut game Game) add_asteroids(count int) {
    for _ in 0 .. count {
        mut npos := V2{}
        new_asteroid_loop: for {
            npos = V2.random(game.screen)
            for a in game.asteroids {
                if a.pos.distance(npos) < (a.radius + 30) {
                    continue new_asteroid_loop
                }
            }
            if game.player.pos.distance(npos) < 5 * (game.player.radius + 30) {
                continue new_asteroid_loop
            }
            break
        }
        radius := 50 + 50 * (0.5 - rand.f32())
        mut asteroid := Asteroid{
            pos:           npos
            vel:           (V2.random(game.screen) - V2.random(game.screen)) / game.screen
            radius:        radius
            rotation:      360 * rand.f32()
            rotation_step: 2 * (0.5 - rand.f32())
            active:        true
        }
        asteroid.setup()
        game.asteroids << asteroid
    }
}

fn on_frame(mut game Game) {
    if game.gg.timer.elapsed().milliseconds() > 15 {
        game.gg.timer.restart()
        game.handle_input()
        game.update()
    }
    game.gg.begin()
    game.draw()
    game.gg.end()
}

fn main() {
    mut game := &Game{}
    mut fpath := asset.get_path('../assets', 'fonts/RobotoMono-Regular.ttf')
    game.player.reset(game.screen)
    game.add_asteroids(10)
    game.gg = gg.new_context(
        window_title: 'V Asteroids'
        width:        int(game.screen.x)
        height:       int(game.screen.y)
        frame_fn:     on_frame
        user_data:    game
        sample_count: 2
        font_path:    fpath
    )
    game.gg.run()
}