use std::{f32::consts::PI, ops::Mul, time::Duration};

use bevy::{
    diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
    ecs::schedule::ScheduleLabel,
    input::{keyboard::KeyCode, Input},
    log::info,
    prelude::{
        bevy_main, default, shape, App, Assets, Color, Commands, Component, Entity, Event,
        EventReader, EventWriter, FixedUpdate, Gizmos, GlobalTransform, IntoSystemConfigs,
        IntoSystemSetConfigs, Mesh, PbrBundle, PostUpdate, Quat, Query, Res, ResMut, Resource,
        Schedule, SpatialBundle, StandardMaterial, Startup, Transform, Update, Vec3, Vec3Swizzles,
        With, Without, World,
    },
    time::{Fixed, Time, Timer, TimerMode},
    transform::TransformSystem,
};
use bevy_oxr::{
    graphics::{extensions::XrExtensions, XrAppInfo, XrPreferdBlendMode},
    input::XrInput,
    resources::{XrFrameState, XrInstance, XrSession},
    xr_init::{xr_only, XrEnableRequest, XrEnableStatus},
    xr_input::{
        actions::XrActionSets,
        debug_gizmos::OpenXrDebugRenderer,
        hands::common::{HandInputDebugRenderer, HandResource, HandsResource, OpenXrHandInput},
        hands::HandBone,
        interactions::{
            draw_interaction_gizmos, draw_socket_gizmos, interactions, socket_interactions,
            update_interactable_states, InteractionEvent, Touched, XRDirectInteractor,
            XRInteractable, XRInteractableState, XRInteractorState, XRSelection,
        },
        oculus_touch::OculusController,
        prototype_locomotion::{proto_locomotion, PrototypeLocomotionConfig},
        trackers::{
            OpenXRController, OpenXRLeftController, OpenXRRightController, OpenXRTracker,
            OpenXRTrackingRoot,
        },
        Hand,
    },
    DefaultXrPlugins,
};

fn input_stuff(
    keys: Res<Input<KeyCode>>,
    status: Res<XrEnableStatus>,
    mut request: EventWriter<XrEnableRequest>,
) {
    if keys.just_pressed(KeyCode::Space) {
        match status.into_inner() {
            XrEnableStatus::Enabled => request.send(XrEnableRequest::TryDisable),
            XrEnableStatus::Disabled => request.send(XrEnableRequest::TryEnable),
        }
    }
}

mod setup;
use crate::setup::setup_scene;
use bevy_rapier3d::prelude::*;

