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

use crate::{
    components::FleetInfo,
    misc::{HorizontalAlign, Text, TextManager, VerticalAlign},
    resources::{Camera, Geometry},
    Error,
};

pub struct Fleets {
    text: Text,
}

#[derive(SystemData)]
pub struct FleetData<'a> {
    geometry: WriteExpect<'a, Geometry>,
    camera: ReadExpect<'a, Camera>,
    positions: ReadStorage<'a, Position>,
    fleets: ReadStorage<'a, Fleet>,
    fleet_infos: ReadStorage<'a, FleetInfo>,
}

impl Fleets {
    pub fn new(manager: &TextManager) -> Result<Self, Error> {
        let cache = manager.create_cache()?;
        let text = cache
            .new_text()
            .scale(20.0)
            .font("resources/fonts/DroidSansMono.ttf")
            .color(0.7, 0.7, 0.7, 1.0)
            .vert_align(VerticalAlign::Center)
            .horz_align(HorizontalAlign::Center)
            .text("")
            .build()?;

        Ok(Self { text })
    }
}

impl<'a> System<'a> for Fleets {
    type SystemData = FleetData<'a>;

    fn run(&mut self, data: Self::SystemData) {
        let FleetData {
            mut geometry,
            camera,
            positions,
            fleets,
            fleet_infos,
        } = data;

        gl::enable(gl::BLEND);

        for (position, fleet, fleet_info) in (&positions, &fleets, &fleet_infos).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, fleet.orbit_min),
            );
            geometry.render_lines(
                Vector4f::new(0.5, 0.5, 0.5, 0.05),
                &create_circle(position.pos, fleet.orbit_max),
            );
            geometry.render_lines(
                Vector4f::new(0.5, 0.5, 0.5, 0.05),
                &create_circle(position.pos, SHIP_ORBIT_DISTANCE_MAX * fleet.orbit_max),
            );

            gl::blend_func(gl::SRC_ALPHA, gl::ONE_MINUS_SRC_ALPHA);
            gl::blend_equation(gl::FUNC_SUBTRACT);
            self.text
                .update(
                    0,
                    format!(
                        "F:{}\nB:{}\nT:{}",
                        fleet_info.count.fighter,
                        fleet_info.count.bomber,
                        fleet_info.count.transporter
                    ),
                )
                .panic("Unable to update text")
                .render_offset(&camera.world_to_window(position.pos));
        }

        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
}