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

namespace Azimuth.UnitTests.DenseLinearAlgebra
{
    public class TransformGroupTests : TestFixture
    {
        public AffineMatrix identity = new AffineMatrix(0, Vector.Zero, 1);
        public AffineMatrix unitX = new AffineMatrix(0, Vector.UnitX, 1);
        public AffineMatrix _11 = new AffineMatrix(0, new Vector(1, 1), 1);
        public AffineMatrix _15 = new AffineMatrix(0, new Vector(1, 5), 1);
        public AffineMatrix rot180 = new AffineMatrix(Math.PI, Vector.Zero, 1);
        public AffineMatrix scale2 = new AffineMatrix(0, Vector.Zero, 2);

        public void Ctor_FromList()
        {
            var transforms = new TransformGroup(new AffineMatrix[]
            {
                identity,
                unitX,
                rot180,
                scale2,
            });

            CheckEqual(4, transforms.Count);
            CheckEqual(identity, transforms[0]);
            CheckEqual(unitX, transforms[1]);
            CheckEqual(rot180, transforms[2]);
            CheckEqual(scale2, transforms[3]);
        }

        public void Ctor_JustCount()
        {
            var transforms = new TransformGroup(4);

            CheckEqual(4, transforms.Count);
            CheckEqual(identity, transforms[0]);
            CheckEqual(identity, transforms[1]);
            CheckEqual(identity, transforms[2]);
            CheckEqual(identity, transforms[3]);
        }

        public void SetTransforms()
        {
            var transformGroup = new TransformGroup(4);

            var transforms = new AffineMatrix[]
            {
                identity,
                unitX,
                rot180,
                scale2,
            };

            transformGroup.Transforms = transforms;

            CheckEqual(transforms[0], transformGroup[0]);
            CheckEqual(transforms[1], transformGroup[1]);
            CheckEqual(transforms[2], transformGroup[2]);
            CheckEqual(transforms[3], transformGroup[3]);
        }

        public void TransformPoint()
        {
            var transforms = new TransformGroup(new AffineMatrix[]
            {
                identity,
                _11,
                rot180,
                scale2,
            });

            DenseVector X = new DenseVector(4);
            DenseVector Y = new DenseVector(4);

            transforms.TransformPoint(Vector.UnitX, ref X, ref Y);

            CheckEqual(new Vector(1, 0), new Vector(X[0], Y[0]));
            CheckEqual(new Vector(2, 1), new Vector(X[1], Y[1]));
            CheckEqual(new Vector(-1, 0), new Vector(X[2], Y[2]));
            CheckEqual(new Vector(2, 0), new Vector(X[3], Y[3]));
        }

        public void TransformDirection()
        {
            var transforms = new TransformGroup(new AffineMatrix[]
            {
                identity,
                _11,
                rot180,
                scale2,
            });

            DenseVector X = new DenseVector(4);
            DenseVector Y = new DenseVector(4);

            transforms.TransformDirection(Vector.UnitX, ref X, ref Y);

            CheckEqual(new Vector(1, 0), new Vector(X[0], Y[0]));
            CheckEqual(new Vector(1, 0), new Vector(X[1], Y[1]));
            CheckEqual(new Vector(-1, 0), new Vector(X[2], Y[2]));
            CheckEqual(new Vector(2, 0), new Vector(X[3], Y[3]));
        }

        public void AggregatePoints()
        {
            var transforms = new TransformGroup(new AffineMatrix[]
            {
                identity,
                _15,
                rot180,
                scale2,
            });

            var X = new DenseVector(new Scalar[] 
            {
                1, 2, 3, 4,
            });

            var Y = new DenseVector(new Scalar[] 
            {
                0, 1, 3, 2,
            });

            var newPos = transforms.AggregatePoints(X, Y);

            CheckEqual(new Vector(9, 7), newPos);
        }

        public void AggregateDirections()
        {
            var transforms = new TransformGroup(new AffineMatrix[]
            {
                identity,
                _15,
                rot180,
                scale2,
            });

            var X = new DenseVector(new Scalar[] 
            {
                1, 2, 3, 4,
            });

            var Y = new DenseVector(new Scalar[] 
            {
                0, 1, 3, 2,
            });

            var newPos = transforms.AggregateDirections(X, Y);

            CheckEqual(new Vector(8, 2), newPos);
        }

        public void AsEnumerable()
        {
            var transforms = new TransformGroup(new AffineMatrix[]
            {
                identity,
                unitX,
                rot180,
                scale2,
            });

            CheckEqual(new[] { identity, unitX, rot180, scale2 }, transforms.Transforms);
        }
    }
}