use glc::vector::{Angle, Vector2f, Vector4f};
use space_crush_common::{
    components::{Orbit, Position},
    constants::SHIP_ORBIT_DISTANCE_MAX,
};
use specs::{prelude::*, ReadStorage, System, World, WriteExpect};

use crate::resources::Geometry;

#[derive(Default)]
pub struct Orbits {}

#[derive(SystemData)]
pub struct OrbitsData<'a> {
    geometry: WriteExpect<'a, Geometry>,
    positions: ReadStorage<'a, Position>,
    orbits: ReadStorage<'a, Orbit>,
}

impl<'a> System<'a> for Orbits {
    type SystemData = OrbitsData<'a>;

    fn run(&mut self, data: Self::SystemData) {
        let OrbitsData {
            mut geometry,
            positions,
            orbits,
        } = data;

        gl::enable(gl::BLEND);

        for (position, orbit) in (&positions, &orbits).join() {
            gl::blend_func(gl::SRC_ALPHA, gl::ONE);
            gl::blend_equation(gl::FUNC_ADD);
            geometry.render_lines(
                Vector4f::new(0.5, 0.5, 0.5, 0.05),
                &create_circle(position.pos(), orbit.min()),
            );
            geometry.render_lines(
                Vector4f::new(0.5, 0.5, 0.5, 0.05),
                &create_circle(position.pos(), orbit.max()),
            );
            geometry.render_lines(
                Vector4f::new(0.5, 0.5, 0.5, 0.05),
                &create_circle(position.pos(), SHIP_ORBIT_DISTANCE_MAX * orbit.max()),
            );
        }

        gl::blend_equation(gl::FUNC_ADD);
        gl::disable(gl::BLEND);
    }
}

fn create_circle(p: &Vector2f, r: f32) -> Vec<Vector2f> {
    let mut points = Vec::new();

    for i in 0..=180 {
        points.push(Vector2f::new(
            p.x + r * Angle::Deg(i as f32 * 2.0).cos(),
            p.y + r * Angle::Deg(i as f32 * 2.0).sin(),
        ));
    }

    points
}