use crate::{actor, audio, camera, chat, nature, settings, world};
use bevy::prelude::*;
use bevy::diagnostic::{DiagnosticsStore, FrameTimeDiagnosticsPlugin};
use bevy::transform::TransformSystem;
use bevy_xpbd_3d::prelude::*;
use bevy::math::DVec3;
use std::collections::VecDeque;
use std::time::SystemTime;

pub const HUD_REFRESH_TIME: f32 = 0.1;
pub const FONT: &str = "fonts/Yupiter-Regular.ttf";
pub const LOG_MAX: usize = 20;
pub const LOG_MAX_TIME_S: u64 = 20;
pub const AMBIENT_LIGHT: f32 = 0.0; // Space is DARK
pub const AMBIENT_LIGHT_AR: f32 = 15.0;
//pub const REPLY_NUMBERS: [char; 10] = ['❶', '❷', '❸', '❹', '❺', '❻', '❼', '❽', '❾', '⓿'];
//pub const REPLY_NUMBERS: [char; 10] = ['①', '②', '③', '④', '⑤', '⑥', '⑦', '⑧', '⑨', '⑩'];
pub const REPLY_NUMBERS: [char; 10] = ['➀', '➁', '➂', '➃', '➄', '➅', '➆', '➇', '➈', '➉'];

pub struct HudPlugin;
impl Plugin for HudPlugin {
    fn build(&self, app: &mut App) {
        app.add_systems(Startup, setup);
        app.add_systems(Update, (
            update_hud,
            update_ar_overlays,
            handle_input,
            handle_target_event,
        ));
        app.add_systems(PostUpdate, (
            update_target_selectagon
                .after(PhysicsSet::Sync)
                .after(camera::apply_input_to_player)
                .before(TransformSystem::TransformPropagate),
        ));
        app.insert_resource(AugmentedRealityState {
            overlays_visible: false,
        });
        app.insert_resource(Log {
            logs: VecDeque::with_capacity(LOG_MAX),
            needs_rerendering: true,
        });
        app.insert_resource(FPSUpdateTimer(
                Timer::from_seconds(HUD_REFRESH_TIME, TimerMode::Repeating)));
        app.add_event::<TargetEvent>();
    }
}

#[derive(Event)] pub struct TargetEvent(pub Option<Entity>);
#[derive(Component)] struct GaugesText;
#[derive(Component)] struct ChatText;
#[derive(Component)] struct Reticule;
#[derive(Component)] struct ToggleableHudElement;
#[derive(Component)] struct OnlyHideWhenTogglingHud;
#[derive(Component)] struct Selectagon;
#[derive(Component)] pub struct IsTargeted;

#[derive(Resource)]
pub struct AugmentedRealityState {
    pub overlays_visible: bool,
}

#[derive(Component)] pub struct AugmentedRealityOverlayBroadcaster;
#[derive(Component)]
pub struct AugmentedRealityOverlay {
    pub owner: Entity,
}

#[derive(Resource)]
struct FPSUpdateTimer(Timer);

pub enum LogLevel {
    Warning,
    //Error,
    Info,
    //Debug,
    Chat,
    //Ping,
    Notice,
}

struct Message {
    text: String,
    sender: String,
    level: LogLevel,
    time: u64,
}

#[derive(Component)]
pub struct IsClickable {
    pub name: Option<String>,
    pub distance: Option<f64>,
}
impl Default for IsClickable { fn default() -> Self { Self {
    name: None,
    distance: None,
}}}

#[derive(Resource)]
pub struct Log {
    logs: VecDeque<Message>,
    needs_rerendering: bool,
}

impl Log {
    pub fn info(&mut self, message: String) {
        self.add(message, "System".to_string(), LogLevel::Info);
    }

    pub fn chat(&mut self, message: String, sender: String) {
        self.add(message, sender, LogLevel::Chat);
    }

    pub fn warning(&mut self, message: String) {
        self.add(message, "WARNING".to_string(), LogLevel::Warning);
    }

    pub fn notice(&mut self, message: String) {
        self.add(message, "".to_string(), LogLevel::Notice);
    }

