use std::{fmt::Debug, hash::Hash, time::Duration};

use bevy::prelude::*;
use bevy_synthizer::{Buffer, Sound};

use rand::random;

use crate::{
    commands::RunIfExistsExt,
    core::Player,
    exploration::ExplorationFocused,
    visibility::{VisibilityChanged, Visible, VisibleEntities},
};

#[derive(Component, Clone, Debug, Reflect)]
#[reflect(Component)]
pub struct SoundIcon {
    pub buffer: Handle<Buffer>,
    pub gain: f64,
    pub pitch: f64,
    pub interval: Option<Timer>,
}

impl Default for SoundIcon {
    fn default() -> Self {
        let seconds = random::<f32>() + 4.5;
        let mut icon = Self {
            buffer: default(),
            gain: 1.,
            pitch: 1.,
            interval: Some(Timer::from_seconds(seconds, TimerMode::Repeating)),
        };
        if let Some(ref mut interval) = icon.interval {
            let seconds = Duration::from_secs_f32(seconds - 0.1);
            interval.set_elapsed(seconds);
        }
        icon
    }
}

fn added(mut commands: Commands, icons: Query<(Entity, &SoundIcon), Added<SoundIcon>>) {
    for (entity, icon) in icons.iter() {
        let buffer = icon.buffer.clone();
        let gain = icon.gain;
        let pitch = icon.pitch;
        let looping = icon.interval.is_none();
        commands.run_if_exists(entity, move |mut entity| {
            entity.insert(Sound {
                buffer,
                gain,
                pitch,
                looping,
                paused: true,
                ..default()
            });
        });
    }
}

fn update<S>(
    config: Res<SoundIconPlugin<S>>,
    state: Res<State<S>>,
    time: Res<Time>,
    viewers: Query<&VisibleEntities, With<Player>>,
    mut icons: Query<(
        Entity,
        &mut SoundIcon,
        Option<&Visible>,
        Option<&Parent>,
        &mut Sound,
    )>,
) where
    S: 'static + Clone + Debug + Eq + Hash + Send + Sync,
{
    if !config.states.is_empty() && !config.states.contains(state.current()) {
        return;
    }
    for visible in viewers.iter() {
        for (icon_entity, mut icon, visibility, parent, mut sound) in icons.iter_mut() {
            let entity = if visibility.is_some() {
                Some(icon_entity)
            } else if parent.is_some() {
                Some(**parent.unwrap())
            } else {
                None
            };
            if let Some(entity) = entity {
                if visible.contains(&entity) {
                    if sound.looping {
                        sound.paused = false;
                    } else if let Some(interval) = icon.interval.as_mut() {
                        interval.tick(time.delta());
                        if interval.finished() {
                            sound.paused = false;
                            sound.restart = true;
                            interval.reset();
                        }
                    }
                    let buffer = icon.buffer.clone();
                    if sound.buffer != buffer {
                        sound.buffer = buffer;
                    }
                    sound.gain = icon.gain;
                    sound.pitch = icon.pitch;
                    sound.looping = icon.interval.is_none();
                } else if !sound.paused {
                    sound.paused = true;
                    sound.restart = true;
                }
            }
        }
    }
}

fn exploration_focus_changed(
    mut focused: Query<(Entity, Option<&Children>), Changed<ExplorationFocused>>,
    mut icons: Query<&mut SoundIcon>,
) {
    const ICON_GAIN: f64 = 3.;
    for (entity, children) in focused.iter_mut() {
        if let Ok(mut icon) = icons.get_mut(entity) {
            icon.gain *= ICON_GAIN;
        }
        if let Some(children) = children {
            for child in children.iter() {
                if let Ok(mut icon) = icons.get_mut(*child) {
                    icon.gain *= ICON_GAIN;
                }
            }
        }
    }
}

fn exploration_focus_removed(
    removed: RemovedComponents<ExplorationFocused>,
    mut query: Query<&mut SoundIcon>,
    children: Query<&Children>,
) {
    const ICON_GAIN: f64 = 3.;
    for entity in removed.iter() {
        if let Ok(mut icon) = query.get_mut(entity) {
            icon.gain /= ICON_GAIN;
        }
        if let Ok(children) = children.get(entity) {
            for child in children.iter() {
                if let Ok(mut icon) = query.get_mut(*child) {
                    icon.gain /= ICON_GAIN;
                }
            }
        }
    }
}

fn reset_timer_on_visibility_gain(
    mut events: EventReader<VisibilityChanged>,
    player: Query<Entity, With<Player>>,
    mut icons: Query<&mut SoundIcon>,
    children: Query<&Children>,
) {
    for event in events.iter() {
        if let VisibilityChanged::Gained { viewer, viewed } = event {
            if player.get(*viewer).is_ok() {
                let mut targets = vec![];
                if icons.get(*viewed).is_ok() {
                    targets.push(viewed);
                }
                if let Ok(children) = children.get(*viewed) {
                    for child in children.iter() {
                        if icons.get(*child).is_ok() {
                            targets.push(child);
                        }
                    }
                }
                for icon in targets.iter_mut() {
                    if let Ok(mut icon) = icons.get_mut(**icon) {
                        if let Some(timer) = icon.interval.as_mut() {
                            timer.set_elapsed(timer.duration());
                        }
                    }
                }
            }
        }
    }
}

#[derive(Resource, Clone)]
pub struct SoundIconPlugin<S> {
    pub states: Vec<S>,
}

impl<S> Default for SoundIconPlugin<S> {
    fn default() -> Self {
        Self { states: default() }
    }
}

impl<S> Plugin for SoundIconPlugin<S>
where
    S: 'static + Clone + Debug + Eq + Hash + Send + Sync,
{
    fn build(&self, app: &mut App) {
        app.insert_resource(self.clone())
            .register_type::<SoundIcon>()
            .add_system(added)
            .add_system_to_stage(CoreStage::PostUpdate, update::<S>)
            .add_system_to_stage(
                CoreStage::PostUpdate,
                exploration_focus_changed.after(update::<S>),
            )
            .add_system_to_stage(
                CoreStage::PostUpdate,
                exploration_focus_removed.after(exploration_focus_changed),
            )
            .add_system_to_stage(CoreStage::PostUpdate, reset_timer_on_visibility_gain);
    }
}