use bevy::{prelude::*, math::bool, render::primitives::Frustum};
use rand::prelude::*;
use bevy::render::primitives::Plane;


// pub struct BuildScenePlugin;

// impl Plugin for BuildScenePlugin {
//     fn build(&self, app: &mut App) {
//         app.add_startup_system(build_scene) // actual scene
//             .add_system(print_positions); // debugging
//     }
// }

#[derive(Component)]
pub struct ProjectionScreen {
    bottom_left: Vec3,
    bottom_right: Vec3,
    top_left: Vec3,
    top_right: Vec3,

    dir_right: Vec3,
    dir_up: Vec3,
    dir_normal: Vec3,

    matrix: Mat4

}



fn generalized_projection_stereo(eyePos : Vec3)
{

}


fn generalized_projection (
    projectionScreen: ProjectionScreen,
    eyePos: Vec3,
    mut camera: Camera3dBundle,
    clampNearPlane: bool,
)
{
    let pa = projectionScreen.bottom_left;
    let pb = projectionScreen.bottom_right;
    let pc = projectionScreen.top_left;
    let pd = projectionScreen.top_right;

    let vu = projectionScreen.dir_up;
    let vr = projectionScreen.dir_right;
    let vn = projectionScreen.dir_normal;

    // let m = projectionScreen.matrix;

    //let m = Mat4::from_cols(vu., y_axis, z_axis, w_axis)

    let va = pa - eyePos;
    let vb = pb - eyePos;
    let vc = pc - eyePos;
    let vd = pd - eyePos;

    let viewDir = eyePos + va + vb + vc + vd;

    let d = -va.dot(vn);


    if clampNearPlane {
        _ = 33;
        // camera.frustum.planes[4]. // should be near
    }
}

pub fn build_scene(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    // plane
    commands.spawn(PbrBundle {
        mesh: meshes.add(Mesh::from(shape::Plane { size: 5.0 })),
        material: materials.add(Color::rgb(0.3, 0.5, 0.3).into()),
        ..default()
    });
    // cube
    commands.spawn(PbrBundle {
        mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
        material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
        transform: Transform::from_xyz(0.0, 0.5, 0.0),
        ..default()
    });
    // light
    commands.spawn(PointLightBundle {
        point_light: PointLight {
            intensity: 1500.0,
            shadows_enabled: true,
            ..default()
        },
        transform: Transform::from_xyz(4.0, 8.0, 4.0),
        ..default()
    });


    // camera

    let mut cam = Camera3dBundle {
        transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),

        ..default()
    };



    // commands.spawn(cam);

    // commands.spawn((Person, Position { x: 10.0, y: 10.0 }));
    // commands.spawn()
    // .insert(Person)
    // .insert(Position { x: 10.0, y: 10.0 } );

    // camera
    // commands.spawn_bundle(OffAxisProjection {
    //     transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
    //     ..default()
    // });
}



// pub fn modify_frustum(mut query: Query<&Frustum>)
// {
//     let mut rng = rand::thread_rng();

//     for mut q in query.iter() {

//         for mut p in q.planes {

//             println!("{:?}",p);

//             let mut n = p.normal_d();

//             n.w += rng.gen::<f32>();

//             p = Plane::new(n);

//             println!("{:?}",p);



//             // p.normal_d() += rng.gen();
//         }

//         // println!("{:?}",q.frustum.planes.len()); 
//     }
// }


// pub fn modify_projection(mut query: Query<&Projection>)
// {
//     let mut rng = rand::thread_rng();

//     for mut q in query.iter() {
        
//         print!("{:?}",q);
//     }
// }

// pub fn print_positions(query: Query<&Position>) {
//     for _position in query.iter() {
//         _ = 33;
//         // println!("position {:?} {:?}", position.x, position.y)
//     }
// }

// Problem with off-axis
// projection 2401, 240