#[bevy_main]
pub fn main() {
    color_eyre::install().unwrap();

    info!("Running bevy_openxr demo");
    let mut app = App::new();
    let mut xr_extensions = XrExtensions::default();

    app.add_systems(Update, input_stuff)
        //lets get the usual diagnostic stuff added
        .add_plugins(LogDiagnosticsPlugin::default())
        .add_plugins(FrameTimeDiagnosticsPlugin)
        //lets get the xr defaults added
        .add_plugins(DefaultXrPlugins {
            reqeusted_extensions: xr_extensions,
            prefered_blend_mode: XrPreferdBlendMode::Opaque,
            app_info: XrAppInfo {
                name: "Bevy OXR Demo".into(),
            },
        })
        //lets add the debug renderer for the controllers
        .add_plugins(OpenXrDebugRenderer)
        //rapier goes here
        .add_plugins(RapierPhysicsPlugin::<NoUserData>::default().with_default_system_setup(false))
        // .add_plugins(RapierDebugRenderPlugin::default())
        //lets setup the starting scene
        .add_systems(Startup, setup_scene)
        .add_systems(Startup, spawn_controllers_example) //you need to spawn controllers or it crashes TODO:: Fix this
        //add locomotion
        .add_systems(Update, proto_locomotion.run_if(xr_only()))
        .insert_resource(PrototypeLocomotionConfig::default())
        //lets add the interaction systems
        .add_event::<InteractionEvent>()
        .add_systems(Update, prototype_interaction_input.run_if(xr_only()))
        .add_systems(Update, interactions.before(update_interactable_states))
        .add_systems(Update, update_interactable_states)
        .add_systems(
            Update,
            socket_interactions.before(update_interactable_states),
        )
        //add the grabbable system
        .add_systems(Update, update_grabbables.after(update_interactable_states))
        //draw the interaction gizmos
        .add_systems(
            Update,
            draw_interaction_gizmos
                .run_if(xr_only())
                .after(update_interactable_states),
        )
        .add_systems(Update, draw_socket_gizmos.after(update_interactable_states))
        //add our cube spawning system
        .add_event::<SpawnCubeRequest>()
        .insert_resource(SpawnCubeTimer(Timer::from_seconds(
            0.25,
            bevy::time::TimerMode::Once,
        )))
        .add_systems(Update, request_cube_spawn.run_if(xr_only()))
        .add_systems(Update, cube_spawner.after(request_cube_spawn))
        //test capsule
        .add_systems(Startup, spawn_capsule)
        //physics hands
        .add_plugins(OpenXrHandInput)
        .add_plugins(HandInputDebugRenderer)
        .add_systems(Startup, spawn_physics_hands)
        .add_systems(
            FixedUpdate,
            update_physics_hands.before(PhysicsSet::SyncBackend),
        )
        .add_event::<GhostHandEvent>()
        .add_systems(Update, handle_ghost_hand_events.after(update_grabbables))
        .insert_resource(GhostTimers {
            left: Timer::from_seconds(0.25, TimerMode::Once),
            right: Timer::from_seconds(0.25, TimerMode::Once),
        })
        .add_systems(Update, watch_ghost_timers.before(handle_ghost_hand_events));

    //configure rapier sets
    let mut physics_schedule = Schedule::new(PhysicsSchedule);

    physics_schedule.configure_sets(
        (
            PhysicsSet::SyncBackend,
            PhysicsSet::StepSimulation,
            PhysicsSet::Writeback,
        )
            .chain()
            .before(TransformSystem::TransformPropagate),
    );

    app.configure_sets(
        PostUpdate,
        (
            PhysicsSet::SyncBackend,
            PhysicsSet::StepSimulation,
            PhysicsSet::Writeback,
        )
            .chain()
            .before(TransformSystem::TransformPropagate),
    );
    //add rapier systems
    physics_schedule.add_systems((
        RapierPhysicsPlugin::<NoUserData>::get_systems(PhysicsSet::SyncBackend)
            .in_set(PhysicsSet::SyncBackend),
        RapierPhysicsPlugin::<NoUserData>::get_systems(PhysicsSet::StepSimulation)
            .in_set(PhysicsSet::StepSimulation),
        RapierPhysicsPlugin::<NoUserData>::get_systems(PhysicsSet::Writeback)
            .in_set(PhysicsSet::Writeback),
    ));
    app.add_schedule(physics_schedule) // configure our fixed timestep schedule to run at the rate we want
        .insert_resource(Time::<Fixed>::from_duration(Duration::from_secs_f32(
            FIXED_TIMESTEP,
        )))
        .add_systems(FixedUpdate, run_physics_schedule)
        .add_systems(Startup, configure_physics);
    app.run();
}

//fixed timesteps?
const FIXED_TIMESTEP: f32 = 1. / 90.;

// A label for our new Schedule!
#[derive(ScheduleLabel, Debug, Hash, PartialEq, Eq, Clone)]
struct PhysicsSchedule;

fn run_physics_schedule(world: &mut World) {
    world.run_schedule(PhysicsSchedule);
}

fn configure_physics(mut rapier_config: ResMut<RapierConfiguration>) {
    rapier_config.timestep_mode = TimestepMode::Fixed {
        dt: FIXED_TIMESTEP,
        substeps: 1,
    }
}

fn spawn_controllers_example(mut commands: Commands) {
    //left hand
    commands.spawn((
        OpenXRLeftController,
        OpenXRController,
        OpenXRTracker,
        SpatialBundle::default(),
        XRDirectInteractor,
        XRInteractorState::default(),
        XRSelection::default(),
        Hand::Left,
    ));
    //right hand
    commands.spawn((
        OpenXRRightController,
        OpenXRController,
        OpenXRTracker,
        SpatialBundle::default(),
        XRDirectInteractor,
        XRInteractorState::default(),
        XRSelection::default(),
        Hand::Right,
    ));
}

fn spawn_capsule(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    commands.spawn((
        PbrBundle {
            mesh: meshes.add(Mesh::from(shape::Capsule {
                radius: 0.033,
                depth: 0.115,
                ..default()
            })),
            material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
            transform: Transform::from_xyz(0.0, 2.0, 0.0),
            ..default()
        },
        // Collider::capsule_y(0.0575, 0.034),
        Collider::capsule(
            Vec3 {
                x: 0.0,
                y: -0.0575,
                z: 0.0,
            },
            Vec3 {
                x: 0.0,
                y: 0.0575,
                z: 0.0,
            },
            0.034,
        ),
        RigidBody::Dynamic,
    ));
}

