use bevy::{
    diagnostic::{
        DiagnosticsStore, EntityCountDiagnosticsPlugin, FrameTimeDiagnosticsPlugin,
        SystemInformationDiagnosticsPlugin,
    },
    input::{keyboard::KeyboardInput, ButtonState},
    utils::{hashbrown::hash_map::Iter, HashMap},
};

use crate::prelude::*;

pub(crate) struct DebugPlugin;

impl Plugin for DebugPlugin {
    fn build(&self, app: &mut App) {
        app.add_plugins((
            FrameTimeDiagnosticsPlugin,
            EntityCountDiagnosticsPlugin::default(),
            SystemInformationDiagnosticsPlugin::default(),
        ))
        .init_resource::<DebugInfo>()
        .add_systems(Startup, init_debug_ui)
        .add_systems(
            Update,
            (
                toggle_debug_mode.run_if(on_event::<KeyboardInput>()),
                display_diagnostics.run_if(resource_exists::<DebugEnabled>()),
                toggle_debug_ui.run_if(resource_changed_or_removed::<DebugEnabled>()),
                camera_info.run_if(resource_exists::<DebugEnabled>()),
                // gltf_info.run_if(on_event::<AssetEvent<Gltf>>()),
            ),
        );
    }
}

#[derive(Debug, Default, Resource)]
pub(crate) struct DebugInfo(HashMap<String, String>);

impl DebugInfo {
    pub fn set(&mut self, key: String, val: String) -> Option<String> {
        self.0.insert(key, val)
    }

    pub fn _get(&self, key: &String) -> Option<&String> {
        self.0.get(key)
    }

    pub fn iter(&self) -> Iter<'_, String, String> {
        self.0.iter()
    }
}

/// Marker resource used to enable Debug mode when present
#[derive(Debug, Resource, Default)]
pub(crate) struct DebugEnabled;

#[derive(Debug, Component)]
struct DebugRoot;

fn toggle_debug_mode(
    mut events: EventReader<KeyboardInput>,
    enabled: Option<Res<DebugEnabled>>,
    mut commands: Commands,
) {
    events
        .read()
        .filter(
            |KeyboardInput {
                 state, key_code, ..
             }| *state == ButtonState::Pressed && *key_code == Some(KeyCode::F3),
        )
        .for_each(|_| match enabled {
            Some(_) => commands.remove_resource::<DebugEnabled>(),
            None => commands.insert_resource(DebugEnabled),
        });
}

fn toggle_debug_ui(
    mut visibility: Query<&mut Visibility, With<DebugRoot>>,
    enabled: Option<Res<DebugEnabled>>,
) {
    visibility.iter_mut().for_each(|mut vis| {
        *vis = match enabled {
            Some(_) => Visibility::Visible,
            None => Visibility::Hidden,
        }
    });
}

fn init_debug_ui(mut commands: Commands) {
    commands
        .spawn((
            NodeBundle {
                style: Style {
                    padding: UiRect::all(Val::Px(10.0)),
                    ..default()
                },
                background_color: Color::BLACK.into(),
                visibility: Visibility::Hidden,
                ..default()
            },
            DebugRoot,
        ))
        .with_children(|parent| {
            parent.spawn((
                TextBundle {
                    style: Style { ..default() },
                    ..default()
                },
                DebugRoot,
            ));
        });
}

fn display_diagnostics(
    mut root: Query<&mut Text, With<DebugRoot>>,
    diagnostics: Res<DiagnosticsStore>,
    debug_infos: Res<DebugInfo>,
) {
    root.iter_mut().for_each(|mut text| {
        text.sections = diagnostics
            .iter()
            .map(|d| format!("{}: {:.0}\n", d.name, d.smoothed().unwrap_or(0.0),))
            .chain(debug_infos.iter().map(|(k, v)| format!("{}: {}\n", k, v)))
            .map(|s| TextSection::new(s, TextStyle { ..default() }))
            .collect();
        text.sections.sort_unstable_by(|a, b| a.value.cmp(&b.value));
    });
}

fn camera_info(mut debug_infos: ResMut<DebugInfo>, cameras: Query<(&Camera, &Name)>) {
    let camera_names = cameras
        .iter()
        .filter(|(c, _)| c.is_active)
        .map(|(_, n)| n.as_str())
        .collect::<Vec<&str>>()
        .iter()
        .copied()
        .intersperse(", ")
        .collect::<String>();
    debug_infos.set("Cameras".into(), camera_names);
}

fn gltf_info(
    gltfs: Res<Assets<Gltf>>,
) {
    gltfs.iter().for_each(|(_, gltf)| {
        info!("Named animations: {:#?}", gltf.named_animations);
    });
}