    pub fn add(&mut self, message: String, sender: String, level: LogLevel) {
        if self.logs.len() == LOG_MAX {
            self.logs.pop_front();
        }
        if let Ok(epoch) = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {
            self.logs.push_back(Message {
                text: message,
                sender: sender,
                level: level,
                time: epoch.as_secs(),
            });
            self.needs_rerendering = true;
        }
    }

    pub fn remove_old(&mut self) {
        if let Some(message) = self.logs.front() {
            if let Ok(epoch) = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {
                if epoch.as_secs() - message.time > LOG_MAX_TIME_S {
                    self.logs.pop_front();
                }
            }
        }
    }

    pub fn clear(&mut self) {
        self.logs.clear();
    }
}

fn setup(
    mut commands: Commands,
    settings: Res<settings::Settings>,
    asset_server: Res<AssetServer>,
    mut log: ResMut<Log>,
    mut ambient_light: ResMut<AmbientLight>,
) {
    log.notice("Resuming from suspend".to_string());
    log.notice("WARNING: Oxygen Low".to_string());
    let visibility = if settings.hud_active {
        Visibility::Inherited
    } else {
        Visibility::Hidden
    };
    let mut bundle_fps = TextBundle::from_sections([
        TextSection::new(
            "",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::GRAY,
                ..default()
            }
        ),
        TextSection::new(
            " ⚡ ",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::GRAY,
                ..default()
            },
        ),
        TextSection::new(
            "",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::GRAY,
                ..default()
            }
        ),
        TextSection::new(
            " ☣ ",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::GRAY,
                ..default()
            },
        ),
        TextSection::new(
            "",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::GRAY,
                ..default()
            }
        ),
        TextSection::new(
            "",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::GRAY,
                ..default()
            }
        ),
        TextSection::new(
            "\n氧 OXYGEN ",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::GRAY,
                ..default()
            },
        ),
        TextSection::new(
            "",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::MAROON,
                ..default()
            }
        ),
        TextSection::new(
            "\nProximity 警告 ",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::GRAY,
                ..default()
            },
        ),
        TextSection::new(
            "",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::GRAY,
                ..default()
            }
        ),
        TextSection::new(
            "\nSuit Integrity ",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::GRAY,
                ..default()
            },
        ),
        TextSection::new(
            "",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::GRAY,
                ..default()
            }
        ),
        TextSection::new(
            "\nVitals ",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::GRAY,
                ..default()
            },
        ),
        TextSection::new(
            "",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::GRAY,
                ..default()
            }
        ),
        TextSection::new( // Target
            "",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::GRAY,
                ..default()
            }
        ),
    ]).with_style(Style {
        top: Val::VMin(2.0),
        left: Val::VMin(3.0),
        ..default()
    });
    bundle_fps.visibility = visibility;
    commands.spawn((
        GaugesText,
        ToggleableHudElement,
        bundle_fps,
    ));

    // Add Chat Box
    let bundle_chatbox = TextBundle::from_sections([
        TextSection::new(
            "Warning: System Log Uninitialized",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::rgb(0.7, 0.7, 0.7),
                ..default()
            }
        ),
        TextSection::new(
            "\n",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::WHITE,
                ..default()
            }
        ),
        TextSection::new(
            "\n\n\n",
            TextStyle {
                font: asset_server.load(FONT),
                font_size: settings.font_size_hud,
                color: Color::WHITE,
                ..default()
            }
        ),
    ]).with_style(Style {
        position_type: PositionType::Absolute,
        bottom: Val::VMin(0.0),
        left: Val::VMin(0.0),
        ..default()
    }).with_text_justify(JustifyText::Left);
    commands.spawn((
        NodeBundle {
            style: Style {
                width: Val::Percent(50.),
                align_items: AlignItems::Start,
                position_type: PositionType::Absolute,
                bottom: Val::Vh(10.0),
                left: Val::Vw(25.0),
                ..default()
            },
            ..default()
        },
    )).with_children(|parent| {
         parent.spawn((
             bundle_chatbox,
             ChatText,
         ));
    });

    commands.spawn((
        Reticule,
        ToggleableHudElement,
        NodeBundle {
            style: Style {
                width: Val::Px(2.0),
                height: Val::Px(2.0),
                position_type: PositionType::Absolute,
                top: Val::Vh(50.0),
                left: Val::Vw(50.0),
                ..default()
            },
            visibility: visibility,
            background_color: Color::rgb(0.4, 0.4, 0.6).into(),
            ..default()
        },
    ));

    // Selectagon
    commands.spawn((
        Selectagon,
        ToggleableHudElement,
        OnlyHideWhenTogglingHud,
        SceneBundle {
            scene: asset_server.load(world::asset_name_to_path("selectagon")),
            visibility: Visibility::Hidden,
            ..default()
        },
    ));

    // AR-related things
    ambient_light.brightness = if settings.hud_active {
        AMBIENT_LIGHT_AR
    } else {
        AMBIENT_LIGHT
    };
}