#[derive(Component, PartialEq, Debug, Clone, Copy)]
pub enum PhysicsHandBone {
    Palm,
    Wrist,
    ThumbMetacarpal,
    ThumbProximal,
    ThumbDistal,
    ThumbTip,
    IndexMetacarpal,
    IndexProximal,
    IndexIntermediate,
    IndexDistal,
    IndexTip,
    MiddleMetacarpal,
    MiddleProximal,
    MiddleIntermediate,
    MiddleDistal,
    MiddleTip,
    RingMetacarpal,
    RingProximal,
    RingIntermediate,
    RingDistal,
    RingTip,
    LittleMetacarpal,
    LittleProximal,
    LittleIntermediate,
    LittleDistal,
    LittleTip,
}
#[derive(Component, PartialEq)]
pub enum BoneInitState {
    True,
    False,
}

fn spawn_physics_hands(mut commands: Commands) {
    //here we go
    let hands = [Hand::Left, Hand::Right];
    let bones = [
        PhysicsHandBone::Palm,
        PhysicsHandBone::Wrist,
        PhysicsHandBone::ThumbMetacarpal,
        PhysicsHandBone::ThumbProximal,
        PhysicsHandBone::ThumbDistal,
        PhysicsHandBone::ThumbTip,
        PhysicsHandBone::IndexMetacarpal,
        PhysicsHandBone::IndexProximal,
        PhysicsHandBone::IndexIntermediate,
        PhysicsHandBone::IndexDistal,
        PhysicsHandBone::IndexTip,
        PhysicsHandBone::MiddleMetacarpal,
        PhysicsHandBone::MiddleProximal,
        PhysicsHandBone::MiddleIntermediate,
        PhysicsHandBone::MiddleDistal,
        PhysicsHandBone::MiddleTip,
        PhysicsHandBone::RingMetacarpal,
        PhysicsHandBone::RingProximal,
        PhysicsHandBone::RingIntermediate,
        PhysicsHandBone::RingDistal,
        PhysicsHandBone::RingTip,
        PhysicsHandBone::LittleMetacarpal,
        PhysicsHandBone::LittleProximal,
        PhysicsHandBone::LittleIntermediate,
        PhysicsHandBone::LittleDistal,
        PhysicsHandBone::LittleTip,
    ];
    let radius = 0.010;
    let left_hand_membership_group = Group::GROUP_1;
    let right_hand_membership_group = Group::GROUP_2;
    let floor_membership = Group::GROUP_3;

    for hand in hands.iter() {
        let hand_membership = match hand {
            Hand::Left => left_hand_membership_group,
            Hand::Right => right_hand_membership_group,
        };
        let mut hand_filter: Group = Group::ALL;
        hand_filter.remove(hand_membership);
        hand_filter.remove(floor_membership);
        for bone in bones.iter() {
            //spawn the thing
            commands.spawn((
                SpatialBundle::default(),
                Collider::capsule(
                    Vec3 {
                        x: 0.0,
                        y: -0.0575,
                        z: 0.0,
                    },
                    Vec3 {
                        x: 0.0,
                        y: 0.0575,
                        z: 0.0,
                    },
                    radius,
                ),
                RigidBody::Dynamic,
                Velocity::default(),
                CollisionGroups::new(hand_membership, Group::from_bits(0b0001).unwrap()),
                // SolverGroups::new(self_group, interaction_group),
                bone.clone(),
                BoneInitState::False,
                hand.clone(),
            ));
        }
    }
}

pub enum MatchingType {
    PositionMatching,
    VelocityMatching,
}

