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

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

                new SquareMatrix(matrix);
            }

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

                CheckThrow(typeof(Exception));
                new SquareMatrix(matrix);
            }

            public void ZeroLength()
            {
                var matrix = new Scalar[0, 0];

                new SquareMatrix(matrix);
            }

            public void SpecifySizeWorks()
            {
                var matrix = new SquareMatrix(10);

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

            public void ThrowsExceptionWhenNegative()
            {
                CheckThrow(typeof(Exception));
                var matrix = new SquareMatrix(-10);
            }

            public void ConversionFromRectangular_Square()
            {
                var rawMatrix = new Scalar[,] { { 1, 2, }, { 2, 1 } };
                var rectangularMatrix = new RectangularMatrix(rawMatrix);
                var squareMatrix = new SquareMatrix(rectangularMatrix);

                CheckEqual(2, squareMatrix.Size);
                CheckEqual(rectangularMatrix, squareMatrix);
            }

            public void ConversionFromRectangular_Rectangular()
            {
                var rawMatrix = new Scalar[,] { { 1, 2, }, { 2, 1 }, {0,0} };
                var rectangularMatrix = new RectangularMatrix(rawMatrix);

                CheckThrow(typeof(Exception));
                var squareMatrix = new SquareMatrix(rectangularMatrix);
            }

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

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

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

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

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

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

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

        public class Conversions : TestFixture
        {
            public void FromScalar2D()
            {
                var matrix = new Scalar[,] {
                    {1},
                };

                SquareMatrix squareMatrix = matrix;
            }
        }

        public class RowWiseLargestElement : TestFixture
        {
            public void Works()
            {
                var matrix = new SquareMatrix(new Scalar[,] {
                    { 1, 2, 3 },
                    { 6, 5, 4 },
                    { 7, 9, 8 }
                });

                DenseVector largest = new Scalar[] {
                    3,
                    6,
                    9
                };

                CheckEqual(largest, matrix.CalculateRowWiseLargestElement());
            }
        }

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

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

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

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

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

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

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

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

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

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

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

                CheckEqual(matrix1, matrix2);
                CheckEqual(matrix2, matrix1);
                Check(matrix1.Equals(matrix2));
                Check(matrix2.Equals(matrix1));
            }

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

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

                CheckNotEqual(matrix1, matrix2);
                CheckNotEqual(matrix2, matrix1);
                CheckFalse(matrix1.Equals(matrix2));
                CheckFalse(matrix2.Equals(matrix1));
            }

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

                IRectangularMatrix matrix2 = new RectangularMatrix(new Scalar[,] {
                    { 1, 2, 0, },
                    { 6, 5, 0, },
                });

                CheckNotEqual(matrix1, matrix2);
                CheckNotEqual(matrix2, matrix1);
                CheckFalse(matrix1.Equals(matrix2));
                CheckFalse(matrix2.Equals(matrix1));
            }
        }

        public class SwapRows : TestFixture
        {
            public void Works()
            {
                var matrix = new SquareMatrix(new Scalar[,] {
                    { 1, 2, 3 },
                    { 6, 5, 4 },
                    { 7, 9, 8 }
                });

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

                matrix.SwapRows(0, 1);

                CheckEqual(swapped, matrix);
            }
        }

        public class FindLargestElementInColumn : TestFixture
        {
            public void Zeros()
            {
                var matrix = new SquareMatrix(new Scalar[,] {
                    { 0, 0, },
                    { 0, 0, },
                });

                DenseVector weightings = new Scalar[] {
                    1, 1
                };

                Scalar largest;

                int index = matrix.FindLargestElementInColumn(0, 0, 2, weightings, out largest);

                CheckEqual(0, largest);
                CheckEqual(0, index);
            }

            public void Works()
            {
                var matrix = new SquareMatrix(new Scalar[,] {
                    { 1, 2, 8 },
                    { 6, 9, 4 },
                    { 7, 5, 3 }
                });

                DenseVector weightings = new Scalar[] {
                    1, 1, 1
                };

                Scalar largest;
                int index;
                
                index = matrix.FindLargestElementInColumn(0, 0, 3, weightings, out largest);

                CheckEqual(2, index);
                CheckEqual(7, largest);

                index = matrix.FindLargestElementInColumn(1, 0, 3, weightings, out largest);

                CheckEqual(1, index);
                CheckEqual(9, largest);

                index = matrix.FindLargestElementInColumn(2, 0, 3, weightings, out largest);

                CheckEqual(0, index);
                CheckEqual(8, largest);
            }
        }

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

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

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

        public class SymmetryTests : TestFixture
        {
            public void x11()
            {
                var matrix = new SquareMatrix(new Scalar[,] { { 1, } });

                Check(matrix.IsSymmmetric());
            }

            public void Symmetric()
            {
                var matrix = new SquareMatrix(new Scalar[,] {
                    { 1, 2, },
                    { 2, 10, },
                });

                Check(matrix.IsSymmmetric());
            }

            public void NotSymmetric()
            {
                var matrix = new SquareMatrix(new Scalar[,] {
                    { 1, -2, },
                    { 2, 10, },
                });

                CheckFalse(matrix.IsSymmmetric());
            }
        }

        public class GetColumn : TestFixture
        {
            SquareMatrix matrix;

            public override void TestSetup()
            {
                matrix = new SquareMatrix(new Scalar[,] {
                    { 1, 2, 3, },
                    { 6, 5, 4, },
                    { 7, 9, 8, },
                });
            }

            public void Column0()
            {
                DenseVector expected = new DenseVector(new Scalar[] { 1, 6, 7 });

                CheckEqual(expected, matrix.GetColumn(0));
            }

            public void Column1()
            {
                DenseVector expected = new DenseVector(new Scalar[] { 2, 5, 9 });

                CheckEqual(expected, matrix.GetColumn(1));
            }

            public void Column2()
            {
                DenseVector expected = new DenseVector(new Scalar[] { 3, 4, 8 });

                CheckEqual(expected, matrix.GetColumn(2));
            }
        }

        public class SizeEtAl : TestFixture
        {
            SquareMatrix matrix = new Scalar[,] {
                    {1, 2, 3},
                    {4, 5, 6},
                    {7, 8, 9},
                };

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

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

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