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

namespace Azimuth.UnitTests
{
    public class Matrix3x3Tests : UnitTestSharp.TestFixture
    {
        public void SolveEquation_Basic()
        {
            var mat = new Matrix3x3(new Scalar[,] {
                { 1, 2, 3, },
                { 3, 2, 1, },
                { 1, 2, 1, },
            });

            Scalar det;
            Vector3 actual;
            bool success = mat.SolveEquation(new Vector3(1, 2, 3), out actual, out det);

            var expected = new Vector3(-.5, 2.25, -1);

            Check(success);
            CheckEqual(expected, actual);
            CheckEqual(8.0, det);
        }

        public void SolveEquation_Basic_Static()
        {
            var col0 = new Vector3(1, 3, 1);
            var col1 = new Vector3(2, 2, 2);
            var col2 = new Vector3(3, 1, 1);

            Scalar det;
            Vector3 actual;
            bool success = Matrix3x3.SolveEquation(col0, col1, col2, new Vector3(1, 2, 3), out actual, out det);

            var expected = new Vector3(-.5, 2.25, -1);

            Check(success);
            CheckEqual(expected, actual);
            CheckEqual(8.0, det);
        }

        public void SolveEquation_Degenerate()
        {
            var col0 = new Vector3(1, 3, 1);
            var col1 = new Vector3(2, 2, 2);
            var col2 = new Vector3(1, 1, 1);

            Scalar det;
            Vector3 actual;
            bool success = Matrix3x3.SolveEquation(col0, col1, col2, new Vector3(1, 2, 3), out actual, out det);

            CheckFalse(success);
            Check(Vector3.IsNaN(actual));
            CheckEqual(0, det);
        }

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

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

            mat.Transpose();

            CheckEqual(expected, mat);
        }

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

            var clone = mat.Clone();

            CheckEqual(mat, clone);
            mat[1, 1] = 100;
            CheckNotEqual(mat, clone);
        }

        public void ArrayAccessor()
        {
            var mat = new Matrix3x3(new Scalar[,] {
                { 1, 2, 3, },
                { 4, 5, 6, },
                { 7, 8, 9, },
            });

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

            CheckEqual(4, mat[1, 0]);
            CheckEqual(5, mat[1, 1]);
            CheckEqual(6, mat[1, 2]);

            CheckEqual(7, mat[2, 0]);
            CheckEqual(8, mat[2, 1]);
            CheckEqual(9, mat[2, 2]);
        }

        public void ArrayAccessor_NegativeRow()
        {
            var mat = new Matrix3x3(new Scalar[,] {
                { 1, 2, 3, },
                { 4, 5, 6, },
                { 7, 8, 9, },
            });

            CheckThrow(typeof(Exception));
            CheckEqual(1, mat[-1, 0]);
        }

        public void ArrayAccessor_BigRow()
        {
            var mat = new Matrix3x3(new Scalar[,] {
                { 1, 2, 3, },
                { 4, 5, 6, },
                { 7, 8, 9, },
            });

            CheckThrow(typeof(Exception));
            CheckEqual(1, mat[3, 0]);
        }

        public void ArrayAccessor_NegativeCol()
        {
            var mat = new Matrix3x3(new Scalar[,] {
                { 1, 2, 3, },
                { 4, 5, 6, },
                { 7, 8, 9, },
            });

            CheckThrow(typeof(Exception));
            CheckEqual(1, mat[0, -1]);
        }

        public void ArrayAccessor_BigCol()
        {
            var mat = new Matrix3x3(new Scalar[,] {
                { 1, 2, 3, },
                { 4, 5, 6, },
                { 7, 8, 9, },
            });

            CheckThrow(typeof(Exception));
            CheckEqual(1, mat[0, 3]);
        }

        public void Equality_True()
        {
            var mat1 = new Matrix3x3(new Scalar[,] {
                { 1, 2, 3, },
                { 4, 5, 6, },
                { 7, 8, 9, },
            });

            var mat2 = new Matrix3x3(new Scalar[,] {
                { 1, 2, 3, },
                { 4, 5, 6, },
                { 7, 8, 9, },
            });

            CheckEqual(mat1, mat2);
        }

        public void Equality_False()
        {
            var mat1 = new Matrix3x3(new Scalar[,] {
                { 1, 2, 99, },
                { 4, 5, 6, },
                { 7, 8, 9, },
            });

            var mat2 = new Matrix3x3(new Scalar[,] {
                { 1, 2, 3, },
                { 4, 5, 6, },
                { 7, 8, 9, },
            });

            CheckNotEqual(mat1, mat2);
        }

        public void BuildFromCols()
        {
            var col0 = new Vector3(1, 2, 3);
            var col1 = new Vector3(4, 5, 6);
            var col2 = new Vector3(7, 8, 9);

            var mat = Matrix3x3.BuildFromColumns(col0, col1, col2);

            var expected = new Matrix3x3(new Scalar[,] {
                { 1, 4, 7, },
                { 2, 5, 8, },
                { 3, 6, 9, },
            });

            CheckEqual(expected, mat);
        }

        public void BuildFromRows()
        {
            var row0 = new Vector3(1, 2, 3);
            var row1 = new Vector3(4, 5, 6);
            var row2 = new Vector3(7, 8, 9);

            var mat = Matrix3x3.BuildFromRows(row0, row1, row2);

            var expected = new Matrix3x3(new Scalar[,] {
                { 1, 2, 3, },
                { 4, 5, 6, },
                { 7, 8, 9, },
            });

            CheckEqual(expected, mat);
        }

        public void ToStringTest()
        {
            var mat = new Matrix3x3(new Scalar[,] {
                { 1, 2, 3, },
                { 4, 5, 6, },
                { 7, 8, 9, },
            });

            var expected = "[<1 : 2 : 3>\n<4 : 5 : 6>\n<7 : 8 : 9>]";
            CheckEqual(expected, mat.ToString());
        }

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

            public void RowCount()
            {
                ISquareMatrix matrix = new Matrix3x3();
                CheckEqual(3, matrix.RowCount);
            }

            public void Size()
            {
                ISquareMatrix matrix = new Matrix3x3();
                CheckEqual(3, matrix.Size);
            }
        }
    }
}