use crate::solar_system::SolarSystem;
use crate::solar_system::body::BodyId;
use crate::fleet::{Fleet, FleetId, FleetsManager};

#[derive(Clone)]
pub struct FleetScheduleWindow
{
    pub target: (Option<BodyId>, Option<FleetId>),
    pub linear_acceleration_limit: f32,
    pub angular_acceleration_limit: f32,
}

impl Default for FleetScheduleWindow
{
    fn default() -> Self {
        Self { 
            target: Default::default(), 
            linear_acceleration_limit: 9.81, 
            angular_acceleration_limit: 15.0 
        }
    }
}

impl FleetScheduleWindow
{
    pub fn paint(
        &mut self,
        star_systems: &[SolarSystem],
        fleets_man: &FleetsManager,
        fleet: &Fleet,
        ui: &mut egui::Ui)
    {
        ui.horizontal(|limits_ui| {
            limits_ui.vertical(|linear_limit_ui| {
                linear_limit_ui.label("Linear acceleration limit");
                linear_limit_ui.add(
                    egui::DragValue::new(&mut self.linear_acceleration_limit)
                    .range(0.0..=(9.8*2.0))
                    .clamp_existing_to_range(true)
                    .suffix(" m/s^2")
                    .speed(0.1)
                    .max_decimals_opt(Some(2))
                );
            });
            limits_ui.separator();
            limits_ui.vertical(|angular_limit_ui| {
                angular_limit_ui.label("Angular acceleration limit");
                angular_limit_ui.add(
                    egui::DragValue::new(&mut self.angular_acceleration_limit)
                    .range(0.0..=30.0)
                    .clamp_existing_to_range(true)
                    .suffix(" °/s^2")
                    .speed(0.1)
                    .max_decimals_opt(Some(2))
                );
            });
        });
        ui.separator();

        let fleet_system = &star_systems[fleet.system().unwrap_or(0)];
        let bodies = fleet_system.bodies();
        let bodies_order = fleet_system.heirarchy().traverse_preorder();
        let system_fleets = fleet_system.fleets(fleets_man);

        let row_height = ui.spacing().interact_size.y;
        ui.horizontal(|panel_ui| 
        {
            panel_ui.vertical(|vertical_ui| {
                vertical_ui.set_max_width(128.0);
                vertical_ui.vertical_centered(|centered_ui| {
                    centered_ui.label("Target");
                });
                egui::ScrollArea::vertical()
                    .id_salt("fleet_schedule_objs")
                    .auto_shrink(false)
                    .min_scrolled_height(256.0)
                    .show_rows(vertical_ui, row_height, bodies.len() + system_fleets.len(),
                |objs_ui, rows| {
                    let fleet_rows_start = 0;
                    let bodies_rows_start = system_fleets.len();

                    for row in rows {
                        match row < bodies_rows_start {
                            true => {
                                let id = system_fleets[row - fleet_rows_start];
                                let selected = self.target.1
                                    .is_some_and(|v| { v == id });
                                let fleet = fleets_man.fleet(id);
                                if let Some(fleet) = fleet {
                                    if objs_ui.selectable_label(selected, fleet.name()).clicked() {
                                        self.select_fleet_from_schedule_objs(id, selected);
                                    }
                                }
                            },
                            false => {
                                let id = *bodies_order[row - bodies_rows_start];
                                let selected = self.target.0
                                    .is_some_and(|v| { v == id });
                                let body = &bodies[id];
                                if objs_ui.selectable_label(selected, body.name()).clicked() {
                                    self.select_body_from_schedule_objs(id, selected);
                                }
                            }
                        }
                    }
                });
            });

            panel_ui.vertical(|vertical_ui| {
                vertical_ui.set_max_width(128.0);
                vertical_ui.vertical_centered(|centered_ui| {
                    centered_ui.label("Commands");
                });
                egui::ScrollArea::vertical()
                    .id_salt("fleet_schedule_commands")
                    .auto_shrink(false)
                    .min_scrolled_height(256.0)
                    .show_rows(vertical_ui, row_height, 0,
                |cmd_ui, rows| {

                });
            });
            
            panel_ui.vertical(|vertical_ui| {
                vertical_ui.set_max_width(128.0);
                vertical_ui.vertical_centered(|centered_ui| {
                    centered_ui.label("Schedule");
                });
            });
        });
    }

    fn select_body_from_schedule_objs(
        &mut self,
        id: BodyId,
        selected: bool)
    {
        self.target =
            (if selected { None } else { Some(id) }, None);
    }

    fn select_fleet_from_schedule_objs(
        &mut self,
        id: FleetId,
        selected: bool)
    {
        self.target =
            (None, if selected { None } else { Some(id) });
    }
}