using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Azimuth.UnitTests
{
    public class ComplexTests : UnitTestSharp.TestFixture
    {
        public void Ctor()
        {
            var complex = new Complex(10, 20);
            CheckEqual(10, complex.Real);
            CheckEqual(20, complex.Imaginary);
        }

        public void Conjugate()
        {
            CheckEqual((3, -4), new Complex(3, 4).Conjugate);
        }

        public void ImplicitConversionFromScalar()
        {
            Complex complex = 10;
            CheckEqual(10, complex.Real);
            CheckEqual(0, complex.Imaginary);
        }

        public class MagnitudeTests : UnitTestSharp.TestFixture
        {
            public void Zero()
            {
                var complex = new Complex();
                CheckEqual(0, complex.Magnitude());
            }

            public void PythagoreanTriple()
            {
                var complex = new Complex(3, 4);
                CheckEqual(5, complex.Magnitude());
            }

            public void NegativeReal()
            {
                var complex = new Complex(-3, 4);
                CheckEqual(5, complex.Magnitude());
            }

            public void NegativeImaginary()
            {
                var complex = new Complex(3, -4);
                CheckEqual(5, complex.Magnitude());
            }

            public void BothNegative()
            {
                var complex = new Complex(-3, -4);
                CheckEqual(5, complex.Magnitude());
            }
        }

        public class MagnitudeSquaredTests : UnitTestSharp.TestFixture
        {
            public void Zero()
            {
                var complex = new Complex();
                CheckEqual(0, complex.MagnitudeSquared());
            }

            public void PythagoreanTriple()
            {
                var complex = new Complex(3, 4);
                CheckEqual(25, complex.MagnitudeSquared());
            }

            public void NegativeReal()
            {
                var complex = new Complex(-3, 4);
                CheckEqual(25, complex.MagnitudeSquared());
            }

            public void NegativeImaginary()
            {
                var complex = new Complex(3, -4);
                CheckEqual(25, complex.MagnitudeSquared());
            }

            public void BothNegative()
            {
                var complex = new Complex(-3, -4);
                CheckEqual(25, complex.MagnitudeSquared());
            }
        }

        public class AngleTests : UnitTestSharp.TestFixture
        {
            public void Zero()
            {
                Complex complex = (0, 0);
                CheckEqual(0, complex.Angle());
            }

            public void PositiveReal()
            {
                Complex complex = (10, 0);
                CheckEqual(0, complex.Angle());
            }

            public void NegativeReal()
            {
                Complex complex = (-10, 0);
                CheckEqual(Math.PI, complex.Angle());
            }

            public void PositiveImaginary()
            {
                Complex complex = (0, 10);
                CheckEqual(Math.PI / 2, complex.Angle());
            }

            public void NegativeImaginary()
            {
                Complex complex = (0, -10);
                CheckEqual(-Math.PI / 2, complex.Angle());
            }

            public void PythTriple()
            {
                Complex complex = (3, 4);
                CheckEqual(0.9272952180016, complex.Angle());
            }
        }

        public class PrincipalSqrt : UnitTestSharp.TestFixture
        {
            public void Zero()
            {
                var complex = new Complex();
                CheckEqual(0, complex.PrincipalSqrt());
            }

            public void SquareReal()
            {
                Complex complex = 25;
                CheckEqual(5, complex.PrincipalSqrt());
            }

            public void Basic()
            {
                Complex complex = new Complex(3, 4);
                CheckEqual(new Complex(2, 1), complex.PrincipalSqrt());
            }

            public void RealNegative()
            {
                Complex complex = new Complex(-3, 4);
                CheckEqual(new Complex(1, 2), complex.PrincipalSqrt());
            }

            public void ImaginaryNegative()
            {
                Complex complex = new Complex(3, -4);
                CheckEqual(new Complex(2, -1), complex.PrincipalSqrt());
            }

            public void BothNegative()
            {
                Complex complex = new Complex(-3, -4);
                CheckEqual(new Complex(1, -2), complex.PrincipalSqrt());
            }
        }

        public class SinhCosh : UnitTestSharp.TestFixture
        {
            public void Zero()
            {
                var complex = new Complex(0, 0);
                Complex.SinhCosh(complex, out Complex sinh, out Complex cosh);
                CheckEqual(0, sinh);
                CheckEqual(1, cosh);
            }

            public void One()
            {
                var complex = new Complex(1, 0);
                Complex.SinhCosh(complex, out Complex sinh, out Complex cosh);
                CheckEqual(1.1752011936438014, sinh);
                CheckEqual(1.5430806348152437, cosh);
            }

            public void I()
            {
                var complex = new Complex(0, 1);
                Complex.SinhCosh(complex, out Complex sinh, out Complex cosh);
                CheckEqual(new Complex(0, Math.Sin(1)), sinh);
                CheckEqual(Math.Cos(1), cosh);
            }

            public void OnePlusI()
            {
                var complex = new Complex(1, 1);
                Complex.SinhCosh(complex, out Complex sinh, out Complex cosh);
                CheckEqual(new Complex(0.634963914784, 1.298457581415), sinh);
                CheckEqual(new Complex(0.833730025131, 0.988897705762), cosh);
            }

            public void NegativeOnePlusI()
            {
                var complex = new Complex(-1, 1);
                Complex.SinhCosh(complex, out Complex sinh, out Complex cosh);
                CheckEqual(new Complex(-0.634963914784, 1.298457581415), sinh);
                CheckEqual(new Complex(0.833730025131, -0.988897705762), cosh);
            }

            public void NegativeOneMinusI()
            {
                var complex = new Complex(-1, -1);
                Complex.SinhCosh(complex, out Complex sinh, out Complex cosh);
                CheckEqual(new Complex(-0.634963914784, -1.298457581415), sinh);
                CheckEqual(new Complex(0.833730025131, 0.988897705762), cosh);
            }

            public void OneMinusI()
            {
                var complex = new Complex(1, -1);
                Complex.SinhCosh(complex, out Complex sinh, out Complex cosh);
                CheckEqual(new Complex(0.634963914784, -1.298457581415), sinh);
                CheckEqual(new Complex(0.833730025131, -0.988897705762), cosh);
            }

            public void TwoMinusTwoI()
            {
                var complex = new Complex(2, -2);
                Complex.SinhCosh(complex, out Complex sinh, out Complex cosh);
                CheckEqual(new Complex(-1.509306485323, -3.420954861117), sinh);
                CheckEqual(new Complex(-1.565625835315, -3.297894836311), cosh);
            }
        }

        public class ToMatrix : UnitTestSharp.TestFixture
        {
            public void Zero()
            {
                var value = new Complex();
                CheckEqual(new Matrix2x2(), value.ToMatrix());
            }

            public void Basic()
            {
                var value = new Complex(3, 4);
                var expected = new Matrix2x2(
                    3, -4,
                    4, 3
                );
                CheckEqual(expected, value.ToMatrix());
            }
        }

        public class Arithmetic : UnitTestSharp.TestFixture
        {
            public void RealPostMultiplication()
            {
                var complex = new Complex(3, 4);
                CheckEqual(new Complex(6, 8), complex * 2);
            }

            public void RealPreMultiplication()
            {
                var complex = new Complex(3, 4);
                CheckEqual(new Complex(6, 8), 2 * complex);
            }

            public void RealPreAddition()
            {
                var complex = new Complex(3, 4);
                CheckEqual(new Complex(5, 4), 2 + complex);
            }

            public void RealPostAddition()
            {
                var complex = new Complex(3, 4);
                CheckEqual(new Complex(5, 4), complex + 2);
            }

            public void RealPreSubtraction()
            {
                var complex = new Complex(3, 4);
                CheckEqual(new Complex(-1, -4), 2 - complex);
            }

            public void RealPostSubtraction()
            {
                var complex = new Complex(3, 4);
                CheckEqual(new Complex(1, 4), complex - 2);
            }

            public void Negate()
            {
                var complex = new Complex(3, 4);
                CheckEqual(new Complex(-3, -4), -complex);
            }

            public void RealDivision()
            {
                var complex = new Complex(3, 4);
                CheckEqual(new Complex(1.5, 2), complex / 2);
            }

            public void ComplexMultiplication()
            {
                var a = new Complex(3, 4);
                var b = new Complex(5, -6);

                CheckEqual(new Complex(39, 2), a * b);
                CheckEqual(new Complex(39, 2), b * a);
            }

            public void ComplexAddition()
            {
                var a = new Complex(3, 4);
                var b = new Complex(5, -6);

                CheckEqual(new Complex(8, -2), a + b);
                CheckEqual(new Complex(8, -2), b + a);
            }

            public void ComplexSubtraction()
            {
                var a = new Complex(3, 4);
                var b = new Complex(5, -6);

                CheckEqual(new Complex(-2, 10), a - b);
                CheckEqual(new Complex(2, -10), b - a);
            }

            public void ComplexDivision()
            {
                var a = new Complex(3, 4);
                var b = new Complex(5, -6);

                CheckEqual(new Complex(-9.0/61, 38.0/61), a / b);
                CheckEqual(new Complex(-9.0/25, -38.0/25), b / a);
            }

            public void ComplexDivisionBy0()
            {
                var a = new Complex(3, -4);
                var b = new Complex();

                CheckEqual(new Complex(Scalar.PositiveInfinity, Scalar.NegativeInfinity), a / b);
            }

            public void ScalarDivisionBy0()
            {
                var a = new Complex(3, -4);

                CheckEqual(new Complex(Scalar.PositiveInfinity, Scalar.NegativeInfinity), a / new Scalar(0.0));
            }
        }

        public class ImplicitConversions : UnitTestSharp.TestFixture
        {
            public void Scalar()
            {
                Complex complex = new Scalar(10);

                CheckEqual(new Complex(10, 0), complex);
            }

            public void Float()
            {
                float value = 10;
                Complex complex = value;

                CheckEqual(new Complex(10, 0), complex);
            }

            public void Double()
            {
                double value = 10;
                Complex complex = value;

                CheckEqual(new Complex(10, 0), complex);
            }
        }

        public class IsNan : UnitTestSharp.TestFixture
        {
            public void AllNaN()
            {
                var complex = new Complex(Scalar.NaN, Scalar.NaN);
                Check(Complex.IsNaN(complex));
            }

            public void RealNaN()
            {
                var complex = new Complex(Scalar.NaN, 0);
                Check(Complex.IsNaN(complex));
            }

            public void ImaginaryNaN()
            {
                var complex = new Complex(0, Scalar.NaN);
                Check(Complex.IsNaN(complex));
            }

            public void NoneAreNaN()
            {
                var complex = new Complex(0, 1);
                CheckFalse(Complex.IsNaN(complex));
            }

            public void NaN()
            {
                Check(Scalar.IsNaN(Complex.NaN.Real));
                Check(Scalar.IsNaN(Complex.NaN.Imaginary));
            }
        }

        public class Equality : UnitTestSharp.TestFixture
        {
            public void Equals()
            {
                var a = new Complex(4, 5);
                var b = new Complex(4, 5);

                Check(a.Equals(b));
                Check(b.Equals(a));
            }

            public void EqualsOperator_Equal()
            {
                var a = new Complex(4, 5);
                var b = new Complex(4, 5);

                Check(a == b);
                Check(b == a);
            }

            public void UnequalsOperator_Equal()
            {
                var a = new Complex(4, 5);
                var b = new Complex(4, 5);

                CheckFalse(a != b);
                CheckFalse(b != a);
            }

            public void UnequalReals()
            {
                var a = new Complex(4, 5);
                var b = new Complex(3, 5);

                CheckFalse(a.Equals(b));
                CheckFalse(b.Equals(a));
            }

            public void EqualsOperator_UnequalReals()
            {
                var a = new Complex(4, 5);
                var b = new Complex(3, 5);

                CheckFalse(a == b);
                CheckFalse(b == a);
            }

            public void UnequalOperator_UnequalReals()
            {
                var a = new Complex(4, 5);
                var b = new Complex(3, 5);

                Check(a != b);
                Check(a != b);
            }

            public void UnequalImaginaries()
            {
                var a = new Complex(4, 5);
                var b = new Complex(4, 6);

                CheckFalse(a.Equals(b));
                CheckFalse(b.Equals(a));
            }

            public void EqualsOperator_UnequalImaginaries()
            {
                var a = new Complex(4, 5);
                var b = new Complex(4, 6);

                CheckFalse(a == b);
                CheckFalse(b == a);
            }

            public void UnequalOperator_UnequalImaginaries()
            {
                var a = new Complex(4, 5);
                var b = new Complex(4, 6);

                Check(a != b);
                Check(a != b);
            }

            public void EqualsObject()
            {
                var a = new Complex(4, 5);

                CheckFalse(a.Equals(null));
            }

            public void EqualsObject_Equal()
            {
                var a = new Complex(4, 5);
                object b = new Complex(4, 5);

                Check(a.Equals(b));
            }

            public void EqualsObject_Unequal()
            {
                var a = new Complex(4, 5);
                object b = new Complex(4, 6);

                CheckFalse(a.Equals(b));
            }
        }

        public class ToStringTests : UnitTestSharp.TestFixture
        {
            public void Zero()
            {
                var complex = new Complex();
                CheckEqual("0", complex.ToString());
            }

            public void One()
            {
                var complex = new Complex(1, 0);
                CheckEqual("1", complex.ToString());
            }

            public void NegativeOne()
            {
                var complex = new Complex(-1, 0);
                CheckEqual("-1", complex.ToString());
            }

            public void NegativeI()
            {
                var complex = new Complex(0, -1);
                CheckEqual("-i", complex.ToString());
            }

            public void I()
            {
                var complex = new Complex(0, 1);
                CheckEqual("i", complex.ToString());
            }

            public void NegativeTwoI()
            {
                var complex = new Complex(0, -2);
                CheckEqual("-2i", complex.ToString());
            }

            public void TwoI()
            {
                var complex = new Complex(0, 2);
                CheckEqual("2i", complex.ToString());
            }

            public void BasicPositive()
            {
                var complex = new Complex(3, 4);
                CheckEqual("(3 + 4i)", complex.ToString());
            }

            public void BasicNegative()
            {
                var complex = new Complex(-3, -4);
                CheckEqual("(-3 - 4i)", complex.ToString());
            }
        }

        public class BitsToHexCodeTests : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var complex = new Complex(3, 4);
                CheckEqual("(0x4008000000000000 + 0x4010000000000000i)", Complex.BitsToHexCode(complex));
            }
        }

        public class TryParse : UnitTestSharp.TestFixture
        {
            public void ParseReal()
            {
                Check(Complex.TryParse("3", out Complex result));
                CheckEqual(3, result);
            }

            public void ParseRealParantheses()
            {
                Check(Complex.TryParse("(3)", out Complex result));
                CheckEqual(3, result);
            }

            public void ParseImaginary()
            {
                Check(Complex.TryParse("3i", out Complex result));
                CheckEqual(new Complex(0, 3), result);
            }

            public void ParseImaginaryParantheses()
            {
                Check(Complex.TryParse("(3i)", out Complex result));
                CheckEqual(new Complex(0, 3), result);
            }

            public void ParseFullPositive()
            {
                Check(Complex.TryParse("(3 + 4i)", out Complex result));
                CheckEqual(new Complex(3, 4), result);
            }

            public void ParseFullNegative()
            {
                Check(Complex.TryParse("(-3 - 4i)", out Complex result));
                CheckEqual(new Complex(-3, -4), result);
            }

            public void Bits()
            {
                Check(Complex.TryParse("(0x4008000000000000 + 0x4010000000000000i)", out Complex result));
                CheckEqual(new Complex(3, 4), result);
            }

            public void MixedBitsAndText()
            {
                Check(Complex.TryParse("(0x4008000000000000 + 4i)", out Complex result));
                CheckEqual(new Complex(3, 4), result);
            }

            public void BadDataReal()
            {
                Complex.TryParse("(yes - i)", out _);
            }

            public void BadDataImaginary()
            {
                Complex.TryParse("(-3 - yesi)", out _);
            }
        }

        public class Parse : UnitTestSharp.TestFixture
        {
            public void CanParse()
            {
                Complex complex = Complex.Parse("3 + 4i");
                CheckEqual(new Complex(3, 4), complex);
            }

            public void CannotParse()
            {
                CheckThrow(typeof(ArgumentException));
                Complex.Parse("tes + 4i");
            }
        }

        public class ToFromTuple : UnitTestSharp.TestFixture
        {
            public void FromTuple()
            {
                Complex complex = (3, 4);

                CheckEqual(new Complex(3, 4), complex);
            }

            public void ToTuple()
            {
                var (real, imaginary) = new Complex(3, 4);
                CheckEqual(3, real);
                CheckEqual(4, imaginary);
            }

            public void EqualityToTuple()
            {
                var complex = new Complex(3, 4);
                Check(complex.Equals((3, 4)));
            }

            public void EqualityToStringTuple()
            {
                var complex = new Complex(3, 4);
                CheckFalse(complex.Equals(("three", "four")));
            }

            private struct TestStruct { }

            public void EqualityToStructTuple()
            {
                var complex = new Complex(3, 4);
                CheckFalse(complex.Equals((new TestStruct(), new TestStruct())));
            }
        }
    }
}