// vtest build: !openbsd
module main

import gg
import rand
import sokol.audio
import math

const paddle_speed_base = f32(400.0)
const ball_speed_base = f32(300.0)

// Colors
const color_bg = gg.Color{10, 15, 30, 255}
const color_foreground = gg.Color{230, 230, 230, 255}
const color_accent = gg.Color{0, 255, 100, 255}
const color_secondary = gg.Color{0, 200, 80, 255}
const color_text_dim = gg.Color{150, 150, 150, 200}
const color_line = gg.Color{100, 100, 100, 150}
const color_p1 = gg.Color{255, 50, 50, 255}
const color_p2 = gg.Color{50, 100, 255, 255}

struct SoundManager {
mut:
    ping []f32
    pong []f32
    buzz []f32
}

fn (mut sm SoundManager) init() {
    sample_rate := f32(audio.sample_rate())

    // Ping (Wall)
    ping_duration := f32(0.1)
    ping_frames := int(sample_rate * ping_duration)
    for i in 0 .. ping_frames {
        t := f32(i) / sample_rate
        // Use a steeper exponential-like decay for a cleaner "pluck"
        env := f32(math.pow(f32(1.0) - t / ping_duration, 3))
        sm.ping << f32(0.3) * math.sinf(t * 800.0 * 2 * math.pi) * env
    }
    // Absolute silence buffer to prevent clicks
    for _ in 0 .. 100 {
        sm.ping << 0
    }

    // Pong (Paddle)
    pong_duration := f32(0.1)
    pong_frames := int(sample_rate * pong_duration)
    for i in 0 .. pong_frames {
        t := f32(i) / sample_rate
        env := f32(math.pow(f32(1.0) - t / pong_duration, 3))
        sm.pong << f32(0.3) * math.sinf(t * 400.0 * 2 * math.pi) * env
    }
    for _ in 0 .. 100 {
        sm.pong << 0
    }

    // Buzz (Reset)
    buzz_duration := f32(0.3)
    buzz_frames := int(sample_rate * buzz_duration)
    for i in 0 .. buzz_frames {
        t := f32(i) / sample_rate
        env := f32(math.pow(f32(1.0) - t / buzz_duration, 2))
        // Add a harmonic for a more "buzzy" feel
        val := f32(0.25) * math.sinf(t * 100.0 * 2 * math.pi) +
            f32(0.1) * math.sinf(t * 200.0 * 2 * math.pi)
        sm.buzz << val * env
    }
    for _ in 0 .. 200 {
        sm.buzz << 0
    }
}

struct App {
mut:
    ctx           &gg.Context = unsafe { nil }
    width         int         = 800
    height        int         = 600
    paddle_width  f32
    paddle_height f32
    ball_size     f32
    p1_y          f32
    p2_y          f32
    ball_x        f32
    ball_y        f32
    ball_vx       f32
    ball_vy       f32
    p1_score      int
    p2_score      int
    paused        bool
    sounds        SoundManager
}

fn (mut app App) update_sizes() {
    size := app.ctx.window_size()
    app.width = size.width
    app.height = size.height

    // Base scales on 800x600
    scale_x := f32(app.width) / 800.0
    scale_y := f32(app.height) / 600.0

    app.paddle_width = 15.0 * scale_x
    app.paddle_height = 80.0 * scale_y
    app.ball_size = 15.0 * scale_x // Keep it circular based on width scale
}

fn (mut app App) reset_ball() {
    app.ball_x = f32(app.width) / 2 - app.ball_size / 2
    app.ball_y = f32(app.height) / 2 - app.ball_size / 2

    scale_x := f32(app.width) / 800.0
    mut vx := ball_speed_base * scale_x
    if rand.intn(2) or { 0 } == 0 {
        vx = -vx
    }
    app.ball_vx = vx
    app.ball_vy = (f32(rand.intn(301) or { 150 } - 150)) * (f32(app.height) / 600.0)
}

