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

namespace Azimuth.UnitTests.DenseLinearAlgebra
{
    public class RectangularMatrixTests
    {
        public class Ctor : TestFixture
        {
            public void RoundTrip()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3, },
                    { 4, 5, 6, },
                    { 7, 8, 9, },
                    { 0, 1, 2, },
                });

                IRectangularMatrix imatrix = matrix;

                var roundTrip = new RectangularMatrix(imatrix);

                CheckEqual(matrix, roundTrip);
            }

            public void Sized()
            {
                var matrix = new RectangularMatrix(10, 20);

                CheckEqual(10, matrix.RowCount);
                CheckEqual(20, matrix.ColumnCount);
            }

            public void FromArrayOfDenseVectorCols_Works()
            {
                var raw = new DenseVector[2];
                raw[0] = new DenseVector(3);
                raw[1] = new DenseVector(3);
                raw[0][0] = 1;
                raw[1][1] = 1;

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

                CheckEqual(expected, new RectangularMatrix(raw));
            }

            public void FromArrayOfDenseVectorCols_Jagged()
            {
                var raw = new DenseVector[2];
                raw[0] = new DenseVector(2);
                raw[1] = new DenseVector(3);

                CheckThrow(typeof(Exception));
                new RectangularMatrix(raw);
            }
        }

        public class Equality : TestFixture
        {
            public void Equal_Square()
            {
                var matrix1 = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3 },
                    { 6, 5, 4 },
                    { 7, 9, 8 }
                });

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

                CheckEqual(matrix1, matrix2);
                CheckEqual(matrix2, matrix1);
            }

            public void Equal_Tall()
            {
                var matrix1 = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 6, 5, },
                    { 7, 9, }
                });

                var matrix2 = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 6, 5, },
                    { 7, 9, }
                });

                CheckEqual(matrix1, matrix2);
                CheckEqual(matrix2, matrix1);
            }

            public void Equal_Fat()
            {
                var matrix1 = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3 },
                    { 6, 5, 4 },
                });

                var matrix2 = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3 },
                    { 6, 5, 4 },
                });

                CheckEqual(matrix1, matrix2);
                CheckEqual(matrix2, matrix1);
            }

            public void NotEqual_SameSize_Square()
            {
                var matrix1 = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3 },
                    { 6, 5, 4 },
                    { 7, 9, 8 }
                });

                var matrix2 = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3 },
                    { 6, 5, 4 },
                    { 7, 9, 10 }
                });

                CheckNotEqual(matrix1, matrix2);
                CheckNotEqual(matrix2, matrix1);
            }

            public void NotEqual_SameSize_Tall()
            {
                var matrix1 = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 6, 5, },
                    { 7, 9, }
                });

                var matrix2 = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 6, 10, },
                    { 7, 9, }
                });

                CheckNotEqual(matrix1, matrix2);
                CheckNotEqual(matrix2, matrix1);
            }

            public void NotEqual_SameSize_Fat()
            {
                var matrix1 = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3, },
                    { 6, 5, 10, },
                });

                var matrix2 = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3, },
                    { 6, 5, 4, },
                });

                CheckNotEqual(matrix1, matrix2);
                CheckNotEqual(matrix2, matrix1);
            }

            public void NotEqual_DifferentSize()
            {
                var matrix1 = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 3 },
                    { 6, 5, 4 },
                });

                var matrix2 = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 6, 5, },
                    { 7, 9, }
                });

                CheckNotEqual(matrix1, matrix2);
                CheckNotEqual(matrix2, matrix1);
            }

            public void Equal_IRectangularMatrix()
            {
                var matrix1 = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 6, 5, },
                });

                var matrix2 = new SquareMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 6, 5, },
                });

                CheckEqual(matrix1, matrix2);
                CheckEqual(matrix2, matrix1);
            }
        }

        public class ToStringTests : TestFixture
        {
            public void Basic()
            {
                var matrix = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 6, 5, },
                    { 7, 9, }
                });

                string expected = "[ 1 : 2 ]\n[ 6 : 5 ]\n[ 7 : 9 ]";

                CheckEqual(expected, matrix.ToString());
            }
        }

        public class SizeEtAl : TestFixture
        {
            RectangularMatrix matrix;

            public override void FixtureSetup()
            {
                matrix = new Scalar[,] {
                    {1, 2, 3, },
                    {4, 5, 6, },
                };
            }

            public void RowCount()
            {
                CheckEqual(2, matrix.RowCount);
            }

            public void ColumnCount()
            {
                CheckEqual(3, matrix.ColumnCount);
            }
        }
    }
}