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

namespace Azimuth.UnitTests.SparseLinearAlgebra
{
    public class SparseVectorTests : UnitTestSharp.TestFixture
    {
        public class Ctor : UnitTestSharp.TestFixture
        {
            /// <summary>
            /// If it doesn't fail, test passes
            /// </summary>
            public void Basic()
            {
                var v = new SparseVector();
            }

            public class FromDense : UnitTestSharp.TestFixture
            {
                public void FromArray()
                {
                    var dense = new Scalar[] { 1, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 7, 8, };
                    var v = new SparseVector(dense);
                    
                    for(int i = 0; i < dense.Length; ++i)
                    {
                        CheckEqual(dense[i], v[i]);
                    }

                    CheckEqual(dense.Length, v.Length);
                    CheckEqual(4, v.NonZeroCount);
                }

                public void FromDenseVector()
                {
                    var dense = new Azimuth.DenseLinearAlgebra.DenseVector(new Scalar[] { 1, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 7, 8, });
                    var v = new SparseVector(dense);

                    for (int i = 0; i < dense.Length; ++i)
                    {
                        CheckEqual(dense[i], v[i]);
                    }

                    CheckEqual(dense.Length, v.Length);
                    CheckEqual(4, v.NonZeroCount);
                }
            }
        }

        public class Clone : UnitTestSharp.TestFixture
        {
            public void Works()
            {
                var dense = new Scalar[] { 0, 1, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, };
                SparseVector sparse = new SparseVector(dense);

                SparseVector sparseClone = sparse.Clone();

                CheckEqual(sparse, sparseClone);
                sparseClone[0] = 10;
                CheckNotEqual(sparse, sparseClone);
            }
        }

        public class NonZeroCount : UnitTestSharp.TestFixture
        {
            public void Works()
            {
                var dense = new Scalar[] { 0, 1, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, };

                CheckEqual(3, new SparseVector(dense).NonZeroCount);
            }

            public void Zero()
            {
                var dense = new Scalar[] { 0, 0, 0, };

                CheckEqual(0, new SparseVector(dense).NonZeroCount);
            }
        }

        public class Length : UnitTestSharp.TestFixture
        {
            public void Works()
            {
                var dense = new Scalar[] { 0, 1, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, };

                CheckEqual(dense.Length, new SparseVector(dense).Length);
            }

            public void Zero()
            {
                var dense = new Scalar[] { 0, 0, 0, };

                CheckEqual(dense.Length, new SparseVector(dense).Length);
            }
        }

        public class ArrayAccessor : UnitTestSharp.TestFixture
        {
            SparseVector sparse;
            readonly SparseVector reference = new SparseVector(new Scalar[] { 0, 1, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, });

            public override void TestSetup()
            {
                sparse = reference.Clone();
            }

            public void ReplaceElement()
            {
                sparse[1] = 5;
                CheckEqual(reference.Length, sparse.Length);
                CheckEqual(reference.NonZeroCount, sparse.NonZeroCount);
            }

            public void AddElementInPlace()
            {
                sparse[0] = 5;
                CheckEqual(reference.Length, sparse.Length);
                CheckEqual(reference.NonZeroCount + 1, sparse.NonZeroCount);
            }

            public void AddElementAtEnd_NoLengthIncrease()
            {
                CheckThrow(typeof(Exception));
                sparse[reference.Length] = 5;
            }

            public void AddElementAtEnd_IncreaseLength()
            {
                sparse.Length++;
                sparse[reference.Length] = 5;
                CheckEqual(reference.Length + 1, sparse.Length);
                CheckEqual(reference.NonZeroCount + 1, sparse.NonZeroCount);
            }

            public void RemoveInPlace()
            {
                sparse[1] = 0;
                CheckEqual(reference.Length, sparse.Length);
                CheckEqual(reference.NonZeroCount - 1, sparse.NonZeroCount);
            }

            public void FakeRemove()
            {
                sparse[0] = 0;
                CheckEqual(reference.Length, sparse.Length);
                CheckEqual(reference.NonZeroCount, sparse.NonZeroCount);
            }

            public void RemoveAtEnd()
            {
                sparse[sparse.Length - 1] = 10;
                sparse[sparse.Length - 1] = 0;
                CheckEqual(reference.Length, sparse.Length);
                CheckEqual(reference.NonZeroCount, sparse.NonZeroCount);
            }
        }

        public class ToStringTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                string expected = "<0 : 1 : 0 : -1 : 0 : 0 : 0 : 0 : 0 : 0 : -1 : 0 : 0>";

                SparseVector vec = new SparseVector(new Scalar[] { 0, 1, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, });

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