fn (mut app App) reset_game() {
    app.p1_score = 0
    app.p2_score = 0
    app.p1_y = f32(app.height) / 2 - app.paddle_height / 2
    app.p2_y = f32(app.height) / 2 - app.paddle_height / 2
    app.reset_ball()
    app.paused = false
}

fn on_frame(data voidptr) {
    mut app := unsafe { &App(data) }
    app.ctx.begin()

    // Draw dashed center line
    line_segments := 20
    segment_height := f32(app.height) / line_segments
    for i in 0 .. line_segments {
        if i % 2 == 0 {
            app.ctx.draw_rect_filled(f32(app.width) / 2 - 1, i * segment_height, 2, segment_height,
                color_line)
        }
    }

    // Draw paddles
    app.ctx.draw_rounded_rect_filled(20, app.p1_y, app.paddle_width, app.paddle_height, 5, color_p1)
    app.ctx.draw_rounded_rect_filled(f32(app.width) - 20 - app.paddle_width, app.p2_y,
        app.paddle_width, app.paddle_height, 5, color_p2)

    // Draw ball
    app.ctx.draw_circle_filled(app.ball_x + app.ball_size / 2, app.ball_y + app.ball_size / 2,
        app.ball_size / 2, color_foreground)

    // Draw ball speed (10m = 800px => 1m = 80px)
    // We scale the meter definition with width
    meter_px := 80.0 * (f32(app.width) / 800.0)
    speed_px := math.sqrt(app.ball_vx * app.ball_vx + app.ball_vy * app.ball_vy)
    speed_ms := speed_px / meter_px
    app.ctx.draw_text(app.width / 2, 20, 'Ball: ${speed_ms:.1f} m/s',
        size:  20
        color: color_foreground
        align: .center
    )

    // Draw scores and positions
    // Moved up to be less obtrusive
    app.ctx.draw_text(app.width / 4, 30, app.p1_score.str(),
        size:  40
        color: color_accent
        align: .center
    )
    app.ctx.draw_text(app.width / 4, 80, 'Y: ${int(app.p1_y)}',
        size:  16
        color: color_secondary
        align: .center
    )

    app.ctx.draw_text(3 * app.width / 4, 30, app.p2_score.str(),
        size:  40
        color: color_accent
        align: .center
    )
    app.ctx.draw_text(3 * app.width / 4, 80, 'Y: ${int(app.p2_y)}',
        size:  16
        color: color_secondary
        align: .center
    )

    if app.paused {
        app.ctx.draw_text(app.width / 2, app.height / 2 - 50, 'PAUSED',
            size:  64
            color: color_accent
            align: .center
        )
        app.ctx.draw_text(app.width / 2, app.height / 2 + 10, 'Press SPACE to Resume',
            size:  20
            color: color_accent
            align: .center
        )
    } else {
        app.ctx.draw_text(app.width / 2, app.height - 25,
            'SPACE: Pause | W/S: P1 | UP/DOWN: P2 | R: Reset',
            size:  16
            color: color_text_dim
            align: .center
        )
    }

    app.ctx.end()
}

fn on_event(e &gg.Event, data voidptr) {
    mut app := unsafe { &App(data) }
    if e.typ == .resized || e.typ == .restored {
        app.update_sizes()
    }
    if e.typ == .key_down {
        match e.key_code {
            .space { app.paused = !app.paused }
            .r { app.reset_game() }
            else {}
        }
    }
}

