using System;
using Azimuth;
using Prism;
using UnitTestSharp;

namespace Konis.UnitTests
{
    public class StandardEmitterDefTests : TestFixture
    {
        private static GradientDef WhiteTint()
        {
            return new GradientDef { Gradient = Gradient.Constant(Colors.White) };
        }

        public class DefaultsTests : TestFixture
        {
            public void LifetimeAndSizeAreOne()
            {
                var def = new StandardEmitterDef();

                CheckEqual(1.0, def.Lifetime.Minimum.Value);
                CheckEqual(1.0, def.Lifetime.Maximum.Value);
                CheckEqual(1.0, def.Size.Minimum.Value);
                CheckEqual(1.0, def.Size.Maximum.Value);
            }

            public void EverythingElseIsEmptyOrNull()
            {
                var def = new StandardEmitterDef();

                CheckTrue(def.Speed.IsEmpty);
                CheckTrue(def.Heading.IsEmpty);
                CheckTrue(def.Elevation.IsEmpty);
                CheckTrue(def.AngularVelocity.IsEmpty);
                CheckTrue(def.Gravity.IsEmpty);
                CheckTrue(def.Drag.IsEmpty);
                CheckNull(def.SizeOverLife);
                CheckNull(def.AlphaOverLife);
                CheckNull(def.TintOverLife);
            }

            public void UpIsZ()
            {
                CheckEqual(Axis.Z, new StandardEmitterDef().Up);
            }

            public void ANumberGivenForAVariation_DrawsThatNumber()
            {
                var def = new StandardEmitterDef { Speed = 30 };

                CheckEqual(30.0, def.Speed.Minimum.Value);
                CheckEqual(30.0, def.Speed.Maximum.Value);
            }
        }

        public class ValidateTests : TestFixture
        {
            private static StandardEmitterDef Working()
            {
                return new StandardEmitterDef { Capacity = 10, TintOverLife = WhiteTint() };
            }

            public void WithACapacityAndATint_Passes()
            {
                Working().Validate();
            }

            public void WithEveryValueSet_Passes()
            {
                new StandardEmitterDef
                {
                    Capacity = 10,
                    Lifetime = new Variation(1, 2),
                    Speed = new Variation(0, 5),
                    Heading = new Variation(0, 1),
                    Elevation = Variation.PlusOrMinus(0.1),
                    AngularVelocity = Variation.PlusOrMinus(2),
                    Size = new Variation(0.5, 1),
                    Rate = 20,
                    Lifespan = 3,
                    Gravity = -9.8,
                    Drag = 0.5,
                    SizeOverLife = new PiecewiseLinear((0, 0), (1, 1)).Evaluate,
                    AlphaOverLife = age => 1 - age,
                    TintOverLife = WhiteTint(),
                }.Validate();
            }

            public void AnUpThatIsNotAnAxis_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                new StandardEmitterDef { Capacity = 10, TintOverLife = WhiteTint(), Up = (Axis)7 }.Validate();
            }

            public void AnyOfTheThreeAxesAsUp_Passes()
            {
                new StandardEmitterDef { Capacity = 10, TintOverLife = WhiteTint(), Up = Axis.X }.Validate();
                new StandardEmitterDef { Capacity = 10, TintOverLife = WhiteTint(), Up = Axis.Y }.Validate();
            }

            public void ACapacityOfZero_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                new StandardEmitterDef { TintOverLife = WhiteTint() }.Validate();
            }

            public void ANegativeCapacity_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                new StandardEmitterDef { Capacity = -1, TintOverLife = WhiteTint() }.Validate();
            }

            public void WithoutATint_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                new StandardEmitterDef { Capacity = 10 }.Validate();
            }

            public void ATintWithoutAGradient_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                new StandardEmitterDef { Capacity = 10, TintOverLife = new GradientDef() }.Validate();
            }

            public void ALifetimeThatReachesZero_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                new StandardEmitterDef { Capacity = 10, TintOverLife = WhiteTint(), Lifetime = new Variation(0, 1) }
                    .Validate();
            }

            public void ASizeThatReachesZero_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                new StandardEmitterDef { Capacity = 10, TintOverLife = WhiteTint(), Size = new Variation(0, 1) }
                    .Validate();
            }

            public void ASpeedBelowZero_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                new StandardEmitterDef { Capacity = 10, TintOverLife = WhiteTint(), Speed = new Variation(-1, 1) }
                    .Validate();
            }

            public void ADragBelowZero_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                new StandardEmitterDef { Capacity = 10, TintOverLife = WhiteTint(), Drag = new Variation(-1, 1) }
                    .Validate();
            }

            public void ASizeOverLifeThatIsNotANumberAtOneAge_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                new StandardEmitterDef
                {
                    Capacity = 10,
                    TintOverLife = WhiteTint(),
                    SizeOverLife = age => age == 0.5 ? double.NaN : 1,
                }.Validate();
            }

            public void AnAlphaOverLifeThatIsInfiniteAtOneAge_Throws()
            {
                CheckThrow(typeof(InvalidOperationException));
                new StandardEmitterDef
                {
                    Capacity = 10,
                    TintOverLife = WhiteTint(),
                    AlphaOverLife = age => age == 1 ? double.PositiveInfinity : 1,
                }.Validate();
            }
        }
    }
}