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

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()
            {
                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);
            }
        }
    }
}