fn update_physics_hands(
    hands_res: Option<Res<HandsResource>>,
    mut bone_query: Query<(
        &mut Transform,
        &mut Collider,
        &PhysicsHandBone,
        &mut BoneInitState,
        &Hand,
        &mut Velocity,
    )>,
    hand_query: Query<(&Transform, &HandBone, &Hand, Without<PhysicsHandBone>)>,
    time: Res<Time>,
    mut gizmos: Gizmos,
) {
    let matching = MatchingType::VelocityMatching;
    //sanity check do we even have hands?
    match hands_res {
        Some(res) => {
            //config stuff
            let radius = 0.010;
            for mut bone in bone_query.iter_mut() {
                let hand_res = match bone.4 {
                    Hand::Left => res.left,
                    Hand::Right => res.right,
                };

                //lets just do the Right ThumbMetacarpal for now
                let result = get_start_and_end_entities(hand_res, bone.2);
                if let Some((start_entity, end_entity)) = result {
                    //now we need their transforms
                    let start_components = hand_query.get(start_entity);
                    let end_components = hand_query.get(end_entity);
                    let direction = end_components.unwrap().0.translation
                        - start_components.unwrap().0.translation;
                    if direction.length() < 0.001 {
                        //i hate this but we need to skip init if the length is zero
                        return;
                    }

                    match *bone.3 {
                        BoneInitState::True => {
                            match matching {
                                MatchingType::PositionMatching => {
                                    //if we are init then we just move em?
                                    *bone.0 = start_components
                                        .unwrap()
                                        .0
                                        .clone()
                                        .looking_at(end_components.unwrap().0.translation, Vec3::Y);
                                }
                                MatchingType::VelocityMatching => {
                                    //calculate position difference
                                    let diff = (start_components.unwrap().0.translation
                                        - bone.0.translation)
                                        / time.delta_seconds();
                                    bone.5.linvel = diff;
                                    //calculate angular velocity?
                                    // gizmos.ray(bone.0.translation, bone.0.forward(), Color::WHITE);
                                    let desired_forward = start_components
                                        .unwrap()
                                        .0
                                        .clone()
                                        .looking_at(end_components.unwrap().0.translation, Vec3::Y)
                                        .rotation;
                                    // gizmos.ray(
                                    //     bone.0.translation,
                                    //     desired_forward.mul_vec3(-Vec3::Z),
                                    //     Color::GREEN,
                                    // );
                                    let cross =
                                        bone.0.forward().cross(desired_forward.mul_vec3(-Vec3::Z));

                                    // gizmos.ray(
                                    //     bone.0.translation,
                                    //     cross,
                                    //     Color::RED,
                                    // );
                                    bone.5.angvel = cross / time.delta_seconds();
                                }
                            }
                        }
                        BoneInitState::False => {
                            //build a new collider?
                            *bone.1 = Collider::capsule(
                                Vec3::splat(0.0),
                                Vec3 {
                                    x: 0.0,
                                    y: 0.0,
                                    z: -direction.length(),
                                },
                                radius,
                            );
                            *bone.3 = BoneInitState::True;
                        }
                    }
                }
            }
        }
        None => info!("hand states resource not initialized yet"),
    }
}

fn get_start_and_end_entities(
    hand_res: HandResource,
    bone: &PhysicsHandBone,
) -> Option<(Entity, Entity)> {
    match bone {
        PhysicsHandBone::Palm => return None,
        PhysicsHandBone::Wrist => return None,
        PhysicsHandBone::ThumbMetacarpal => {
            return Some((hand_res.thumb.metacarpal, hand_res.thumb.proximal))
        }
        PhysicsHandBone::ThumbProximal => {
            return Some((hand_res.thumb.proximal, hand_res.thumb.distal))
        }
        PhysicsHandBone::ThumbDistal => return Some((hand_res.thumb.distal, hand_res.thumb.tip)),
        PhysicsHandBone::ThumbTip => return None,
        PhysicsHandBone::IndexMetacarpal => {
            return Some((hand_res.index.metacarpal, hand_res.index.proximal))
        }
        PhysicsHandBone::IndexProximal => {
            return Some((hand_res.index.proximal, hand_res.index.intermediate))
        }
        PhysicsHandBone::IndexIntermediate => {
            return Some((hand_res.index.intermediate, hand_res.index.distal))
        }
        PhysicsHandBone::IndexDistal => return Some((hand_res.index.distal, hand_res.index.tip)),
        PhysicsHandBone::IndexTip => return None,
        PhysicsHandBone::MiddleMetacarpal => {
            return Some((hand_res.middle.metacarpal, hand_res.middle.proximal))
        }
        PhysicsHandBone::MiddleProximal => {
            return Some((hand_res.middle.proximal, hand_res.middle.intermediate))
        }
        PhysicsHandBone::MiddleIntermediate => {
            return Some((hand_res.middle.intermediate, hand_res.middle.distal))
        }
        PhysicsHandBone::MiddleDistal => {
            return Some((hand_res.middle.distal, hand_res.middle.tip))
        }
        PhysicsHandBone::MiddleTip => return None,
        PhysicsHandBone::RingMetacarpal => {
            return Some((hand_res.ring.metacarpal, hand_res.ring.proximal))
        }
        PhysicsHandBone::RingProximal => {
            return Some((hand_res.ring.proximal, hand_res.ring.intermediate))
        }
        PhysicsHandBone::RingIntermediate => {
            return Some((hand_res.ring.intermediate, hand_res.ring.distal))
        }
        PhysicsHandBone::RingDistal => return Some((hand_res.ring.distal, hand_res.ring.tip)),
        PhysicsHandBone::RingTip => return None,
        PhysicsHandBone::LittleMetacarpal => {
            return Some((hand_res.little.metacarpal, hand_res.little.proximal))
        }
        PhysicsHandBone::LittleProximal => {
            return Some((hand_res.little.proximal, hand_res.little.intermediate))
        }
        PhysicsHandBone::LittleIntermediate => {
            return Some((hand_res.little.intermediate, hand_res.little.distal))
        }
        PhysicsHandBone::LittleDistal => {
            return Some((hand_res.little.distal, hand_res.little.tip))
        }
        PhysicsHandBone::LittleTip => return None,
    };
}

