import gg
import math
import time
import rand

const pwidth = 800

const pheight = 600

struct AppState {
mut:
    gg          &gg.Context = unsafe { nil }
    istream_idx int
    pixels      [pheight][pwidth]gg.Color
}

@[direct_array_access]
fn (mut state AppState) update() {
    for {
        unsafe { vmemset(&state.pixels, 0, pwidth * pheight * sizeof[gg.Color]()) }
        state.draw_sky() or {}
        time.sleep(30_000 * time.millisecond)
    }
}

fn (mut state AppState) draw_sky() ! {
    for _ in 0 .. 2000 {
        mut star_size := 1
        for rand.i32_in_range(0, 100)! < 5 {
            star_size += 10
        }
        for rand.i32_in_range(0, 100000)! < 5 {
            star_size += 85
        }
        sx := if star_size < 10 {
            rand.i32_in_range(-40, pwidth + 40)!
        } else {
            rand.i32_in_range(40, pwidth - 40)!
        }
        sy := if star_size < 10 {
            rand.i32_in_range(-40, pheight + 40)!
        } else {
            rand.i32_in_range(40, pheight - 40)!
        }
        state.draw_star(sx, sy, gg.Color{
            r: u8(rand.i32_in_range(50, 255)!)
            g: u8(rand.i32_in_range(50, 255)!)
            b: u8(rand.i32_in_range(50, 255)!)
        }, star_size)
    }
}

@[direct_array_access]
fn (mut state AppState) draw_star(x int, y int, c gg.Color, radius int) {
    if radius == 0 {
        return
    }
    minx := math.max(0, x - radius)
    miny := math.max(0, y - radius)
    maxx := math.min(pwidth, x + radius)
    maxy := math.min(pheight, y + radius)
    for cx in minx .. maxx {
        for cy in miny .. maxy {
            dx := math.abs[f32](cx - x) / f32(radius)
            dy := math.abs[f32](cy - y) / f32(radius)
            gradient := math.max[f32](0, math.min[f32](1, 1 - (math.sqrtf(dx) + math.sqrtf(dy))))
            if gradient < 0.01 {
                continue
            }
            mut pixel := unsafe { &state.pixels[cy][cx] }
            color := gg.Color{
                r: u8(math.min(255, int(pixel.r) + int(f32(c.r) * gradient)))
                g: u8(math.min(255, int(pixel.g) + int(f32(c.g) * gradient)))
                b: u8(math.min(255, int(pixel.b) + int(f32(c.b) * gradient)))
                a: 255
            }
            unsafe {
                *pixel = color
            }
        }
    }
}

fn (mut state AppState) draw() {
    mut istream_image := state.gg.get_cached_image_by_idx(state.istream_idx)
    istream_image.update_pixel_data(unsafe { &u8(&state.pixels) })
    size := gg.window_size()
    sx := -50 + 50 * math.sinf(f32(state.gg.frame) / 100)
    sy := -50 + 50 * math.cosf(f32(state.gg.frame) / 100)
    scale := 200 + 50 * math.sinf(f32(state.gg.frame) / 300)
    wx := size.width + scale
    wy := size.height + scale
    state.gg.draw_image(sx, sy, wx, wy, istream_image)
}

fn graphics_init(mut state AppState) {
    state.istream_idx = state.gg.new_streaming_image(pwidth, pheight, 4, pixel_format: .rgba8)
}

fn graphics_frame(mut state AppState) {
    state.gg.begin()
    state.draw()
    state.gg.end()
}

fn main() {
    mut state := &AppState{}
    state.gg = gg.new_context(
        width:        pwidth
        height:       pheight
        window_title: 'Random stars'
        init_fn:      graphics_init
        frame_fn:     graphics_frame
        user_data:    state
    )
    spawn state.update()
    state.gg.run()
}