package main

import (
	"fmt"
	"math"
	"strconv"

	rl "github.com/gen2brain/raylib-go/raylib"
)

type movementPattern int
type shootingPattern int

const (
    horizontal movementPattern = iota
    circular movementPattern = iota
)

type game struct {
    arenaWidth int32
    arenaHeight int32
    interfaceWidth int32
    time int
    enemies []*enemy
    bullets []*bullet
    score int
}

type bullet struct {
    pos rl.Vector2
    speed rl.Vector2
    size float32
    dmg int
    enemy bool
}

type player struct {
    pos rl.Vector2
    speed rl.Vector2
    moveSpeed float32
    bulletMoveSpeed float32
    hitBoxRadius float32
    bulletSize float32
}

type enemy struct {
    pos rl.Vector2
    health int
    movePattern func(*enemy)rl.Vector2
    shootPattern func()
    hitBoxRadius float32
}

func (g game) insideArena(v rl.Vector2) bool {
    return v.X >= 0 && v.Y >= 0 && 
    v.Y <= float32(g.arenaHeight) && v.X <= float32(g.arenaWidth)
}

func (g *game) removeBullet(index int) {
    g.bullets[index] = g.bullets[len(g.bullets)-1]
    g.bullets = g.bullets[:len(g.bullets)-1]
}

func (b *bullet) update(g *game, index int) {
    b.pos = rl.Vector2Add(b.pos, b.speed)

    if !g.insideArena(b.pos) {
        g.removeBullet(index)
        return
    }

    rl.DrawCircleV(b.pos, b.size, rl.Yellow)
}

func (e *enemy) shoot(g *game) {
    if g.time % 15 != 0 {
        return
    }
    g.bullets = append(g.bullets, &bullet{
        speed: rl.Vector2{X: 0, Y: 10},
        size: 4,
        dmg: 1,
        enemy: true,
        pos: e.pos,
    })
}

func horizonalPattern(g *game) (func(*enemy)rl.Vector2) {
    direction := rl.Vector2{X: 4, Y: 0}

    return func(e *enemy) rl.Vector2 {
        result := rl.Vector2Add(direction, e.pos)

        if !g.insideArena(result) {
            direction = rl.Vector2Negate(direction)
        }
        return result
    }
}

func circlePattern(g *game, center rl.Vector2) (func(*enemy)rl.Vector2) {

    t := float64(0.5)

    return func(e *enemy) rl.Vector2 {
        // x' = (x - x₀) * cos(θ) - (y - y₀) * sin(θ) + x₀
        // y' = (x - x₀) * sin(θ) + (y - y₀) * cos(θ) + y₀

        // x' = x * cos(θ) - y * sin(θ)
        // y' = x * sin(θ) + y * cos(θ)

        // result := center
        //
        // result.X = result.X + (e.pos.X - result.X) * float32(math.Cos(t)) - 
        // (e.pos.Y - result.Y) * float32(math.Sin(t))
        //
        // result.Y =  result.Y + (e.pos.Y - result.Y) * float32(math.Sin(t)) + 
        // (e.pos.Y - result.Y) * float32(math.Cos(t))

        result := center
        result.X = result.X * float32(math.Cos(t)) - result.Y * float32(math.Sin(t))
        result.Y = result.X * float32(math.Sin(t)) - result.Y * float32(math.Cos(t))

        t += .08
        return result
    }
}

func (e *enemy) checkHit(g *game) (bool, *bullet, int) {
    for index, bullet := range g.bullets {

        playerBullet := !bullet.enemy
        if !playerBullet {
            continue
        }
        distance := rl.Vector2Distance(e.pos, bullet.pos) - bullet.size
        // fmt.Println(distance)

        if distance < e.hitBoxRadius {
            return true, bullet, index
        }
    }
    return false, nil, 0
}

func (g *game) killEnemy(index int) {
    g.enemies[index] = g.enemies[len(g.enemies)-1]
    g.enemies = g.enemies[:len(g.enemies)-1]
}


func (e *enemy) update(g *game, index int) {

    enemyColor := rl.Blue

    if e.movePattern != nil {
        e.pos = e.movePattern(e)
    }

    if hit, bullet, idx := e.checkHit(g); hit {
        g.score += 273
        e.health -= bullet.dmg
        g.removeBullet(idx)
        enemyColor = rl.White
    }

    if e.health <= 0 {
        g.killEnemy(index)
        return
    }

    e.shoot(g)

    rl.DrawCircleV(e.pos, e.hitBoxRadius, enemyColor)
}

