using System;
using System.Diagnostics;


/*
 * This is a complex number class I wrote to use in unity (since Unity uses MonoDevelop) 
 *  If you like my work, and found use in it, 
 *  or want to encourage more useful classes in C#.
 *  Please donate ^^
 * Bitcoin Address:  1LdyAQHXdFVqzGzah45sGKhsQ8wDE6jyci
 * Good luck and enjoy.
 * 
 */


namespace Assets.Scripts
{
    public struct Complex
    {
        

        private double _realNumber;
        private double _imaginaryNumber;

        private static readonly Random _random = new Random();

        public Double RealNumber
        {
            get { return _realNumber; }
            set { _realNumber = value; }
        }

        public Double ImaginaryNumber
        {
            get { return _imaginaryNumber; }
            set { _imaginaryNumber = value; }
        }

        public Complex(double real, double imaginary)
        {
            _realNumber = real;
            _imaginaryNumber = imaginary;
        }

        public Complex(Complex z)
        {
            _realNumber = z._realNumber;
            _imaginaryNumber = z._imaginaryNumber;
        }

        public void ComplexNumber(double real, double imaginary)
        {
            _realNumber = real;
            _imaginaryNumber = imaginary;
        }

        public static Complex Random()
        {
            var z = new Complex
            {
                RealNumber = _random.NextDouble(),
                ImaginaryNumber = _random.NextDouble()
            };
            return z;
        }

        public static Complex Random(Double lowNumber)
        {
            return Random(lowNumber, 0);
        }

        public static Complex Random(Double lowNumber, Double highNumber)
        {
            var z = new Complex();
            var range = highNumber - lowNumber;
            z.RealNumber = lowNumber + range*_random.NextDouble();
            z.ImaginaryNumber = lowNumber + range*_random.NextDouble();
            return z;
        }

        public static Complex operator +(Complex z1, Complex z2)
        {
            return new Complex(z1.RealNumber + z2.RealNumber, z1.ImaginaryNumber + z2.ImaginaryNumber);
        }

        public static Complex operator -(Complex z1, Complex z2)
        {
            return new Complex(z1.RealNumber - z2.RealNumber, z1.ImaginaryNumber - z2.ImaginaryNumber);
        }

        public static Complex operator -(Complex z)
        {
            z.RealNumber = -z.RealNumber;
            z.ImaginaryNumber = -z.ImaginaryNumber;
            return z;
        }

        public static Complex operator *(Complex z1, Complex z2)
        {
            return new Complex(
                z1.RealNumber * z2.RealNumber - z1.ImaginaryNumber *z2.ImaginaryNumber,
                z1.RealNumber * z2.ImaginaryNumber + z2.ImaginaryNumber * z2.RealNumber
                );
        }

        static public Complex operator *(Complex z, double dval)
        {
            var z2 = new Complex 
            {
                RealNumber = (z.RealNumber*dval),
                ImaginaryNumber = (z.ImaginaryNumber*dval)
            };
            return z2;
        }

        static public Complex operator *( double dval, Complex z)
        {
            var z2 = new Complex
            {
                RealNumber = (z.RealNumber * dval),
                ImaginaryNumber = (z.ImaginaryNumber * dval)
            };
            return z2;
        }

        public static Complex operator /(Complex z1, Complex z2)
        {
            var value = z2.RealNumber*z2.RealNumber + z2.ImaginaryNumber*z2.ImaginaryNumber;

            return new Complex(
                (z1.RealNumber * z2.RealNumber + z1.ImaginaryNumber * z2.ImaginaryNumber)/value,
                (z1.ImaginaryNumber * z2.RealNumber + z1.RealNumber * z2.ImaginaryNumber)/value
                );
        }

        static public Complex operator /(Complex z, double dval)
        {
            var z2 = new Complex
            {
                RealNumber = z.RealNumber/dval,
                ImaginaryNumber = z.ImaginaryNumber/dval
            };
            return z2;
        }

        public static bool operator ==(Complex z1, Complex z2)
        {
            return (z1.RealNumber == z2.RealNumber && z1.ImaginaryNumber == z2.ImaginaryNumber);
        }

        public static bool operator !=(Complex z1, Complex z2)
        {
            return !(z1 == z2);
        }

        public Complex Conjugate
        {
            get { return new Complex(_realNumber, -_imaginaryNumber); }
        }

        public double Norm
        {
            get { return Math.Sqrt(_realNumber * _realNumber + _imaginaryNumber * _imaginaryNumber); }
        }

        public double AbsoluteSquare
        {
            get { return (this * Conjugate).RealNumber; }

        }

        public double Modulus
        {
            get { return Math.Sqrt(_realNumber * _realNumber + _imaginaryNumber * _imaginaryNumber); }
        }

        public double Argument
        {
            get { return Math.Atan2(_imaginaryNumber, _realNumber); }
        }

        public static Complex Polar(double modulus, double argument)
        {
            return new Complex(
               modulus * Math.Cos(argument),
               modulus * Math.Sin(argument));
        }
        
        public static Complex Exp(Complex z)
        {
            var value = Math.Exp(z.RealNumber);

            return new Complex(
               value * Math.Cos(z.ImaginaryNumber),
               value * Math.Sin(z.ImaginaryNumber));
        }

        public static Complex Log(Complex z)
        {
            return new Complex(Math.Log(z.Modulus), z.Argument);
        }

        public static Complex Pow(Complex baseNumber, Complex index)
        {
            return Exp(index * Log(baseNumber));
        }

