use bevy::math::{Affine3A, Mat4, Quat};
use bevy::prelude::*;

/// creates a conventional projection matrix from frustum planes
///
/// returns a potentially off-axis projection matrix
pub fn make_projection_rh_from_frustum(
    left: f32,
    right: f32,
    bottom: f32,
    top: f32,
    near: f32,
    far: f32,
) -> Mat4 {
    // based on OpenSceneGraph / glFrustum implementation
    let a = (right + left) / (right - left);
    let b: f32 = (top + bottom) / (top - bottom);
    let c = if far.abs() > f32::MAX {
        -1.0
    } else {
        -(far + near) / (far - near)
    };
    let d = if far.abs() > f32::MAX {
        -2.0 * near
    } else {
        -2.0 * far * near / (far - near)
    };

    Mat4::from_cols(
        Vec4::new(2.0 * near / (right - left), 0.0, 0.0, 0.0),
        Vec4::new(0.0, 2.0 * near / (top - bottom), 0.0, 0.0),
        Vec4::new(a, b, c, -1.0),
        Vec4::new(0.0, 0.0, d, 0.0),
    )
}

/// creates a projection from a frustum planes with a reversed depth mapped to [0..1]
pub fn make_projection_rh_from_frustum_reversed(
    left: f32,
    right: f32,
    bottom: f32,
    top: f32,
    z_near: f32,
    z_far: f32,
) -> Mat4 {
    assert!(z_near > 0.0 && z_far > 0.0);

    //
    // reversed z 0..1 projection based on https://thxforthefish.com/posts/reverse_z/
    //
    let a = (right + left) / (right - left);
    let b = (top + bottom) / (top - bottom);

    let c = z_near / (z_far - z_near);
    let d = z_far * z_near / (z_far - z_near);

    let sx = 2.0 * z_near / (right - left);
    let sy = 2.0 * z_near / (top - bottom);

    // 

    Mat4::from_cols(
        Vec4::new(sx, 0.0, 0.0, 0.0),
        Vec4::new(0.0, sy, 0.0, 0.0),
        Vec4::new(a, b, c, -1.0),
        Vec4::new(0.0, 0.0, d, 0.0),
    )

}

pub fn make_projection_rh_custom(fov_y: f32, aspect_ratio: f32, z_near: f32, z_far: f32) -> Mat4 {
    let tan_fovy = (fov_y * 0.5).tan(); // use half angle beta
    let right = tan_fovy * aspect_ratio * z_near;
    let left = -right;
    let top = tan_fovy * z_near;
    let bottom = -top;

    //make_projection_rh_from_frustum(left, right, bottom, top, z_near, z_far)

    make_projection_rh_from_frustum_reversed(left, right, bottom, top, z_near, z_far)
}

pub fn create_offaxis_matrices(
    screen_lower_left: Vec3,
    screen_lower_right: Vec3,
    screen_upper_left: Vec3,
    pos_eye: Vec3,
    z_far: f32,
) -> (Mat4, Mat4) {
    //
    let vec_right = screen_lower_right - screen_lower_left; // vr
    let vec_up = screen_upper_left - screen_lower_left; // vu

    let frustum_left = screen_lower_left - pos_eye; // va
    let frustum_right = screen_lower_right - pos_eye; // vb
    let frustum_up = screen_upper_left - pos_eye; // vc

    let vec_right_normalized = vec_right.normalize();
    let vec_up_normalized = vec_up.normalize();

    let vec_normal = vec_right_normalized.cross(vec_up_normalized).normalize();

    let dist = -frustum_left.normalize().dot(vec_normal);

    // println!("vec_right_normalized {}",vec_right_normalized);
    // println!("vec_up_normalized {}",vec_up_normalized);
    // println!("vec_normal {}",vec_normal);

    // println!("Dist {}",dist);

    // small offset for the near plane
    let min_near_distance_offset = 0.01f32;

    // set a minimal near distance
    let min_near_distance = 0.00001f32;

    // calculate a reasonable near distance
    let z_near = min_near_distance.max(dist - min_near_distance_offset);

    // distances
    let left = vec_right_normalized.dot(frustum_left) * z_near / dist; // left screen edge
    let right = vec_right_normalized.dot(frustum_right) * z_near / dist; // right screen edge
    let bottom = vec_up_normalized.dot(frustum_left) * z_near / dist; // bottom screen edge
    let top = vec_up_normalized.dot(frustum_up) * z_near / dist; // distance eye from screen

    // info!("l r b t {} {} {} {}",left,right,bottom,top);

    // create a view frustum
    let projection_matrix =
        make_projection_rh_from_frustum_reversed(left, right, bottom, top, z_near, z_far);

    let view_matrix_rotation = Mat4::from_cols(
        Vec4::new(
            vec_right_normalized.x,
            vec_up_normalized.x,
            vec_normal.x,
            0.0,
        ),
        Vec4::new(
            vec_right_normalized.y,
            vec_up_normalized.y,
            vec_normal.y,
            0.0,
        ),
        Vec4::new(
            vec_right_normalized.z,
            vec_up_normalized.z,
            vec_normal.z,
            0.0,
        ),
        Vec4::W,
    );

    let rotation_quat = Quat::from_mat4(&view_matrix_rotation); // Quat::from_mat4(view_matrix_rotation);

    // info!("Rotation Mat {:?}",view_matrix_rotation);
    // info!("Viewer Rotation {:?}",rotation_quat);

    let view_matrix_eye = Mat4::from_cols(Vec4::X, Vec4::Y, Vec4::Z, (-pos_eye).extend(1.0));

    // create resulting view matrix (this should be much simpler using glam API)
    let view_matrix = view_matrix_rotation * view_matrix_eye;

    // return tuple of view and projection
    (view_matrix, projection_matrix)
}

#[cfg(test)]
mod tests {
    use bevy::prelude::*;

    use crate::{projection::create_offaxis_matrices, screeninfo};

    use super::make_projection_rh_from_frustum;

    #[test]
    fn compare_projections() {
        // build an on-axis frustum
        let fovy = 33.0_f32;
        let aspect_ratio = 1.6666_f32;
        let z_near = 1.0_f32;
        let z_far = 1000.0_f32;

        let tan_fovy = (fovy * 0.5).to_radians().tan(); // use half angle beta
        let right = tan_fovy * aspect_ratio * z_near;
        let left = -right;
        let top = tan_fovy * z_near;
        let bottom = -top;

        let mat_frust = make_projection_rh_from_frustum(left, right, bottom, top, z_near, z_far);

        println!("mat 1 {:?}", mat_frust);

        let mat_pers = Mat4::perspective_rh_gl(fovy.to_radians(), aspect_ratio, z_near, z_far);

        println!("mat 2 {:?}", mat_pers);

        assert!(mat_frust.abs_diff_eq(mat_pers, f32::EPSILON));
    }

    #[test]
    fn create_view_matrices() {
        // Assumptions: Screensize 6.0m x 1.8m
        // Viewer is 5m away from center

        let screen_lower_left = Vec3::new(-3.0, -0.9, 0.0);
        let screen_lower_right = Vec3::new(3.0, -0.9, 0.0);
        let screen_upper_left = Vec3::new(-3.0, 0.9, 0.0);

        let eye_pos = Vec3::Z * 5.0;

        let z_far = 100.0_f32;

        let (view, projection) = create_offaxis_matrices(
            screen_lower_left,
            screen_lower_right,
            screen_upper_left,
            eye_pos,
            z_far,
        );

        println!("View {:?}", view);
        println!("Projection {:?}", projection);

        // assert!(!view.is_nan());
        // assert!(!projection.is_nan());
    }
}