func (p *player) move(g *game) {
    p.speed = rl.Vector2{X: 0, Y: 0}

    if rl.IsKeyDown(rl.KeyW) { p.speed.Y -= 1 }
    if rl.IsKeyDown(rl.KeyS) { p.speed.Y += 1 }
    if rl.IsKeyDown(rl.KeyA) { p.speed.X -= 1 }
    if rl.IsKeyDown(rl.KeyD) { p.speed.X += 1 }

    if !(p.speed.X == 0 && p.speed.Y == 0) {
        // jogador se move mais rapido na diagonal caso o contrario
        p.speed = rl.Vector2Normalize(p.speed)
        p.speed = rl.Vector2Scale(p.speed, p.moveSpeed)
    }

    result := rl.Vector2Add(p.pos, p.speed)

    if result.Y - p.hitBoxRadius < 0  || 
    result.Y + p.hitBoxRadius > float32(g.arenaHeight) {
        p.speed.Y = 0
    }
    if result.X - p.hitBoxRadius < 0  || 
    result.X + p.hitBoxRadius > float32(g.arenaWidth) {
        p.speed.X = 0
    }
    
    p.pos = rl.Vector2Add(p.pos, p.speed)
}

func (p *player) shoot(g *game){
    if g.time % 5 != 0 {
        return
    }

    if rl.IsMouseButtonDown(rl.MouseLeftButton) {
        // (mal) leva em consideração a velocidade do jogador
        mouse := rl.GetMousePosition()
        direction := rl.Vector2Subtract(mouse, p.pos)
        direction = rl.Vector2Add(direction, p.speed)
        direction = rl.Vector2Normalize(direction)
        direction = rl.Vector2Scale(direction, p.bulletMoveSpeed)

        g.bullets = append(g.bullets, &bullet{
            pos: p.pos,
            size: p.bulletSize,
            speed: direction,
            dmg: 1,
            enemy: false,
        })
    }
}

func (p *player) checkHit(g *game) {
    for _, bullet := range g.bullets {
        if !bullet.enemy {
            continue
        }
        distance := rl.Vector2Distance(p.pos, bullet.pos) - bullet.size
        // fmt.Println(distance)

        if distance < p.hitBoxRadius {
            fmt.Println("hit!")
        }
    }
}

func (p *player) update(g *game) {

    p.move(g)

    p.shoot(g)

    p.checkHit(g)

    // hitbox
    rl.DrawCircleV(p.pos, p.hitBoxRadius, rl.Red)

    // mira
    mouse := rl.GetMousePosition()
    inverted := rl.Vector2Subtract(p.pos, mouse)
    inverted = rl.Vector2Negate(inverted)
    inverted = rl.Vector2Normalize(inverted)
    inverted = rl.Vector2Scale(inverted, 2000)
    rl.DrawLineV(p.pos, rl.Vector2Add(mouse, inverted), rl.NewColor(255, 0, 0, 100))

}

func main() {

    state := &game{arenaWidth: 450, arenaHeight: 700, interfaceWidth: 300}

    player := player{
        pos: rl.Vector2{X: 100, Y: 100},
        moveSpeed: 4,
        bulletMoveSpeed: 13,
        bulletSize: 8,
        hitBoxRadius: 5,
    }

    rl.SetTraceLog(rl.LogWarning | rl.LogDebug)
	rl.InitWindow(state.arenaWidth + state.interfaceWidth, state.arenaHeight, "danmaku")
	rl.SetTargetFPS(60)

    state.enemies = []*enemy{
        {
            pos: rl.Vector2{X: 200, Y: 200},
            health: 10,
            hitBoxRadius: 10,
            movePattern: horizonalPattern(state),
        },
        {
            pos: rl.Vector2{X: 169, Y: 222},
            health: 10,
            hitBoxRadius:10,
            movePattern: horizonalPattern(state),
        },
        {
            pos: rl.Vector2{X: 400, Y: 400},
            health: 10,
            hitBoxRadius:10,
            // movePattern: circlePattern(state, rl.Vector2{X: 200, Y: 200}),
        },
        {
            pos: rl.Vector2{X: 200, Y: 200},
            health: 10,
            hitBoxRadius:10,
            // movePattern: circlePattern(state, rl.Vector2{X: 200, Y: 200}),
        },
    }

    currectScore := 0

    for ; !rl.WindowShouldClose(); state.time += 1 {
        rl.BeginDrawing()
        rl.ClearBackground(rl.Black)

        rl.DrawText("danmaku babe bullet shoot shoot", 20, 20, 20, rl.DarkGray)
        rl.DrawLine(18, 42, state.arenaWidth-18, 42, rl.Black)
        rl.DrawFPS(0, 0)

        player.update(state)

        for i := 0; i < len(state.enemies); i++ {
            state.enemies[i].update(state, i)
        }

        for i := 0; i < len(state.bullets); i++ {
            state.bullets[i].update(state, i)
        }

        rl.DrawRectangle(
            state.arenaWidth, 0, state.interfaceWidth, state.arenaHeight, 
            rl.NewColor(0, 33, 59, 255),
        )
        currectScore += (state.score - currectScore) / 11
		rl.DrawText(strconv.Itoa(currectScore), state.arenaWidth, 0, 50, rl.White)

		rl.EndDrawing()
	}

	rl.CloseWindow()
}