use crate::movement;

use crate::{camera, movement};

    pub(crate) input_manager_bundle: InputManagerBundle<PlayerAction>,

    cam_target: camera::CameraTarget,
    input_manager_bundle: InputManagerBundle<PlayerAction>,

    pub(crate) sprite_sheet: SpriteSheetBundle,

    sprite_sheet: SpriteSheetBundle,

    pub(crate) movement_dir: movement_pointer::MovementDirection,
    pub(crate) dash: DashState,
    pub(crate) moveable: movement::Moveable,

    movement_dir: movement_pointer::MovementDirection,
    dash: DashState,
    moveable: movement::Moveable,

    pub(crate) children: SpawnChildren,

    children: SpawnChildren,

            // Make ourself the default cam target
            cam_target: camera::CameraTarget::default(),

    query: Query<(&ActionState<PlayerAction>, &DashState), With<Player>>,

    query: Query<
        (
            Entity,
            &ActionState<PlayerAction>,
            &DashState,
            Option<&camera::CameraTarget>,
        ),
        With<Player>,
    >,

    mut commands: Commands,

        let Ok((action_state, dash_state)) = query.get_single() else {

        let Ok((player_entity, action_state, dash_state, maybe_cam_target)) = query.get_single()
        else {

        if maybe_cam_target.is_some() {
            if ui.button("Detach Camera").clicked() {
                commands
                    .entity(player_entity)
                    .remove::<camera::CameraTarget>();
            }
        } else if ui.button("Attach Camera").clicked() {
            commands
                .entity(player_entity)
                .insert(camera::CameraTarget::default());
        }

use super::{player::Player, post_process, LOGICAL_HEIGHT, LOGICAL_WIDTH};

use super::{post_process, LOGICAL_HEIGHT, LOGICAL_WIDTH};

    lag: f32,

    precision: f32,

    /// Camera lag - [0.0, 1.0) lower is snappier, higher is smoother

    /// Camera lag - [0.0, 1.0)
    ///
    /// The camera will nominally be within this percentage of the
    /// target within [`self::snap_duration`]

        self.lag

        self.precision

        self.lag = lag.clamp(0.0, 0.99);

        self.precision = lag.clamp(0.0, 0.99);

            lag: 0.7,

            precision: 0.7,

#[derive(Component)]
struct Camera;

/// Attach this to something to make it the target of the camera
// TODO Maybe allow indexing, to switch targets? Might be cool for cutscenes.
#[derive(Component, Default)]
pub struct CameraTarget(pub usize);

#[derive(Component, Default)]
struct Camera {
    targetting: usize,
}

        camera: Camera,

        camera: Camera::default(),

    mut camera: Query<(&mut PixelCamera, &GlobalTransform), With<Camera>>,
    player: Query<&GlobalTransform, With<Player>>,

    mut camera: Query<(&mut PixelCamera, &Camera, &GlobalTransform)>,
    targets: Query<(&GlobalTransform, &CameraTarget)>,

    match (player.get_single(), camera.get_single_mut()) {
        (Ok(transform), Ok((mut camera, cam_transform))) => {
            // Lerp the camera to player's global translation point
            let source = cam_transform.translation();
            let goal = transform.translation();
            let adjusted_lag = rig.lag;
            let lerped = source * adjusted_lag + goal * (1.0 - adjusted_lag);
            let lerp_delta = lerped - source;
            camera.subpixel_pos +=
                lerp_delta.xy() * time.delta_seconds() / rig.snap_duration.as_secs_f32();
        }
        _ => {
            // Either the camera or the player doesnt exist
        }

    // This is only 1 camera...
    let (mut camera, cam, cam_transform) = camera.single_mut();
    // ...but soooo many targets
    let targeted = targets
        .iter()
        .filter(|(_, t)| t.0 == cam.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();