fn update_hud(
    diagnostics: Res<DiagnosticsStore>,
    time: Res<Time>,
    mut log: ResMut<Log>,
    player: Query<(&actor::HitPoints, &actor::Suit, &actor::ExperiencesGForce), With<actor::Player>>,
    q_camera: Query<(&Position, &LinearVelocity), With<actor::PlayerCamera>>,
    mut timer: ResMut<FPSUpdateTimer>,
    mut query: Query<&mut Text, With<GaugesText>>,
    q_choices: Query<&chat::Choice>,
    mut query_chat: Query<&mut Text, (With<ChatText>, Without<GaugesText>)>,
    query_all_actors: Query<&actor::Actor>,
    settings: Res<settings::Settings>,
    q_target: Query<(&IsClickable, Option<&Position>, Option<&LinearVelocity>), With<IsTargeted>>,
) {
    // TODO only when hud is actually on
    if timer.0.tick(time.delta()).just_finished() || log.needs_rerendering {
        let q_camera_result = q_camera.get_single();
        let player = player.get_single();
        if player.is_ok() && q_camera_result.is_ok() {
            let (hp, suit, gforce) = player.unwrap();
            let (pos, cam_v) = q_camera_result.unwrap();
            for mut text in &mut query {
                text.sections[0].value = format!("2524-03-12 03:02");
                if let Some(fps) = diagnostics.get(&FrameTimeDiagnosticsPlugin::FPS) {
                    if let Some(value) = fps.smoothed() {
                        // Update the value of the second section
                        text.sections[4].value = format!("{value:.0}");
                    }
                }
                let power = suit.power / suit.power_max * 100.0;
                text.sections[2].value = format!("{power:}%");
                let oxy_percent = suit.oxygen / suit.oxygen_max * 100.0;

                // the remaining oxygen hud info ignores leaking suits from low integrity
                if suit.oxygen > nature::OXY_H {
                    let oxy_hour = suit.oxygen / nature::OXY_H;
                    text.sections[7].value = format!("{oxy_percent:.1}% [lasts {oxy_hour:.1} hours]");
                } else {
                    let oxy_min = suit.oxygen / nature::OXY_M;
                    text.sections[7].value = format!("{oxy_percent:.1}% [lasts {oxy_min:.1} min]");
                }
                //let adrenaline = lifeform.adrenaline * 990.0 + 10.0;
                //text.sections[11].value = format!("{adrenaline:.0}pg/mL");
                let vitals = 100.0 * hp.current / hp.max;
                text.sections[13].value = format!("{vitals:.0}%");
                let all_actors = query_all_actors.iter().len();
                text.sections[9].value = format!("{all_actors:.0}");
                let integrity = suit.integrity * 100.0;
                text.sections[11].value = format!("{integrity:.0}%");
                //text.sections[17].value = format!("{speed_readable}/s / {kmh:.0}km/h / {gforce:.1}g");

                // Target display
                let dist_scalar: f64;
                if let Ok((IsClickable { distance: Some(dist), .. }, _, _)) = q_target.get_single() {
                    dist_scalar = *dist;
                }
                else {
                    let target: Option<DVec3>;
                    if let Ok((_, Some(targetpos), _)) = q_target.get_single() {
                        target = Some(targetpos.0);
                    }
                    else if q_target.is_empty() {
                        target = Some(DVec3::new(0.0, 0.0, 0.0));
                    }
                    else {
                        target = None;
                    }
                    if let Some(target_pos) = target {
                        let dist = pos.0 - target_pos;
                        dist_scalar = dist.length();
                    }
                    else {
                        dist_scalar = 0.0;
                    }
                }

                let dev_speed = if settings.dev_mode {
                    let x = pos.x;
                    let y = pos.y;
                    let z = pos.z;
                    format!("\n{x:.0}\n{y:.0}\n{z:.0}")
                } else {
                    "".to_string()
                };
                let gforce = gforce.gforce;
                if let Ok((clickable, _, target_v_maybe)) = q_target.get_single() {
                    let distance = if dist_scalar.is_nan() {
                        "UNKNOWN".to_string()
                    } else if dist_scalar != 0.0 {
                        nature::readable_distance(dist_scalar)
                    } else {
                        "ERROR".to_string()
                    };
                    let speed: f64 = if let Some(target_v) = target_v_maybe {
                        (target_v.0 - cam_v.0).length()
                    } else {
                        cam_v.length()
                    };
                    let speed_readable = nature::readable_distance(speed);
                    let target_name = clickable.name.clone().unwrap_or("Unnamed".to_string());
                    text.sections[14].value = format!("\n\nTarget: {target_name}\nDistance: {distance}\nΔv {speed_readable}/s + {gforce:.1}g{dev_speed}");
                }
                else {
                    let speed = cam_v.length();
                    let speed_readable = nature::readable_distance(speed);
                    text.sections[14].value = format!("\nv {speed_readable}/s + {gforce:.1}g{dev_speed}");
                }
            }
        }

        if let Ok(mut chat) = query_chat.get_single_mut() {
            // Choices
            let mut choices: Vec<String> = Vec::new();
            let mut count = 0;
            for choice in &q_choices {
                if count > 9 {
                    break;
                }
                let press_this = REPLY_NUMBERS[choice.key];
                let reply = &choice.text;
                //let recipient = &choice.recipient;
                // TODO: indicate recipients if there's more than one
                choices.push(format!("{press_this}  {reply}"));
                count += 1;
            }
            if count < 4 {
                for _padding in 0..(4-count) {
                    choices.push(" ".to_string());
                }
            }
            chat.sections[2].value = choices.join("\n");

            // Chat Log and System Log
            let logfilter = if settings.hud_active {
                |_msg: &&Message| { true }
            } else {
                |msg: &&Message| { match msg.level {
                    LogLevel::Chat => true,
                    LogLevel::Warning => true,
                    LogLevel::Info => true,
                    _ => false
                }}
            };
            let logs_vec: Vec<String> = log.logs.iter()
                .filter(logfilter)
                .map(|s| if s.sender.is_empty() {
                    format!("{}", s.text)
                } else {
                    format!("{}: {}", s.sender, s.text)
                }).collect();
            chat.sections[0].value = logs_vec.join("\n");
        }
        log.needs_rerendering = false;
        log.remove_old();
    }
}

