use std::{ops::DerefMut, time::Duration};

use bevy::{
    app::{App, Startup, Update},
    asset::{AssetServer, Assets},
    ecs::{
        component::Component,
        entity::Entity,
        query::{With, Without},
        system::{Commands, Query, Res, ResMut, Single},
    },
    gltf::GltfAssetLabel,
    math::{Vec3, primitives::Cuboid},
    mesh::{Mesh, Mesh3d, MeshBuilder, Meshable},
    scene::SceneRoot,
    time::Time,
    transform::components::Transform,
};

use crate::{dog::Dog, obstacles::Obstacles};

pub trait BunnySystems {
    fn add_bunny_systems(&mut self) -> &mut Self;
}

impl BunnySystems for App {
    fn add_bunny_systems(&mut self) -> &mut Self {
        self.add_systems(Startup, setup)
            .add_systems(Update, (calculate, jump))
    }
}

#[derive(Component)]
struct Bunny;

#[derive(Component)]
enum JumpState {
    Jumping { from: Vec3, to: Vec3 },
    Cooldown { ready: Duration },
}

const DETECTION_DISTANCE: f32 = 3.0;
const SCARED_JUMP_DISTANCE: f32 = 2.0;
const JUMP_HEIGHT: f32 = 1.0;
const JUMP_COOLDOWN: f32 = 0.05;
const DESIRED_SPEED: f32 = 10.0;
const SPEED: f32 = SCARED_JUMP_DISTANCE / (SCARED_JUMP_DISTANCE / DESIRED_SPEED - JUMP_COOLDOWN);

fn setup(mut commands: Commands, asset_server: Res<AssetServer>, mut meshes: ResMut<Assets<Mesh>>) {
    let model =
        asset_server.load(GltfAssetLabel::Scene(0).from_asset("models/cube-pets/animal-bunny.glb"));
    let mesh = meshes.add(Cuboid::from_length(2.0).mesh().build());

    commands.spawn((
        SceneRoot(model.clone()),
        Transform::from_xyz(4.0, 0.0, 0.0),
        Mesh3d(mesh.clone()),
        Bunny,
    ));

    commands.spawn((
        SceneRoot(model.clone()),
        Transform::from_xyz(-4.0, 0.0, 0.0),
        Mesh3d(mesh.clone()),
        Bunny,
    ));
}

type IdleBunniesQuery<'w, 's, 't> =
    Query<'w, 's, (Entity, &'t mut Transform), (With<Bunny>, Without<JumpState>)>;

fn calculate(
    mut commands: Commands,
    dog: Single<&Transform, (With<Dog>, Without<Bunny>)>,
    mut bunnies: IdleBunniesQuery,
    mut obstacles: Obstacles,
) {
    bunnies.iter_mut().for_each(|(bunny, mut bunny_transform)| {
        calculate_next_move(
            &mut commands,
            &dog,
            &mut bunny_transform,
            bunny,
            &mut obstacles,
        );
    });
}

fn calculate_next_move(
    commands: &mut Commands,
    dog: &Transform,
    bunny_transform: &mut Transform,
    bunny: Entity,
    obstacles: &mut Obstacles,
) {
    let direction = bunny_transform.translation - dog.translation;
    if direction.length_squared() > DETECTION_DISTANCE * DETECTION_DISTANCE {
        return;
    }

    let dog_direction = direction.with_y(0.0).normalize();
    let Some(to) = obstacles.avoid(
        bunny_transform.translation,
        bunny_transform.translation + dog_direction * SCARED_JUMP_DISTANCE,
    ) else {
        return;
    };

    commands.entity(bunny).insert(JumpState::Jumping {
        from: bunny_transform.translation,
        to,
    });
    bunny_transform.look_to(-(to - bunny_transform.translation), Vec3::Y);
}

fn jump(
    mut commands: Commands,
    time: Res<Time>,
    mut bunnies: Query<(Entity, &mut Transform, &mut JumpState), With<Bunny>>,
) {
    bunnies.iter_mut().for_each(
        |(bunny, mut bunny_transform, ref mut jump_state)| match jump_state.deref_mut() {
            JumpState::Jumping { from, to } => {
                let from = *from;
                let to = *to;
                animate_jumping(
                    &time,
                    &mut bunny_transform,
                    jump_state.deref_mut(),
                    from,
                    to,
                )
            }
            JumpState::Cooldown { ready } => {
                let ready = *ready;
                cooldown(&mut commands, &time, bunny, ready);
            }
        },
    );
}

fn animate_jumping(
    time: &Time,
    bunny_transform: &mut Transform,
    jump_state: &mut JumpState,
    from: Vec3,
    to: Vec3,
) {
    let current = bunny_transform.translation.with_y(to.y);
    let direction = to - current;
    let delta = SPEED * time.delta_secs();

    let (direction, length) = direction.normalize_and_length();
    if length <= delta {
        bunny_transform.translation = to;
        *jump_state = JumpState::Cooldown {
            ready: time.elapsed() + Duration::from_secs_f32(JUMP_COOLDOWN),
        };
        return;
    }

    let next = current + direction.normalize() * delta;
    let total_distance = from.distance(to);
    bunny_transform.translation = next
        + Vec3::Y
            * JUMP_HEIGHT
            * (std::f32::consts::PI * from.distance(next) / total_distance).sin();
}

fn cooldown(commands: &mut Commands, time: &Time, bunny: Entity, ready: Duration) {
    if time.elapsed() >= ready {
        commands.entity(bunny).remove::<JumpState>();
    }
}