use cgmath::Rotation3;
use solar_engine::{Application, Body, Key, KeyState, Simulator};
use std::sync::{Arc, RwLock};
use std::thread;

pub async fn run() {
    let simulator = Arc::new(RwLock::new(Simulator::new()));
    {
        let mut sim = simulator.write().unwrap();
        sim.add_body(Body {
            name: "Sun".into(),
            position: [0.0, 0.0],
            velocity: [0.0, 0.0],
            mass: 1.989e30,
        });
        sim.add_body(Body {
            name: "Earth".into(),
            position: [1.496e11, 0.0],
            velocity: [0.0, 29780.0],
            mass: 5.972e24,
        });
    }

    let sim_clone = simulator.clone();
    thread::spawn(move || {
        use std::time::{Duration, Instant};
        let mut last = Instant::now();
        loop {
            let now = Instant::now();
            let dt = now.duration_since(last).as_secs_f64();
            last = now;

            {
                let mut sim = sim_clone.write().unwrap();
                let timewarp = sim.get_timewarp();
                sim.step(dt * timewarp as f64);
            }

            thread::sleep(Duration::from_nanos(1));
        }
    });

    let simulator_clone = simulator.clone();

    Application::new()
        .on_update(move |state| {
            let sim = simulator_clone.read().unwrap();
            let bodies = &sim.bodies;

            let instances = bodies
                .iter()
                .enumerate()
                .map(|(i, b)| {
                    solar_engine::RenderInstance {
                        position: cgmath::Vector3::new(
                            (b.position[0] / 1.496e11) as f32,
                            (b.position[1] / 1.496e11) as f32,
                            0.0,
                        ),
                        rotation: cgmath::Quaternion::from_angle_z(cgmath::Deg(0.0)),
                        color: match i {
                            0 => [1.0, 1.0, 0.0], // Sun
                            1 => [0.0, 0.0, 1.0], // Earth
                            _ => [0.5, 0.5, 0.5],
                        },
                        scale: 0.05,
                        shape: solar_engine::Shape::Circle,
                    }
                })
                .collect();

            state.set_instances(instances);
        })
        .on_input(move |_state, event| {
            if event.state == KeyState::Pressed {
                return match event.key {
                    Key::Period => {
                        let mut sim = simulator.write().unwrap();
                        sim.increase_timewarp();
                        println!("Timewarp: {}", sim.get_timewarp());
                    }
                    Key::Comma => {
                        let mut sim = simulator.write().unwrap();
                        sim.decrease_timewarp();
                        println!("Timewarp: {}", sim.get_timewarp());
                    }
                    Key::Minus => {
                        let mut sim = simulator.write().unwrap();
                        sim.reset_timewarp();
                        println!("Timewarp: {}", sim.get_timewarp());
                    }
                    _ => {}
                };
            }
        })
        .run();
}

fn main() {
    pollster::block_on(run());
}