fn on_update(dt f32, data voidptr) {
    mut app := unsafe { &App(data) }

    if app.paused {
        return
    }

    scale_y := f32(app.height) / 600.0
    paddle_speed := paddle_speed_base * scale_y

    // Paddle 1 movement (W/S)
    if app.ctx.pressed_keys[gg.KeyCode.w] {
        app.p1_y -= paddle_speed * dt
    }
    if app.ctx.pressed_keys[gg.KeyCode.s] {
        app.p1_y += paddle_speed * dt
    }

    // Paddle 2 movement (Up/Down)
    if app.ctx.pressed_keys[gg.KeyCode.up] {
        app.p2_y -= paddle_speed * dt
    }
    if app.ctx.pressed_keys[gg.KeyCode.down] {
        app.p2_y += paddle_speed * dt
    }

    // Constrain paddles
    if app.p1_y < 0 {
        app.p1_y = 0
    }
    if app.p1_y > f32(app.height) - app.paddle_height {
        app.p1_y = f32(app.height) - app.paddle_height
    }
    if app.p2_y < 0 {
        app.p2_y = 0
    }
    if app.p2_y > f32(app.height) - app.paddle_height {
        app.p2_y = f32(app.height) - app.paddle_height
    }

    // Ball movement
    app.ball_x += app.ball_vx * dt
    app.ball_y += app.ball_vy * dt

    // Ball wall collision (Top/Bottom)
    if app.ball_y <= 0 {
        app.ball_y = 0
        app.ball_vy = -app.ball_vy
        audio.push(app.sounds.ping.data, app.sounds.ping.len)
    } else if app.ball_y >= f32(app.height) - app.ball_size {
        app.ball_y = f32(app.height) - app.ball_size
        app.ball_vy = -app.ball_vy
        audio.push(app.sounds.ping.data, app.sounds.ping.len)
    }

    // Ball paddle collision
    // P1
    if app.ball_vx < 0 && app.ball_x <= 20 + app.paddle_width && app.ball_x >= 20 {
        if app.ball_y + app.ball_size >= app.p1_y && app.ball_y <= app.p1_y + app.paddle_height {
            app.ball_x = 20 + app.paddle_width
            app.ball_vx = -app.ball_vx * 1.05 // Slightly speed up
            // Add some vertical velocity based on where it hit the paddle
            hit_pos := (app.ball_y + app.ball_size / 2) - (app.p1_y + app.paddle_height / 2)
            app.ball_vy += hit_pos * 5
            audio.push(app.sounds.pong.data, app.sounds.pong.len)
        }
    }

    // P2
    if app.ball_vx > 0 && app.ball_x + app.ball_size >= f32(app.width) - 20 - app.paddle_width
        && app.ball_x + app.ball_size <= f32(app.width) - 20 {
        if app.ball_y + app.ball_size >= app.p2_y && app.ball_y <= app.p2_y + app.paddle_height {
            app.ball_x = f32(app.width) - 20 - app.paddle_width - app.ball_size
            app.ball_vx = -app.ball_vx * 1.05 // Slightly speed up
            // Add some vertical velocity based on where it hit the paddle
            hit_pos := (app.ball_y + app.ball_size / 2) - (app.p2_y + app.paddle_height / 2)
            app.ball_vy += hit_pos * 5
            audio.push(app.sounds.pong.data, app.sounds.pong.len)
        }
    }

    // Score
    if app.ball_x < 0 {
        app.p2_score++
        app.reset_ball()
        audio.push(app.sounds.buzz.data, app.sounds.buzz.len)
    } else if app.ball_x > f32(app.width) {
        app.p1_score++
        app.reset_ball()
        audio.push(app.sounds.buzz.data, app.sounds.buzz.len)
    }
}

fn main() {
    mut app := &App{}
    app.width = 800
    app.height = 600
    app.paddle_width = 15.0
    app.paddle_height = 80.0
    app.ball_size = 15.0
    app.p1_y = f32(app.height) / 2 - app.paddle_height / 2
    app.p2_y = f32(app.height) / 2 - app.paddle_height / 2
    app.reset_ball()

    audio.setup(buffer_frames: 512)
    app.sounds.init()

    app.ctx = gg.new_context(
        width:         app.width
        height:        app.height
        window_title:  'V Pong'
        user_data:     app
        frame_fn:      on_frame
        event_fn:      on_event
        update_fn:     on_update
        bg_color:      color_bg
        resizable:     true
        create_window: true
    )

    app.ctx.run()
}