fn get_hand_res(res: &Res<'_, HandsResource>, hand: Hand) -> HandResource {
    match hand {
        Hand::Left => res.left.clone(),
        Hand::Right => res.right.clone(),
    }
}

#[derive(Event, Default)]
pub struct SpawnCubeRequest;

#[derive(Resource)]
pub struct SpawnCubeTimer(Timer);

fn request_cube_spawn(
    oculus_controller: Res<OculusController>,
    frame_state: Res<XrFrameState>,
    xr_input: Res<XrInput>,
    instance: Res<XrInstance>,
    session: Res<XrSession>,
    mut writer: EventWriter<SpawnCubeRequest>,
    time: Res<Time>,
    mut timer: ResMut<SpawnCubeTimer>,
    action_sets: Res<XrActionSets>,
) {
    timer.0.tick(time.delta());
    if timer.0.finished() {
        //get controller
        let controller = oculus_controller.get_ref(&session, &frame_state, &xr_input, &action_sets);
        //get controller triggers
        let left_main_button = controller.a_button();
        if left_main_button {
            writer.send(SpawnCubeRequest::default());
            timer.0.reset();
        }
        let right_main_button = controller.x_button();
        if right_main_button {
            writer.send(SpawnCubeRequest::default());
            timer.0.reset();
        }
    }
}

fn cube_spawner(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    mut events: EventReader<SpawnCubeRequest>,
) {
    for request in events.read() {
        // cube
        commands.spawn((
            PbrBundle {
                mesh: meshes.add(Mesh::from(shape::Cube { size: 0.1 })),
                material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
                transform: Transform::from_xyz(0.0, 1.0, 0.0),
                ..default()
            },
            RigidBody::Dynamic,
            Collider::cuboid(0.05, 0.05, 0.05),
            ColliderDebugColor(Color::hsl(220.0, 1.0, 0.3)),
            XRInteractable,
            XRInteractableState::default(),
            Grabbable,
            Touched(false),
        ));
    }
}

//TODO: find a real place for this
fn prototype_interaction_input(
    oculus_controller: Res<OculusController>,
    frame_state: Res<XrFrameState>,
    xr_input: Res<XrInput>,
    session: Res<XrSession>,
    mut right_interactor_query: Query<
        (&mut XRInteractorState),
        (
            With<XRDirectInteractor>,
            With<OpenXRRightController>,
            Without<OpenXRLeftController>,
        ),
    >,
    mut left_interactor_query: Query<
        (&mut XRInteractorState),
        (
            With<XRDirectInteractor>,
            With<OpenXRLeftController>,
            Without<OpenXRRightController>,
        ),
    >,
    action_sets: Res<XrActionSets>,
) {
    //get controller
    let controller = oculus_controller.get_ref(&session, &frame_state, &xr_input, &action_sets);
    //get controller triggers
    let left_trigger = controller.trigger(Hand::Left);
    let right_trigger = controller.trigger(Hand::Right);
    //get the interactors and do state stuff
    let mut left_state = left_interactor_query.single_mut();
    if left_trigger > 0.8 {
        *left_state = XRInteractorState::Selecting;
    } else {
        *left_state = XRInteractorState::Idle;
    }
    let mut right_state = right_interactor_query.single_mut();
    if right_trigger > 0.8 {
        *right_state = XRInteractorState::Selecting;
    } else {
        *right_state = XRInteractorState::Idle;
    }
}

