using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Azimuth;
using Azimuth.DenseLinearAlgebra;

namespace Azimuth.UnitTests
{
    public class Matrix2x2Tests : UnitTestSharp.TestFixture
    {
        public class CtorTests : UnitTestSharp.TestFixture
        {
            public void From2DArray()
            {
                var mat = new Matrix2x2(new Scalar[,]
                {
                    { 1, 2, },
                    { 3, 4, },
                });

                CheckEqual(1, mat[0, 0]);
                CheckEqual(2, mat[0, 1]);
                CheckEqual(3, mat[1, 0]);
                CheckEqual(4, mat[1, 1]);
            }

            public void FromScalars()
            {
                var mat = new Matrix2x2(
                    1, 2,
                    3, 4
                );

                CheckEqual(1, mat[0, 0]);
                CheckEqual(2, mat[0, 1]);
                CheckEqual(3, mat[1, 0]);
                CheckEqual(4, mat[1, 1]);
            }
        }

        public class EqualityTests : UnitTestSharp.TestFixture
        {
            public void IsEqual()
            {
                var a = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 0, },
                    { 0, 1, },
                });

                var b = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 0, },
                    { 0, 1, },
                });

                CheckEqual(a, b);
            }

            public void IsUnequal_00()
            {
                var a = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 0, },
                    { 0, 1, },
                });

                var b = new Matrix2x2(new Scalar[,] 
                {
                    { 2, 0, },
                    { 0, 1, },
                });

                CheckNotEqual(a, b);
            }

            public void IsUnequal_01()
            {
                var a = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 1, },
                    { 0, 1, },
                });

                var b = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 0, },
                    { 0, 1, },
                });

                CheckNotEqual(a, b);
            }

            public void IsUnequal_10()
            {
                var a = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 0, },
                    { 0, 1, },
                });

                var b = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 0, },
                    { 1, 1, },
                });

                CheckNotEqual(a, b);
            }

            public void IsUnequal_11()
            {
                var a = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 0, },
                    { 0, 1, },
                });

                var b = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 0, },
                    { 0, 2, },
                });

                CheckNotEqual(a, b);
            }
        }

        public class InversionTests : UnitTestSharp.TestFixture
        {
            public void Identity()
            {
                var ident = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 0, },
                    { 0, 1, },
                });

                var expected = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 0, },
                    { 0, 1, },
                });

                Check(ident.Invert());
                CheckEqual(expected, ident);
            }

            public void Orthogonal()
            {
                var mat = new Matrix2x2(new Scalar[,] 
                {
                    { 0.8, -0.6, },
                    { 0.6, 0.8, },
                });

                var expected = new Matrix2x2(new Scalar[,] 
                {
                    { 0.8, 0.6, },
                    { -0.6, 0.8, },
                });

                Check(mat.Invert());
                CheckEqual(expected, mat);
            }

            public void Symmetric()
            {
                var mat = new Matrix2x2(new Scalar[,] 
                {
                    { 4, 3, },
                    { 3, 4, },
                });

                var expected = new Matrix2x2(new Scalar[,] 
                {
                    { 4.0/7.0, -3.0/7.0, },
                    { -3.0/7.0, 4.0/7.0, },
                });

                Check(mat.Invert());
                CheckEqual(expected, mat);
            }

            public void ArbitraryMatrix()
            {
                var mat = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 2, },
                    { 3, -1, },
                });

                var expected = new Matrix2x2(new Scalar[,] 
                {
                    { 1.0/7.0,  2.0/7.0, },
                    { 3.0/7.0, -1.0/7.0, },
                });

                Check(mat.Invert());
                CheckEqual(expected, mat);
            }

            public void SingularMatrix()
            {
                var mat = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 1, },
                    { 1, 1, },
                });

                var expected = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 1, },
                    { 1, 1, },
                });

                CheckFalse(mat.Invert());
                CheckEqual(expected, mat);
            }
        }

        public class AssignmentMulTests : UnitTestSharp.TestFixture
        {
            public void Basic_AB()
            {
                var A = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 0, },
                    { 0, 2, },
                });

                var B = new Matrix2x2(new Scalar[,] 
                {
                    { 3, 4, },
                    { -4, 1, },
                });

                var expected = new Matrix2x2(new Scalar[,]
                {
                    { 3, 4, },
                    { -8, 2, },
                });

                var C = new Matrix2x2();

                C.AssignmentMul(A, B);

                CheckEqual(expected, C);
                CheckEqual(expected, A * B);
            }

            public void Basic_BA()
            {
                var A = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 0, },
                    { 0, 2, },
                });

                var B = new Matrix2x2(new Scalar[,] 
                {
                    { 3, 4, },
                    { -4, 1, },
                });

                var expected = new Matrix2x2(new Scalar[,]
                {
                    { 3, 8, },
                    { -4, 2, },
                });

                var C = new Matrix2x2();

                C.AssignmentMul(B, A);

                CheckEqual(expected, C);
                CheckEqual(expected, B * A);
            }

            public void Source_lhs()
            {
                var A = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 0, },
                    { 0, 2, },
                });

                var B = new Matrix2x2(new Scalar[,] 
                {
                    { 3, 4, },
                    { -4, 1, },
                });

                var expected = new Matrix2x2(new Scalar[,]
                {
                    { 3, 4, },
                    { -8, 2, },
                });

                A.AssignmentMul(A, B);

                CheckEqual(expected, A);
            }

            public void Source_rhs()
            {
                var A = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 0, },
                    { 0, 2, },
                });

                var B = new Matrix2x2(new Scalar[,] 
                {
                    { 3, 4, },
                    { -4, 1, },
                });

                var expected = new Matrix2x2(new Scalar[,]
                {
                    { 3, 4, },
                    { -8, 2, },
                });

                B.AssignmentMul(A, B);

                CheckEqual(expected, B);
            }
        }

        public class TransposeTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var mat = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 3, },
                    { 0, 2, },
                });

                var expected = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 0, },
                    { 3, 2, },
                });

                mat.Transpose();
                CheckEqual(expected, mat);
            }
        }

        public class DeterminantTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var mat = new Matrix2x2(new Scalar[,] 
                {
                    { 1, 3, },
                    { 11, 2, },
                });

                CheckEqual(-31, mat.Determinant());
            }

            public void Zero()
            {
                var mat = new Matrix2x2(new Scalar[,] 
                {
                    { 3, 6, },
                    { 2, 4, },
                });

                CheckEqual(0, mat.Determinant());
            }
        }

        public class CloneTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var mat = new Matrix2x2(new Scalar[,]
                {
                    { 1, 2, },
                    { 3, 4, },
                });

                var expected = new Matrix2x2(new Scalar[,]
                {
                    { 1, 2, },
                    { 3, 4, },
                });

                var clone = mat.Clone();

                mat[0, 0] = 100;

                CheckEqual(expected, clone);
            }
        }

        public class RankTests : UnitTestSharp.TestFixture
        {
            public void Zero()
            {
                var mat = new Matrix2x2(new Scalar[,]
                {
                    { 0, 0, },
                    { 0, 0, },
                });

                CheckEqual(0, mat.Rank());
            }

            public void One_OffDiagonal()
            {
                var mat = new Matrix2x2(new Scalar[,]
                {
                    { 0, 1, },
                    { 0, 0, },
                });

                CheckEqual(1, mat.Rank());
            }

            public void One_Diagonal()
            {
                var mat = new Matrix2x2(new Scalar[,]
                {
                    { 1, 0, },
                    { 0, 0, },
                });

                CheckEqual(1, mat.Rank());
            }

            public void Identity()
            {
                var mat = new Matrix2x2(new Scalar[,]
                {
                    { 1, 0, },
                    { 0, 1, },
                });

                CheckEqual(2, mat.Rank());
            }

            public void OtherDiagonal()
            {
                var mat = new Matrix2x2(new Scalar[,]
                {
                    { 0, 1, },
                    { 1, 0, },
                });

                CheckEqual(2, mat.Rank());
            }

            public void Full()
            {
                var mat = new Matrix2x2(new Scalar[,]
                {
                    { 2, 1, },
                    { 1, 3, },
                });

                CheckEqual(2, mat.Rank());
            }

            public void LowerRight()
            {
                var mat = new Matrix2x2(new Scalar[,]
                {
                    { 0, 0, },
                    { 1, 0, },
                });

                CheckEqual(1, mat.Rank());
            }
        }

        public class VectorMultiplyTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var matrix = new Matrix2x2(1, 2, 3, 4);
                var vector = new Vector(5, 6);

                CheckEqual(new Vector(17, 39), matrix.VectorMultiply(vector));
            }
        }

        public class ScalarMultiply : UnitTestSharp.TestFixture
        {
            public void Lhs()
            {
                var mat = new Matrix2x2(1, 2, 3, 4);
                var expected = new Matrix2x2(2, 4, 6, 8);

                CheckEqual(expected, mat * 2);
            }

            public void Rhs()
            {
                var mat = new Matrix2x2(1, 2, 3, 4);
                var expected = new Matrix2x2(2, 4, 6, 8);

                CheckEqual(expected, 2 * mat);
            }
        }

        public class ScalarDivide : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var mat = new Matrix2x2(2, 4, 6, 8);
                var expected = new Matrix2x2(1, 2, 3, 4);

                CheckEqual(expected, mat / 2);
            }

            public void Zero()
            {
                var mat = new Matrix2x2(1, 2, -3, -4);
                var expected = new Matrix2x2(
                    Scalar.PositiveInfinity, Scalar.PositiveInfinity,
                    Scalar.NegativeInfinity, Scalar.NegativeInfinity
                );

                CheckEqual(expected, mat / 0);
            }
        }

        public class ScalarAdd : UnitTestSharp.TestFixture
        {
            public void Lhs()
            {
                var mat = new Matrix2x2(2, 4, 6, 8);
                var expected = new Matrix2x2(5, 7, 9, 11);

                CheckEqual(expected, mat + 3);
            }

            public void Rhs()
            {
                var mat = new Matrix2x2(2, 4, 6, 8);
                var expected = new Matrix2x2(5, 7, 9, 11);

                CheckEqual(expected, 3 + mat);
            }
        }

        public class ScalarSubtract : UnitTestSharp.TestFixture
        {
            public void Lhs()
            {
                var mat = new Matrix2x2(5, 7, 9, 11);
                var expected = new Matrix2x2(2, 4, 6, 8);

                CheckEqual(expected, mat - 3);
            }

            public void Rhs()
            {
                var mat = new Matrix2x2(5, 7, 9, 11);
                var expected = new Matrix2x2(-2, -4, -6, -8);

                CheckEqual(expected, 3 - mat);
            }
        }

        public class MatrixAdd : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var lhs = new Matrix2x2(5, 7, 9, 11);
                var rhs = new Matrix2x2(1, 2, 3, 4);
                var expected = new Matrix2x2(6, 9, 12, 15);

                CheckEqual(expected, lhs + rhs);
            }
        }

        public class MatrixSubtract : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var lhs = new Matrix2x2(5, 7, 9, 11);
                var rhs = new Matrix2x2(1, 2, 3, 4);
                var expected = new Matrix2x2(4, 5, 6, 7);

                CheckEqual(expected, lhs - rhs);
            }
        }

        public class TransposeCopyTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var mat = new Matrix2x2(1, 2, 3, 4);
                var original = new Matrix2x2(1, 2, 3, 4);
                var expected = new Matrix2x2(1, 3, 2, 4);
                CheckEqual(expected, mat.TransposeCopy());
                CheckEqual(original, mat);
            }
        }

        public class FromRotationTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var mat = Matrix2x2.FromRotation(Math.PI / 8);
                var c = Math.Cos(Math.PI / 8);
                var s = Math.Sin(Math.PI / 8);
                var expected = new Matrix2x2(c, -s, s, c);
                CheckEqual(expected, mat);
            }
        }

        public class ISquareMatrixTests : UnitTestSharp.TestFixture
        {
            public void ColumnCount()
            {
                ISquareMatrix matrix = new Matrix2x2();
                CheckEqual(2, matrix.ColumnCount);
            }

            public void RowCount()
            {
                ISquareMatrix matrix = new Matrix2x2();
                CheckEqual(2, matrix.RowCount);
            }

            public void Size()
            {
                ISquareMatrix matrix = new Matrix2x2();
                CheckEqual(2, matrix.Size);
            }
        }
    }
}