use crate::{camera, GameState};

use crate::{camera, movement_pointer, GameState};

use bevy::sprite::MaterialMesh2dBundle;

use bevy_prototype_lyon::entity::ShapeBundle;
use bevy_prototype_lyon::geometry::GeometryBuilder;
use bevy_prototype_lyon::shapes;

use moonshine_spawn::spawn_children;

        app.add_systems(Update, debug_view_window.run_if(in_state(GameState::InRun)));

        app.add_systems(Startup, setup_debug)
            .add_systems(Update, debug_view_window.run_if(in_state(GameState::InRun)));

/// Your worst nightmare
#[derive(Component)]
struct Polly;
// Make Polly, your *nightmare*
fn setup_debug(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
) {
    commands.spawn((
        Polly,
        movement_pointer::MovementDirection(Vec2::X, 0.0),
        MaterialMesh2dBundle {
            mesh: meshes
                .add(Rectangle {
                    half_size: (16.0, 24.0).into(),
                })
                .into(),
            // Be careful not to overwrite the LDtk transform
            // Change our origin
            material: materials.add(Color::PURPLE),
            ..default()
        },
        spawn_children(|cb| {
            cb.spawn(movement_pointer::MovementPointerBundle {
                pointer: movement_pointer::MovementPointer,
                shape: ShapeBundle {
                    spatial: SpatialBundle {
                        transform: Transform::default().with_scale(Vec3::new(0.5, 1.0, 1.0)),
                        ..default()
                    },
                    path: GeometryBuilder::build_as(&shapes::RegularPolygon {
                        sides: 3,
                        feature: shapes::RegularPolygonFeature::Apothem(5.0),
                        ..default()
                    }),
                    material: materials.add(Color::ORANGE_RED),
                    ..default()
                },
            });
        }),
    ));
}

    polly: Query<(Entity, Option<&camera::CameraTarget>), With<Polly>>,

        ui.collapsing("Polly Control", |ui| {
            let (polly_entity, cam_target) = polly.single();
            if cam_target.is_some() {
                if ui.button("Remove").clicked() {
                    commands
                        .entity(polly_entity)
                        .remove::<camera::CameraTarget>();
                }
            } else if ui.button("With You").clicked() {
                commands
                    .entity(polly_entity)
                    .insert(camera::CameraTarget::default());
            } else if ui.button("Without You").clicked() {
                commands
                    .entity(polly_entity)
                    .insert(camera::CameraTarget(1));
            }
        });

            ui.add(egui::Slider::new(&mut rig.targetting, 0..=1).text("Target"));

    /// Which [`CameraTarget`](s) does the camera target?
    pub targetting: usize,

            targetting: 0,

struct Camera {
    targetting: usize,
}

struct Camera;

        camera: Camera::default(),

        camera: Camera,

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

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

    let (mut camera, cam, cam_transform) = camera.single_mut();

    let (mut camera, cam_transform) = camera.single_mut();

        .filter(|(_, t)| t.0 == cam.targetting)

        .filter(|(_, t)| t.0 == rig.targetting)