use std::collections::HashMap;

use bevy::{prelude::*, transform::TransformSystem};
use bevy_synthizer::{Buffer, Sound};
use rand::random;

use crate::{commands::RunIfExistsExt, core::PointLike};

#[derive(Component, Clone, Debug, Reflect)]
#[reflect(Component)]
pub struct Footstep {
    pub buffer: Handle<Buffer>,
    pub step_length: f32,
    pub gain: f64,
    pub pitch: Option<f64>,
    pub pitch_variation: Option<f64>,
}

impl Default for Footstep {
    fn default() -> Self {
        Self {
            buffer: default(),
            step_length: 0.8,
            gain: 1.,
            pitch: None,
            pitch_variation: Some(0.15),
        }
    }
}

fn added(mut commands: Commands, footsteps: Query<(Entity, &Footstep), Added<Footstep>>) {
    for (entity, footstep) in &footsteps {
        let buffer = footstep.buffer.clone();
        commands.run_if_exists(entity, move |mut entity| {
            entity.insert(Sound {
                audio: buffer.into(),
                paused: true,
                ..default()
            });
        });
    }
}

fn update(
    mut last_step_distance: Local<HashMap<Entity, (f32, GlobalTransform)>>,
    mut footsteps: Query<(Entity, &Footstep, &Parent, &mut Sound)>,
    transforms_storage: Query<&GlobalTransform>,
) {
    for (entity, footstep, parent, mut sound) in &mut footsteps {
        if let Ok(transform) = transforms_storage.get(**parent) {
            if let Some(last) = last_step_distance.get(&entity) {
                let distance = last.0 + (last.1.distance(transform));
                if distance >= footstep.step_length {
                    last_step_distance.insert(entity, (0., *transform));
                    sound.gain = footstep.gain;
                    sound.pitch = footstep.pitch.unwrap_or(1.);
                    if let Some(pitch_variation) = footstep.pitch_variation {
                        let mut pitch = sound.pitch - pitch_variation / 2.;
                        pitch += random::<f64>() * pitch_variation;
                        sound.pitch = pitch;
                    }
                    sound.paused = false;
                    sound.restart = true;
                } else if last.1 != *transform {
                    last_step_distance.insert(entity, (distance, *transform));
                }
            } else {
                last_step_distance.insert(entity, (0., *transform));
            }
        }
    }
}

pub struct FootstepPlugin;

impl Plugin for FootstepPlugin {
    fn build(&self, app: &mut App) {
        app.register_type::<Footstep>()
            .add_system(added.in_base_set(CoreSet::PreUpdate))
            .add_system(
                update
                    .after(TransformSystem::TransformPropagate)
                    .in_base_set(CoreSet::PostUpdate),
            );
    }
}