InputManagerPlugin::<PlayerAction>::default(),

            InputManagerPlugin::<PlayerMovement>::default(),

        .add_systems(Update, update_test_stuff)

        .add_systems(Update, update_tnua)
        .add_systems(Update, input_behaved)

enum PlayerAction {

enum PlayerMovement {

fn default_player_map() -> InputMap<PlayerAction> {
    InputMap::new([(PlayerAction::Jump, KeyCode::Space)])
        .insert(PlayerAction::Walk, VirtualAxis::horizontal_arrow_keys())
        .to_owned()

fn default_player_map() -> InputMap<PlayerMovement> {
    InputMap::new([
        (
            PlayerMovement::Jump,
            Into::<UserInput>::into(KeyCode::Space),
        ),
        (
            PlayerMovement::Walk,
            VirtualAxis::horizontal_arrow_keys().into(),
        ),
    ])

        Mass(1.0),

        TnuaXpbd2dSensorShape(Collider::circle(32.0)),

        // TnuaXpbd2dSensorShape(Collider::circle(32.0)),

        TnuaConfig {
            max_speed: 5000.,
            air_actions: 2,
            walk: TnuaBuiltinWalk {
                acceleration: 2000.,
                air_acceleration: 1500.,
                float_height: 64.0,
                ..default()
            },
            jump: TnuaBuiltinJump {
                height: 128.,
                reschedule_cooldown: Some(0.1),
                // Defaults x 10
                upslope_extra_gravity: 300.0,
                // takeoff_extra_gravity: 300.0,
                // takeoff_above_velocity: 64.0,
                fall_extra_gravity: 200.0,
                shorten_extra_gravity: 600.0,
                peak_prevention_at_upward_velocity: 10.0,
                peak_prevention_extra_gravity: 200.0,
                ..default()
            },
        },
        TnuaControllerBundle::default(),
        // TnuaXpbd2dSensorShape(Collider::circle(32.0)),
        TnuaSimpleAirActionsCounter::default(),

}
struct AiContext {
    desired_movement: Vec2,

fn update_test_stuff(
    mut query: Query<
        (
            &ActionState<PlayerAction>,
            &mut TnuaController,
            &TnuaConfig,
            &mut TnuaSimpleAirActionsCounter,
        ),
        With<Player>,
    >,
) {
    let (action_state, mut tnua_controller, config, mut air_counter) = query.single_mut();

#[derive(Component)]
struct Behaved {
    runner: simple_bt::BehaviorRunner<AiContext>,
}

    let mov_dir = action_state.clamped_value(&PlayerAction::Walk);
    let direction = mov_dir * Vec3::X;

fn input_behaved(mut query: Query<(&mut Behaved,), Without<Player>>) {
    for (mut behaved,) in query.iter_mut() {
        let mut context = AiContext {
            desired_movement: Vec2::ZERO,
        };
        behaved.runner.proceed(&mut context);
        let x_movement = context.desired_movement.x;
        if x_movement > 0.001 {
            // action_state.press(&PlayerMovement::Walk);
        }
    }
}

    air_counter.update(tnua_controller.as_mut());

fn update_tnua(
    mut query: Query<(
        &ActionState<PlayerMovement>,
        &mut TnuaController,
        &TnuaConfig,
        &mut TnuaSimpleAirActionsCounter,
    )>,
) {
    for (action_state, mut tnua_controller, config, mut air_counter) in query.iter_mut() {
        let mov_dir = action_state.clamped_value(&PlayerMovement::Walk);
        let direction = mov_dir * Vec3::X;

    let speed_factor = 1.0;

        air_counter.update(tnua_controller.as_mut());

    tnua_controller.basis(TnuaBuiltinWalk {
        desired_velocity: direction * speed_factor * config.max_speed,
        // TODO Hanel shooting maybe?
        desired_forward: direction.normalize_or_zero(),
        ..config.walk
    });

        let speed_factor = 1.0;

    if action_state.just_pressed(&PlayerAction::Jump) {
        tnua_controller.action(TnuaBuiltinJump {
            allow_in_air: air_counter.air_count_for(TnuaBuiltinJump::NAME) <= config.air_actions,
            ..config.jump

        tnua_controller.basis(TnuaBuiltinWalk {
            desired_velocity: direction * speed_factor * config.max_speed,
            // TODO Handle shooting maybe?
            desired_forward: direction.normalize_or_zero(),
            ..config.walk

        if action_state.just_pressed(&PlayerMovement::Jump) {
            tnua_controller.action(TnuaBuiltinJump {
                allow_in_air: air_counter.air_count_for(TnuaBuiltinJump::NAME)
                    <= config.air_actions,
                ..config.jump
            });
        }

use std::time::Duration;
use crate::{LOGICAL_HEIGHT, LOGICAL_WIDTH};
use bevy::prelude::*;
use bevy_egui::{egui, EguiContexts};
use bevy_smooth_pixel_camera::components::PixelCamera;
use bevy_smooth_pixel_camera::viewport::ViewportSize;
pub struct CameraPlugin;
impl Plugin for CameraPlugin {
    fn build(&self, app: &mut App) {
        app.add_plugins(bevy_smooth_pixel_camera::PixelCameraPlugin)
            .init_resource::<CameraRig>()
            .add_systems(Startup, setup_camera)
            .add_systems(Update, (update_camera, camera_rig_debug));
    }
}
#[derive(Resource)]
pub struct CameraRig {
    /// Which [`CameraTarget`](s) does the camera target?
    pub targetting: usize,
    precision: f32,
    /// how long should the lerp take?
    pub snap_duration: Duration,
}
impl CameraRig {
    /// Camera lag - [0.0, 1.0]
    ///
    /// The camera will nominally be within this percentage of the
    /// target within [`self::snap_duration`]
    pub fn lag(&self) -> f32 {
        self.precision
    }
    pub fn set_lag(&mut self, lag: f32) {
        self.precision = lag.clamp(0.0, 1.0);
    }
}
impl Default for CameraRig {
    fn default() -> Self {
        Self {
            targetting: 0,
            precision: 0.7,
            snap_duration: Duration::from_secs_f32(10f32.recip()),
        }
    }
}
/// The maximum value used for [`CameraRig::targetting`]
pub const MAX_TARGET: usize = 3;
fn camera_rig_debug(mut rig: ResMut<CameraRig>, mut contexts: EguiContexts) {
    egui::Window::new("Camera Rig").show(contexts.ctx_mut(), |ui| {
        ui.horizontal(|ui| {
            ui.label("Targetting");
            ui.add(egui::Slider::new(&mut rig.targetting, 0..=MAX_TARGET));
        });
        ui.horizontal(|ui| {
            ui.label("Precision");
            ui.add(egui::Slider::new(&mut rig.precision, 0.0..=1.0));
        });
        ui.horizontal(|ui| {
            ui.label("Snap Inverse Halflife");
            let mut recip_halflife = rig.snap_duration.as_secs_f32().recip();
            if ui
                .add(egui::Slider::new(&mut recip_halflife, 1.0..=100.0))
                .changed()
            {
                rig.snap_duration = Duration::from_secs_f32(recip_halflife.recip());
            }
        });
    });
}
/// Attach this to something to make it the target of the camera
#[derive(Component, Default)]
pub struct CameraTarget(pub usize);
#[derive(Component, Default)]
struct Camera;
#[derive(Bundle)]
struct CameraBundle {
    camera: Camera,
    camera_2d: Camera2dBundle,
    pixel_camera: PixelCamera,
    // chroma_aberration: post_process::ChromaticAberattionSettings,
}
fn setup_camera(mut commands: Commands) {
    commands.insert_resource(ClearColor(Color::rgb(0.07, 0.05, 0.05)));
    commands.spawn(CameraBundle {
        camera: Camera,
        camera_2d: Camera2dBundle::default(),
        pixel_camera: PixelCamera::from_size(ViewportSize::AutoMax {
            max_width: LOGICAL_WIDTH,
            max_height: LOGICAL_HEIGHT,
        }),
        // chroma_aberration: post_process::ChromaticAberattionSettings {
        //     // intensity: 0.02,
        //     ..default()
        // },
    });
}
fn update_camera(
    mut camera: Query<(&mut PixelCamera, &GlobalTransform), With<Camera>>,
    targets: Query<(&GlobalTransform, &CameraTarget)>,
    rig: Res<CameraRig>,
    time: Res<Time>,
) {
    // This is only 1 camera...
    let (mut camera, cam_transform) = camera.single_mut();
    // ...but soooo many targets
    let targeted = targets
        .iter()
        .filter(|(_, t)| t.0 == rig.targetting)
        .collect::<Vec<_>>();
    // Get the midpoint of all targeted items
    let goal = targeted
        .iter()
        .map(|(transform, _)| transform.translation())
        .reduce(|total, e| total + e)
        .map(|total| total / targeted.len() as f32);
    if let Some(goal) = goal {
        // Lerp the camera to player's global translation point
        let source = cam_transform.translation();
        // Taken from https://mastodon.social/@acegikmo/111931613710775864
        let lambda = -rig.snap_duration.as_secs_f32() / rig.precision.log2();
        let alpha = 2.0f32.powf(-time.delta_seconds() / lambda);
        let lerped = source * alpha + goal * (1.0 - alpha);
        camera.subpixel_pos = lerped.xy();
    }
}