mod drawable;
mod particle;

use drawable::DrawShape;
use nannou::prelude::*;
use particle::Particle;

const PARTICLE_COUNT: u32 = 200;
const PARTICLE_SIZE: f32 = 10.0;

struct Model {
    // Store the window ID so we can refer to this specific window later if needed.
    _window: WindowId,
    particles: Vec<Particle>,
}

fn fill_particles(app: &App, particles: &mut Vec<Particle>) {
    let boundary = app.window_rect();

    for _ in 0..PARTICLE_COUNT {
        let x = random_range(boundary.left(), boundary.right());
        let y = random_range(boundary.top(), boundary.bottom());

        let particle = Particle::new(Vec2::new(x, y));

        particles.push(particle);
    }
}

fn model(app: &App) -> Model {
    // Create a new window! Store the ID so we can refer to it later.
    let _window = app
        .new_window()
        .size(512, 512)
        .title("nannou")
        .view(view) // The function that will be called for presenting graphics to a frame.
        .event(event) // The function that will be called when the window receives events.
        .build()
        .unwrap();

    let mut particles = Vec::new();

    fill_particles(app, &mut particles);

    Model { _window, particles }
}

// Handle events related to the window and update the model if necessary
fn event(app: &App, model: &mut Model, event: WindowEvent) {
    if let KeyReleased(Key::Escape) = event {
        app.quit()
    }

    if let Resized(_) = event {
        model.particles.clear();

        fill_particles(app, &mut model.particles);
    }

    println!("{:?}", event);
}

// Update the state of your application here. By default, this gets called right before `view`.
fn update(_app: &App, _model: &mut Model, _update: Update) {}

// Draw the state of your `Model` into the given `Frame` here.
fn view(app: &App, model: &Model, frame: Frame) {
    let canvas = app.draw();
    canvas.background().color(CORNFLOWERBLUE);

    canvas.draw(&model.particles);

    // I don't think there is even a fail condition in this function, but it returns a result?
    canvas.to_frame(app, &frame).unwrap();
}

fn main() {
    nannou::app(model).update(update).run();
}