use lb::algebra::Algebra;
use lb::algebra::AlgebraMut;
use lb::mat;
use lb::mat::Matrix;

#[test]
fn matrix_rotate_180() {
    let mat = mat::MatrixVec::from([
        [0, 1, 2], //
        [3, 4, 5], //
    ]);

    let rot = mat.rotate_180();

    assert_eq!(
        rot.as_slice(),
        [
            5, 4, //
            3, 2, //
            1, 0, //
        ]
    );
    assert_eq!(rot.size(), (3, 2).into());

    let rot = rot.rotate_180();

    assert_eq!(rot.as_slice(), mat.as_slice());
    assert_eq!(rot.size(), (3, 2).into());
}

#[test]
fn matrix_rotate_180_in_place() {
    let mut values = [
        0, 1, //
        2, 3, //
        4, 5, //
    ];

    let mut mat = mat::MatrixRefMut::new(&mut values, (2, 3).into()).unwrap();

    mat.rotate_180_in_place();

    assert_eq!(mat.size(), (2, 3).into());
    assert_eq!(
        values,
        [
            5, 4, //
            3, 2, //
            1, 0, //
        ]
    );

    let mut mat = mat::MatrixRefMut::new(&mut values, (2, 3).into()).unwrap();

    mat.rotate_180_in_place();

    assert_eq!(mat.size(), (2, 3).into());
    assert_eq!(
        values,
        [
            0, 1, //
            2, 3, //
            4, 5, //
        ]
    );
}

#[test]
fn matrix_transpose() {
    let values = [
        0, 1, 2, //
        3, 4, 5, //
        6, 7, 8, //
        9, 10, 11, //
    ];

    let mat = mat::MatrixRef::new(&values, (3, 4).into()).unwrap();

    let transposed = mat.transpose();

    assert_eq!(transposed.size(), (4, 3).into());
    assert_eq!(
        transposed.as_slice(),
        [
            0, 3, 6, 9, //
            1, 4, 7, 10, //
            2, 5, 8, 11, //
        ]
    );

    let transposed = transposed.transpose();

    assert_eq!(transposed.size(), (3, 4).into());
    assert_eq!(transposed.as_slice(), values);
}

#[test]
fn matrix_rotate_90_right() {
    let values = [
        0, 1, //
        2, 3, //
        4, 5, //
    ];

    let mat = mat::MatrixRef::new(&values, (2, 3).into()).unwrap();

    let rot = mat.rotate_90_right();

    assert_eq!(rot.size(), (3, 2).into());
    assert_eq!(
        rot.as_slice(),
        [
            4, 2, 0, //
            5, 3, 1, //
        ]
    );

    let rot = rot.rotate_90_right();

    assert_eq!(rot.size(), (2, 3).into());
    assert_eq!(
        rot.as_slice(),
        [
            5, 4, //
            3, 2, //
            1, 0, //
        ]
    );

    let rot = rot.rotate_90_right();

    assert_eq!(rot.size(), (3, 2).into());
    assert_eq!(
        rot.as_slice(),
        [
            1, 3, 5, //
            0, 2, 4, //
        ]
    );

    let rot = rot.rotate_90_right();

    assert_eq!(rot.size(), (2, 3).into());
    assert_eq!(rot.as_slice(), values);
}

#[test]
fn matrix_rotate_90_left() {
    let values = [
        0, 1, //
        2, 3, //
        4, 5, //
    ];

    let mat = mat::MatrixRef::new(&values, (2, 3).into()).unwrap();

    let rot = mat.rotate_90_left();

    assert_eq!(rot.size(), (3, 2).into());
    assert_eq!(
        rot.as_slice(),
        [
            1, 3, 5, //
            0, 2, 4, //
        ]
    );

    let rot = rot.rotate_90_left();

    assert_eq!(rot.size(), (2, 3).into());
    assert_eq!(
        rot.as_slice(),
        [
            5, 4, //
            3, 2, //
            1, 0, //
        ]
    );

    let rot = rot.rotate_90_left();

    assert_eq!(rot.size(), (3, 2).into());
    assert_eq!(
        rot.as_slice(),
        [
            4, 2, 0, //
            5, 3, 1, //
        ]
    );

    let rot = rot.rotate_90_left();

    assert_eq!(rot.size(), (2, 3).into());
    assert_eq!(rot.as_slice(), values);
}

#[test]
fn matrix_reflect_horizontal() {
    {
        let mat = mat::MatrixVec::from([
            [0, 1, 2], //
            [3, 4, 5], //
        ]);

        let refl = mat.reflect_horizontal();

        assert_eq!(
            refl,
            mat::MatrixVec::from([
                [2, 1, 0], //
                [5, 4, 3], //
            ])
        );

        let refl = refl.reflect_horizontal();

        assert_eq!(refl, mat);
    }

    {
        let mat = mat::MatrixVec::from([
            [0, 1, 2, 3], //
            [4, 5, 6, 7], //
        ]);

        let refl = mat.reflect_horizontal();

        assert_eq!(
            refl,
            mat::MatrixVec::from([
                [3, 2, 1, 0], //
                [7, 6, 5, 4], //
            ])
        );

        let refl = refl.reflect_horizontal();

        assert_eq!(refl, mat);
    }
}

#[test]
fn matrix_reflect_vertical() {
    {
        let mat = mat::MatrixVec::from([
            [0, 1], //
            [2, 3], //
            [4, 5], //
        ]);

        let refl = mat.reflect_vertical();

        assert_eq!(
            refl,
            mat::MatrixVec::from([
                [4, 5], //
                [2, 3], //
                [0, 1], //
            ])
        );

        let refl = refl.reflect_vertical();

        assert_eq!(refl, mat);
    }

    {
        let mat = mat::MatrixVec::from([
            [0, 1], //
            [2, 3], //
            [4, 5], //
            [6, 7], //
        ]);

        let refl = mat.reflect_vertical();

        assert_eq!(
            refl,
            mat::MatrixVec::from([
                [6, 7], //
                [4, 5], //
                [2, 3], //
                [0, 1], //
            ])
        );

        let refl = refl.reflect_vertical();

        assert_eq!(refl, mat);
    }
}