        public static Complex Sqrt(Complex z)
        {
            var value = Math.Sqrt(z.RealNumber * z.RealNumber + z.ImaginaryNumber * z.ImaginaryNumber) + z.RealNumber;

            return new Complex(
               Math.Sqrt(0.5 * value),
               Math.Sqrt(0.5 / value) * z.ImaginaryNumber);
        }

        public static Complex Recip(Complex z)
        {
            if (z.RealNumber == 0.0 && z.ImaginaryNumber == 0.0)
            {
                Console.WriteLine("multiplicative inverse (reciprocal) not defined for complex zero");
                return z;
            }

            var zr = new Complex(1.0, 0.0)
            {
                RealNumber = z.RealNumber/(z.RealNumber*z.RealNumber + z.ImaginaryNumber*z.ImaginaryNumber),
                ImaginaryNumber = -z.ImaginaryNumber/(z.RealNumber*z.RealNumber + z.ImaginaryNumber*z.ImaginaryNumber)
            };

            return zr;

        }

        public Complex SetPolar(double mod, double arg)
        {
            var z = new Complex();
            var t = arg;
            z.RealNumber = mod * Math.Cos(t);
            z.ImaginaryNumber = mod * Math.Sin(t);

            return z;
        }

        public static Complex NthRoot(Complex z, long n, long k)
        {
            var mod = z.Modulus;
            var arg = z.Argument;

            var lmod = Math.Log(mod);
            var rlmod = lmod / n;
            var rmod = Math.Exp(rlmod);

            var zrn = new Complex();
            var t = arg / n + 2 * k * Math.PI / n;
            zrn.RealNumber = rmod * Math.Cos(t);
            zrn.ImaginaryNumber = rmod * Math.Sin(t);

            return zrn;

        }

        public static Complex Cos(Complex z)
        {
            var z1 = Exp(new Complex(-z.ImaginaryNumber, z.RealNumber));
            var z2 = Exp(new Complex(z.ImaginaryNumber, -z.RealNumber));

            return new Complex(0.5 * (z1.RealNumber + z2.RealNumber), 
                0.5 * (z1.ImaginaryNumber+ z2.ImaginaryNumber));
        }

        public static Complex Cosh(Complex z)
        {
            Complex z1 = Exp(z);
            Complex z2 = Exp(new Complex(-z.RealNumber, -z.ImaginaryNumber));

            return new Complex(0.5 * (z1.RealNumber + z2.RealNumber),
                0.5 * (z1.ImaginaryNumber + z2.ImaginaryNumber));
        }

        public static Complex Sin(Complex z)
        {
            Complex z1 = Exp(new Complex(-z.ImaginaryNumber, z.RealNumber));
            Complex z2 = Exp(new Complex(z.ImaginaryNumber, -z.RealNumber));

            return new Complex(0.5 * (z1.ImaginaryNumber - z2.ImaginaryNumber), 0.5 * (z2.RealNumber - z1.RealNumber));
        }

        public static Complex Sinh(Complex z)
        {
            Complex z1 = Exp(z);
            Complex z2 = Exp(new Complex(-z.RealNumber, -z.ImaginaryNumber));

            return new Complex(0.5 * (z1.RealNumber - z2.RealNumber),
                0.5 * (z1.ImaginaryNumber - z2.ImaginaryNumber));
        }

        public static Complex Tan(Complex z)
        {
            return Sin(z) / Cos(z);
        }

        public static Complex Tanh(Complex z)
        {
            return Sinh(z) / Cosh(z);
        }

        public static Complex Log10(Complex z)
        {
            const double log10 = 2.3025850929940459;

            Complex value = Log(z);

            value.RealNumber /= log10;
            value.ImaginaryNumber /= log10;

            return value;
        }

        public override string ToString()
        {
            return (String.Format("( {0},  {1} )", RealNumber, ImaginaryNumber));
        }

        public override int GetHashCode()
        {
            unchecked
            {
                return (_realNumber.GetHashCode()*397) ^ _imaginaryNumber.GetHashCode();
            }
        }

        public void Show()
        {
            Console.WriteLine(ToString());
        }

        public void ShowPolar()
        {
            Console.WriteLine("{0} * e^(i * {1})", Modulus, Argument);
        }

        public string Polar()
        {
            var z = new Complex(this);
            var s = z.Modulus + " * e^(i * " + z.Argument + ")";
            return s;
        }

        public void Dump()
        {
            Debug.WriteLine(ToString());
        }

        public void DumpPolar()
        {
            Debug.WriteLine(string.Format("{0} * e^(i * {1})", Modulus, Argument));

        }
        private double Truncate(double dval, int ndigs)
        {
            // MBP rounding algorithm
            // ndigs = number of decimal digits
            double rndfac = Math.Pow(10, ndigs);
            dval *= rndfac;
            dval = Math.Round(dval);
            dval /= rndfac;
            return dval;
        }

        public Complex Round(int ndigs)
        {
            var z = new Complex(this);
            z.RealNumber = Truncate(z.RealNumber, ndigs);
            z.ImaginaryNumber = Truncate(z.ImaginaryNumber, ndigs);
            return z;
        }


        public bool Equals(Complex other)
        {
            return _realNumber.Equals(other._realNumber) && _imaginaryNumber.Equals(other._imaginaryNumber);
        }

        public override bool Equals(object obj)
        {
            if (ReferenceEquals(null, obj)) return false;
            return obj is Complex && Equals((Complex)obj);
        }
    }

}