fn handle_input(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mouse_input: Res<ButtonInput<MouseButton>>,
    mut settings: ResMut<settings::Settings>,
    mut q_hud: Query<(&mut Visibility, Option<&OnlyHideWhenTogglingHud>), With<ToggleableHudElement>>,
    mut ew_sfx: EventWriter<audio::PlaySfxEvent>,
    mut ew_togglemusic: EventWriter<audio::ToggleMusicEvent>,
    mut ew_target: EventWriter<TargetEvent>,
    mut ambient_light: ResMut<AmbientLight>,
    q_objects: Query<(Entity, &Transform), (With<IsClickable>, Without<IsTargeted>, Without<actor::PlayerDrivesThis>, Without<actor::Player>)>,
    q_camera: Query<&Transform, With<Camera>>,
) {
    if keyboard_input.just_pressed(settings.key_togglehud) {
        if settings.hud_active {
            for (mut hudelement_visibility, _) in q_hud.iter_mut() {
                *hudelement_visibility = Visibility::Hidden;
            }
            settings.hud_active = false;
            ambient_light.brightness = AMBIENT_LIGHT;
        }
        else {
            for (mut hudelement_visibility, only_hide) in q_hud.iter_mut() {
                if only_hide.is_none() {
                    *hudelement_visibility = Visibility::Inherited;
                }
            }
            settings.hud_active = true;
            ambient_light.brightness = AMBIENT_LIGHT_AR;
        }
        ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::Switch));
        ew_togglemusic.send(audio::ToggleMusicEvent());
    }
    if settings.hud_active && mouse_input.just_pressed(settings.key_selectobject) {
        if let Ok(camtrans) = q_camera.get_single() {
            let objects: Vec<(Entity, &Transform)> = q_objects.iter().collect();
            if let (Some(new_target), _dist) = camera::find_closest_target::<Entity>(objects, camtrans) {
                ew_target.send(TargetEvent(Some(new_target)));
            }
            else {
                ew_target.send(TargetEvent(None));
            }
        }
    }
}