//this event is for transitioning the physics hand in an out of existent so we can drop things better
#[derive(Event)]
pub struct GhostHandEvent {
    pub hand: Hand,
    pub desired_state: bool, //true for no interactions, false for normal interactions
}
#[derive(Resource)]
pub struct GhostTimers {
    pub left: Timer,
    pub right: Timer,
}

pub fn handle_ghost_hand_events(
    mut events: EventReader<GhostHandEvent>,
    mut bones: Query<(&Hand, &mut CollisionGroups, With<PhysicsHandBone>)>,
) {
    for event in events.read() {
        // info!(
        //     "Ghost hand Event: {:?}, {:?}",
        //     event.hand, event.desired_state
        // );
        //do work
        for mut bone in bones.iter_mut() {
            match *bone.0 == event.hand {
                true => match event.desired_state {
                    true => bone.1.filters = Group::NONE,
                    false => bone.1.filters = Group::from_bits(0b0001).unwrap(),
                },
                false => (),
            }
        }
    }
}

pub fn watch_ghost_timers(
    mut timers: ResMut<GhostTimers>,
    mut writer: EventWriter<GhostHandEvent>,
    time: Res<Time>,
) {
    //tick both timers
    timers.left.tick(time.delta());
    timers.right.tick(time.delta());
    //if they finish send events to make the hands physical again
    if timers.left.just_finished() {
        writer.send(GhostHandEvent {
            hand: Hand::Left,
            desired_state: false,
        });
    }
    if timers.right.just_finished() {
        writer.send(GhostHandEvent {
            hand: Hand::Right,
            desired_state: false,
        });
    }
}

#[derive(Component)]
pub struct Grabbable;

pub fn update_grabbables(
    mut events: EventReader<InteractionEvent>,
    mut grabbable_query: Query<(
        Entity,
        &mut Transform,
        With<Grabbable>,
        Without<XRDirectInteractor>,
        Option<&mut RigidBody>,
    )>,
    mut interactor_query: Query<(
        &GlobalTransform,
        &XRInteractorState,
        &mut XRSelection,
        &Hand,
        Without<Grabbable>,
    )>,
    mut writer: EventWriter<GhostHandEvent>,
    mut timers: ResMut<GhostTimers>,
) {
    //so basically the idea is to try all the events?
    for event in events.read() {
        // info!("some event");
        match grabbable_query.get_mut(event.interactable) {
            Ok(mut grabbable_transform) => {
                // info!("we got a grabbable");
                //now we need the location of our interactor
                match interactor_query.get_mut(event.interactor) {
                    Ok(mut interactor_transform) => {
                        match *interactor_transform.2 {
                            XRSelection::Empty => {
                                match interactor_transform.1 {
                                    XRInteractorState::Idle => match grabbable_transform.4 {
                                        Some(mut thing) => {
                                            *thing = RigidBody::Dynamic;
                                            *interactor_transform.2 = XRSelection::Empty;
                                        }
                                        None => (),
                                    },
                                    XRInteractorState::Selecting => {
                                        // info!("its a direct interactor?");
                                        match grabbable_transform.4 {
                                            Some(mut thing) => {
                                                *thing = RigidBody::KinematicPositionBased;
                                                *interactor_transform.2 =
                                                    XRSelection::Full(grabbable_transform.0);
                                                //raise enter ghost hand event
                                                writer.send(GhostHandEvent {
                                                    hand: *interactor_transform.3,
                                                    desired_state: true,
                                                });
                                            }
                                            None => (),
                                        }
                                        *grabbable_transform.1 =
                                            interactor_transform.0.compute_transform();
                                    }
                                }
                            }
                            XRSelection::Full(ent) => {
                                info!("nah bro we holding something");
                                match grabbable_transform.0 == ent {
                                    true => {
                                        *grabbable_transform.1 =
                                            interactor_transform.0.compute_transform();
                                    }
                                    false => {}
                                }
                                match interactor_transform.1 {
                                    XRInteractorState::Idle => {
                                        *interactor_transform.2 = XRSelection::Empty;
                                        //reset timers to make hands physical again
                                        match *interactor_transform.3 {
                                            Hand::Left => timers.left.reset(),
                                            Hand::Right => timers.right.reset(),
                                        }
                                    }
                                    XRInteractorState::Selecting => {}
                                }
                            }
                        }
                    }
                    Err(_) => {
                        // info!("not a direct interactor")
                    }
                }
            }
            Err(_) => {
                // info!("not a grabbable?")
            }
        }
    }
}