use std::cell::RefCell;

use crate::{GameState, eguictx::EguiCtx, solar_system::SystemId, timeman::{self, Second, TimeMan}, ui::{self, bodies_window::BodiesWindowState, fleet_window::FleetWindowState}};

#[derive(Default, Clone)]
pub struct TopBarState
{
    pub current_system: Option<SystemId>,
    pub auto_tick: Option<Second>,
    pub do_auto_tick: bool,
}

#[derive(Default, Clone)]
pub struct TopBarAction
{
    pub advance_tick: Option<Second>,
    pub toggle_bodies_window: bool,
    pub toggle_fleets_window: bool,
}

impl TopBarState
{
    pub fn paint(
        &mut self,
        ui: &mut egui::Ui,
        game_state: &GameState,
        bodies_window_state: &BodiesWindowState,
        fleets_window_state: &FleetWindowState)
    -> TopBarAction
    {
        let mut action: TopBarAction = TopBarAction::default();
        
        let solar_systems = game_state.solar_systems();
        let timeman = game_state.timeman();

        egui::Panel::top("topbar").show_inside(
            ui,
            |ui| {

            ui.horizontal(|ui| {
                ui.vertical(|ui| {
                    let selected_system_label = match self.current_system {
                        Some(id) => solar_systems[id].name(),
                        None => ""
                    };

                    egui::ComboBox::from_label("Current System")
                        .selected_text(selected_system_label)
                        .show_ui(ui, |ui| {
                    
                        for (i, system) in solar_systems.iter().enumerate() {
                            ui.selectable_value(
                                &mut self.current_system,
                                Some(i),
                                system.name()
                            );
                        }
                    });

                    ui.horizontal(|ui| {
                        self.paint_empire_buttons(ui, &mut action, bodies_window_state, fleets_window_state);
                    });
                });

                self.paint_tick_buttons(&mut action, ui);

            });
            ui.vertical_centered_justified(|ui| {
                let time_str = TimeMan::format_duration(timeman.seconds());
                ui.label(
                    egui::RichText::new(time_str)
                        .font(egui::FontId::monospace(16.0))
                    );
            });
        });
        action
    }

    pub fn paint_empire_buttons(
        &mut self,
        ui: &mut egui::Ui,
        action: &mut TopBarAction,
        bodies_window_state: &BodiesWindowState,
        fleets_window_state: &FleetWindowState
        )
    {
        if ui.add(egui::Button::new("Bodies").selected(bodies_window_state.open)).clicked() {
            action.toggle_bodies_window = true;
        }
        if ui.add(egui::Button::new("Fleets").selected(fleets_window_state.open)).clicked() {
            action.toggle_fleets_window = true;
        }
    }
     
    pub fn paint_tick_buttons(
        &mut self,
        action: &mut TopBarAction,
        ui: &mut egui::Ui)
    {
        let button_seconds = [
            1, 
            5, 
            30, 
            timeman::MINUTE, 
            timeman::MINUTE * 5, 
            timeman::MINUTE * 30, 
            timeman::HOUR, 
            timeman::DAY, 
            timeman::DAY * 5, 
            timeman::YEAR
        ];
        let selected_button = self.auto_tick;

        ui.vertical(|ui| {
            ui.label("Manual");
            ui.checkbox(&mut self.do_auto_tick, "Auto");
        });

        button_seconds.iter().for_each(|&seconds| {
            ui.vertical(|ui| {
                let auto_selected = match selected_button {
                    Some(o) => o == seconds,
                    None => false
                };
                let label = TimeMan::format_duration(seconds);

                if ui.button(label.clone()).clicked() {
                    action.advance_tick = Some(seconds);
                }

                if ui.add(egui::Button::new(label.clone()).selected(auto_selected)).clicked() {
                    self.auto_tick = Some(seconds);
                }
            });
        });
    }
}