fn handle_target_event(
    mut commands: Commands,
    settings: Res<settings::Settings>,
    mut er_target: EventReader<TargetEvent>,
    mut ew_sfx: EventWriter<audio::PlaySfxEvent>,
    q_target: Query<Entity, With<IsTargeted>>,
) {
    let mut play_sfx = false;

    for TargetEvent(target) in er_target.read() {
        for old_target in &q_target {
            commands.entity(old_target).remove::<IsTargeted>();
            play_sfx = true;
        }
        if let Some(entity) = target {
            commands.entity(*entity).insert(IsTargeted);
            play_sfx = true;
        }
        if play_sfx && !settings.mute_sfx {
            ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::Click));
        }
        break; // Only accept a single event per frame
    }
}

fn update_target_selectagon(
    settings: Res<settings::Settings>,
    mut q_selectagon: Query<(&mut Transform, &mut Visibility), (With<Selectagon>, Without<IsTargeted>, Without<Camera>)>,
    q_target: Query<&Transform, (With<IsTargeted>, Without<Camera>, Without<Selectagon>)>,
    q_camera: Query<&Transform, (With<Camera>, Without<IsTargeted>, Without<Selectagon>)>,
) {
    if !settings.hud_active || q_camera.is_empty() {
        return;
    }
    let camera_trans = q_camera.get_single().unwrap();

    if let Ok((mut selectagon_trans, mut selectagon_vis)) = q_selectagon.get_single_mut() {
        if let Ok(target_trans) = q_target.get_single() {
            match *selectagon_vis {
                Visibility::Hidden => { *selectagon_vis = Visibility::Visible; },
                _ => {}
            }
            selectagon_trans.translation = target_trans.translation;
            selectagon_trans.scale = target_trans.scale;
            selectagon_trans.rotation = camera_trans.rotation;

            // Enlarge Selectagon to a minimum angular diameter
            let (angular_diameter, _, _) = camera::calc_angular_diameter(
                &selectagon_trans, camera_trans);
            let min_angular_diameter = 2.0f32.to_radians();
            if angular_diameter < min_angular_diameter {
                selectagon_trans.scale *= min_angular_diameter / angular_diameter;
            }
        }
        else {
            match *selectagon_vis {
                Visibility::Hidden => {},
                _ => { *selectagon_vis = Visibility::Hidden; }
            }
        }
    }
}

fn update_ar_overlays (
    q_owners: Query<(Entity, &Transform, &Visibility), (With<AugmentedRealityOverlayBroadcaster>, Without<AugmentedRealityOverlay>)>,
    mut q_overlays: Query<(&mut Transform, &mut Visibility, &mut AugmentedRealityOverlay)>,
    settings: ResMut<settings::Settings>,
    mut state: ResMut<AugmentedRealityState>,
) {
    let (need_activate, need_clean, need_update);
    if settings.hud_active {
        need_activate = !state.overlays_visible;
        need_clean = false;
    }
    else {
        need_activate = false;
        need_clean = state.overlays_visible;
    }
    need_update = settings.hud_active;
    state.overlays_visible = settings.hud_active;

    if need_update || need_clean || need_activate {
        for (mut trans, mut vis, ar) in &mut q_overlays {
            for (owner_id, owner_trans, owner_vis) in &q_owners {
                if owner_id == ar.owner {
                    *trans = *owner_trans;
                    if need_clean {
                        *vis = Visibility::Hidden;
                    }
                    else {
                        *vis = *owner_vis;
                    }
                    break;
                }
            }
        }
    }
}