            public void Empty()
            {
                string expected = "<{empty}>";

                SparseVector vec = new SparseVector(new Scalar[] { });

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

        public class ToDenseVector : UnitTestSharp.TestFixture
        {
            public void RoundTrip()
            {
                var vec = new Azimuth.DenseLinearAlgebra.DenseVector(
                    new Scalar[] { 0, 1, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, });

                var sparse = new SparseVector(vec);
                var denseRoundTrip = sparse.ToDenseVector();

                CheckEqual(vec, denseRoundTrip);
            }
        }

        public class Equality : UnitTestSharp.TestFixture
        {
            public void Empty()
            {
                var vec1 = new SparseVector();
                var vec2 = new SparseVector();

                CheckEqual(vec1, vec2);
                CheckEqual(vec2, vec1);
            }

            public void SparseSparse()
            {
                var vec1 = new SparseVector(new Scalar[] { 0, 1, 0 });
                var vec2 = new SparseVector(new Scalar[] { 0, 1, 0 });

                CheckEqual(vec1, vec2);
                CheckEqual(vec2, vec1);
            }

            public void SparseSparseDifferentLengths()
            {
                var vec1 = new SparseVector(new Scalar[] { 0, 1, });
                var vec2 = new SparseVector(new Scalar[] { 0, 1, 0 });

                CheckEqual(vec1, vec2);
                CheckEqual(vec2, vec1);
            }

            public void SparseSparseNotEqual()
            {
                var vec1 = new SparseVector(new Scalar[] { 1, 0 });
                var vec2 = new SparseVector(new Scalar[] { 0, 1, 0 });

                CheckNotEqual(vec1, vec2);
                CheckNotEqual(vec2, vec1);
            }
        }

        public class SparseDotProduct : UnitTestSharp.TestFixture
        {
            public void TotallyDense()
            {
                SparseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7 };
                SparseVector array2 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7 };

                CheckEqual(140, array1.DotProduct(array2));
                CheckEqual(140, array2.DotProduct(array1));
            }

            public void Empty()
            {
                SparseVector array1 = new Scalar[] { };
                SparseVector array2 = new Scalar[] { };

                CheckEqual(0, array1.DotProduct(array2));
                CheckEqual(0, array2.DotProduct(array1));
            }

            public void DifferentLength_1()
            {
                SparseVector array1 = new Scalar[] { 1, 2, 3 };
                SparseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.DotProduct(array2);
            }

            public void DifferentLength_2()
            {
                SparseVector array1 = new Scalar[] { 1, 2, 3 };
                SparseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array2.DotProduct(array1);
            }

            public void Sparse()
            {
                SparseVector array1 = new SparseVector(8);
                SparseVector array2 = new SparseVector(8);

                array1[2] = 1;
                array1[6] = 1;
                array1[7] = 1;

                array2[2] = 1;
                array2[1] = 1;
                array2[3] = 1;

                CheckEqual(1, array2.DotProduct(array1));
                CheckEqual(1, array1.DotProduct(array2));
            }
        }

        public class DenseDotProduct : UnitTestSharp.TestFixture
        {
            public void TotallyDense()
            {
                SparseVector array1 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7 };
                DenseVector array2 = new Scalar[] { 1, 2, 3, 4, 5, 6, 7 };

                CheckEqual(140, array1.DotProduct(array2));
                //CheckEqual(140, array2.DotProduct(array1));
            }

            public void Empty()
            {
                SparseVector array1 = new Scalar[] { };
                DenseVector array2 = new Scalar[] { };

                CheckEqual(0, array1.DotProduct(array2));
                //CheckEqual(0, array2.DotProduct(array1));
            }

            public void DifferentLength_1()
            {
                SparseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                array1.DotProduct(array2);
            }

            // No DenseVector Dotproduct overload can take a sparse vector
            [UnitTestSharp.IgnoreTest]
            public void DifferentLength_2()
            {
                SparseVector array1 = new Scalar[] { 1, 2, 3 };
                DenseVector array2 = new Scalar[] { 3, 4 };

                CheckThrow(typeof(Exception));
                //array2.DotProduct(array1);
            }

            public void Sparse()
            {
                SparseVector array1 = new SparseVector(8);
                DenseVector array2 = new DenseVector(8);

                array1[2] = 1;
                array1[6] = 1;
                array1[7] = 1;

                array2[2] = 1;
                array2[1] = 1;
                array2[3] = 1;

                //CheckEqual(1, array2.DotProduct(array1));
                CheckEqual(1, array1.DotProduct(array2));
            }
        }
    }
}