using System;
using Prism;
using Azimuth;
using Glass.Text;
using UnitTestSharp;

namespace Glass.UnitTests.Text
{
    public class StylesTests : TestFixture
    {
        public class CountTests : TestFixture
        {
            public void IsANumberOfKindCountWithNoLook()
            {
                StyledText styled = Styles.Count(-1234);

                CheckTrue(styled.IsNumber);
                CheckEqual(-1234L, styled.Number);
                CheckEqual(NumberKind.Count, styled.Kind);
                CheckEqual(default(TextStyle), styled.Style);
            }

            public void ATint_KeepsTheKind()
            {
                CheckEqual(NumberKind.Count, Styles.Tint(Colors.Red, Styles.Count(5)).Kind);
            }
        }

        public class PlainTests : TestFixture
        {
            public void IsANumberOfKindPlainWithNoLook()
            {
                StyledText styled = Styles.Plain(2026);

                CheckTrue(styled.IsNumber);
                CheckEqual(2026L, styled.Number);
                CheckEqual(NumberKind.Plain, styled.Kind);
                CheckEqual(default(TextStyle), styled.Style);
            }
        }

        public class FixedTests : TestFixture
        {
            public void IsAFixedNumberHoldingTheDoublesBitsAndTheDecimals()
            {
                StyledText styled = Styles.Fixed(12.345, 2);

                CheckTrue(styled.IsNumber);
                CheckEqual(NumberKind.Fixed, styled.Kind);
                CheckEqual(BitConverter.DoubleToInt64Bits(12.345), styled.Number);
                CheckEqual(2, styled.Precision);
                CheckEqual(default(TextStyle), styled.Style);
            }

            public void NaNAndInfinities_AreKeptAsTheyAre()
            {
                CheckTrue(double.IsNaN(BitConverter.Int64BitsToDouble(Styles.Fixed(double.NaN, 2).Number)));
                CheckEqual(double.PositiveInfinity,
                    BitConverter.Int64BitsToDouble(Styles.Fixed(double.PositiveInfinity, 2).Number));
                CheckEqual(double.NegativeInfinity,
                    BitConverter.Int64BitsToDouble(Styles.Fixed(double.NegativeInfinity, 2).Number));
            }

            public void NoDecimalsAndNineDecimals_AreAllowed()
            {
                CheckEqual(0, Styles.Fixed(1, 0).Precision);
                CheckEqual(9, Styles.Fixed(1, 9).Precision);
            }

            public void ANegativeDecimalCount_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Styles.Fixed(1, -1);
            }

            public void TenDecimals_Throw()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Styles.Fixed(1, 10);
            }

            public void ATint_KeepsTheValuesAndTakesTheLook()
            {
                StyledText styled = Styles.Tint(Colors.Red, Styles.Fixed(1.5, 3));

                CheckEqual(NumberKind.Fixed, styled.Kind);
                CheckEqual(BitConverter.DoubleToInt64Bits(1.5), styled.Number);
                CheckEqual(3, styled.Precision);
                CheckEqual(new TextStyle { TintColor = Colors.Red }, styled.Style);
            }
        }

        public class ScientificTests : TestFixture
        {
            public void IsAScientificNumberHoldingTheDoublesBitsAndTheDigits()
            {
                StyledText styled = Styles.Scientific(1.5e30, 3);

                CheckTrue(styled.IsNumber);
                CheckEqual(NumberKind.Scientific, styled.Kind);
                CheckEqual(BitConverter.DoubleToInt64Bits(1.5e30), styled.Number);
                CheckEqual(3, styled.Precision);
                CheckEqual(default(TextStyle), styled.Style);
            }

            public void OneAndFifteenDigits_AreAllowed()
            {
                CheckEqual(1, Styles.Scientific(1, 1).Precision);
                CheckEqual(15, Styles.Scientific(1, 15).Precision);
            }

            public void ZeroDigits_Throw()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Styles.Scientific(1, 0);
            }

            public void SixteenDigits_Throw()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Styles.Scientific(1, 16);
            }

            public void ATint_KeepsTheValuesAndTakesTheLook()
            {
                StyledText styled = Styles.Tint(Colors.Red, Styles.Scientific(2e10, 4));

                CheckEqual(NumberKind.Scientific, styled.Kind);
                CheckEqual(BitConverter.DoubleToInt64Bits(2e10), styled.Number);
                CheckEqual(4, styled.Precision);
                CheckEqual(new TextStyle { TintColor = Colors.Red }, styled.Style);
            }
        }

        public class ShortExponentTests : TestFixture
        {
            public void IsAShortExponentNumberHoldingTheDoublesBitsAndTheDigits()
            {
                StyledText styled = Styles.ShortExponent(1.5e30, 3);

                CheckTrue(styled.IsNumber);
                CheckEqual(NumberKind.ShortExponent, styled.Kind);
                CheckEqual(BitConverter.DoubleToInt64Bits(1.5e30), styled.Number);
                CheckEqual(3, styled.Precision);
                CheckEqual(default(TextStyle), styled.Style);
            }

            public void OneAndFifteenDigits_AreAllowed()
            {
                CheckEqual(1, Styles.ShortExponent(1, 1).Precision);
                CheckEqual(15, Styles.ShortExponent(1, 15).Precision);
            }

            public void ZeroDigits_Throw()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Styles.ShortExponent(1, 0);
            }

            public void SixteenDigits_Throw()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                Styles.ShortExponent(1, 16);
            }

            public void ATint_KeepsTheValuesAndTakesTheLook()
            {
                StyledText styled = Styles.Tint(Colors.Red, Styles.ShortExponent(2e10, 4));

                CheckEqual(NumberKind.ShortExponent, styled.Kind);
                CheckEqual(BitConverter.DoubleToInt64Bits(2e10), styled.Number);
                CheckEqual(4, styled.Precision);
                CheckEqual(new TextStyle { TintColor = Colors.Red }, styled.Style);
            }
        }

        public class TintTests : TestFixture
        {
            public void AString_IsGivenTheTint()
            {
                StyledText styled = Styles.Tint(Colors.Red, "abc");

                CheckEqual("abc", styled.Text);
                CheckEqual(new TextStyle { TintColor = Colors.Red }, styled.Style);
            }

            public void ANumber_IsGivenTheTint()
            {
                StyledText styled = Styles.Tint(Colors.Red, Styles.Plain(42));

                CheckEqual(42L, styled.Number);
                CheckEqual(new TextStyle { TintColor = Colors.Red }, styled.Style);
            }

            public void AnotherWrappedHole_KeepsItsOwnValuesAndGainsTheTint()
            {
                StyledText styled = Styles.Tint(Colors.Red, Styles.Gamma(2, "abc"));

                CheckEqual(new TextStyle { TintColor = Colors.Red, CoverageGamma = 2 }, styled.Style);
            }

            public void AnInnerTint_WinsOverTheOuterOne()
            {
                StyledText styled = Styles.Tint(Colors.Red, Styles.Tint(Colors.Blue, "abc"));

                CheckEqual((Color?)Colors.Blue, styled.Style.TintColor);
            }
        }

        public class TintTextureTests : TestFixture
        {
            public void AString_IsGivenTheTexture()
            {
                var texture = new TextMaterialStyleTests.FakeTexture();

                StyledText styled = Styles.TintTexture(texture, "abc");

                CheckEqual("abc", styled.Text);
                CheckTrue(ReferenceEquals(texture, styled.Style.TintTexture));
            }

            public void ANumber_IsGivenTheTexture()
            {
                var texture = new TextMaterialStyleTests.FakeTexture();

                StyledText styled = Styles.TintTexture(texture, Styles.Plain(8));

                CheckEqual(8L, styled.Number);
                CheckTrue(ReferenceEquals(texture, styled.Style.TintTexture));
            }

            public void ANullTexture_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                Styles.TintTexture(null, "abc");
            }
        }

        public class TintTransformTests : TestFixture
        {
            public void AString_IsGivenTheTransform()
            {
                StyledText styled = Styles.TintTransform(TextStyleTests.TintTransformTests.Shifted, "abc");

                CheckEqual("abc", styled.Text);
                CheckEqual((AffineMatrix?)TextStyleTests.TintTransformTests.Shifted, styled.Style.TintTransform);
            }

            public void ANumber_IsGivenTheTransform()
            {
                StyledText styled = Styles.TintTransform(TextStyleTests.TintTransformTests.Shifted, Styles.Plain(8));

                CheckEqual(8L, styled.Number);
                CheckEqual((AffineMatrix?)TextStyleTests.TintTransformTests.Shifted, styled.Style.TintTransform);
            }
        }

        public class TintSpaceTests : TestFixture
        {
            public void AString_IsGivenTheSpace()
            {
                StyledText styled = Styles.TintSpace(TintSpace.Model, "abc");

                CheckEqual("abc", styled.Text);
                CheckEqual((TintSpace?)TintSpace.Model, styled.Style.TintSpace);
            }

            public void ANumber_IsGivenTheSpace()
            {
                StyledText styled = Styles.TintSpace(TintSpace.Model, Styles.Plain(8));

                CheckEqual(8L, styled.Number);
                CheckEqual((TintSpace?)TintSpace.Model, styled.Style.TintSpace);
            }
        }

        public class GammaTests : TestFixture
        {
            public void AString_IsGivenTheGamma()
            {
                StyledText styled = Styles.Gamma(2.2, "abc");

                CheckEqual("abc", styled.Text);
                CheckEqual(new TextStyle { CoverageGamma = 2.2 }, styled.Style);
            }

            public void ANumber_IsGivenTheGamma()
            {
                StyledText styled = Styles.Gamma(0, Styles.Plain(-3));

                CheckEqual(-3L, styled.Number);
                CheckEqual((Azimuth.Scalar?)0, styled.Style.CoverageGamma);
            }
        }

        public class StrikethroughTests : TestFixture
        {
            public void AString_IsStruck()
            {
                StyledText styled = Styles.Strikethrough("abc");

                CheckEqual("abc", styled.Text);
                CheckEqual(new TextStyle { Strikethrough = true }, styled.Style);
            }

            public void ANumber_IsStruck()
            {
                StyledText styled = Styles.Strikethrough(Styles.Plain(-3));

                CheckEqual(-3L, styled.Number);
                CheckEqual((bool?)true, styled.Style.Strikethrough);
            }

            public void AnInnerNoStrikethrough_WinsOverTheOuterOne()
            {
                StyledText styled = Styles.Strikethrough(Styles.NoStrikethrough("abc"));

                CheckEqual((bool?)false, styled.Style.Strikethrough);
            }
        }

        public class BoldTests : TestFixture
        {
            public void AString_IsBold()
            {
                StyledText styled = Styles.Bold("abc");

                CheckEqual("abc", styled.Text);
                CheckEqual(new TextStyle { Bold = true }, styled.Style);
            }

            public void ANumber_IsBold()
            {
                StyledText styled = Styles.Bold(Styles.Plain(-3));

                CheckEqual(-3L, styled.Number);
                CheckEqual((bool?)true, styled.Style.Bold);
            }

            public void NestedInItalic_IsBoldItalic()
            {
                StyledText styled = Styles.Italic(Styles.Bold("abc"));

                CheckEqual(new TextStyle { Bold = true, Italic = true }, styled.Style);
            }

            public void AnInnerNoBold_WinsOverTheOuterBold()
            {
                StyledText styled = Styles.Bold(Styles.NoBold("abc"));

                CheckEqual((bool?)false, styled.Style.Bold);
            }
        }

        public class NoBoldTests : TestFixture
        {
            public void AString_IsGivenAnExplicitOff()
            {
                CheckEqual(new TextStyle { Bold = false }, Styles.NoBold("abc").Style);
            }

            public void ANumber_IsGivenAnExplicitOff()
            {
                StyledText styled = Styles.NoBold(Styles.Plain(5));

                CheckEqual(5L, styled.Number);
                CheckEqual((bool?)false, styled.Style.Bold);
            }
        }

        public class ItalicTests : TestFixture
        {
            public void AString_IsItalic()
            {
                StyledText styled = Styles.Italic("abc");

                CheckEqual("abc", styled.Text);
                CheckEqual(new TextStyle { Italic = true }, styled.Style);
            }

            public void ANumber_IsItalic()
            {
                StyledText styled = Styles.Italic(Styles.Plain(7));

                CheckEqual(7L, styled.Number);
                CheckEqual((bool?)true, styled.Style.Italic);
            }

            public void AnInnerNoItalic_WinsOverTheOuterItalic()
            {
                CheckEqual((bool?)false, Styles.Italic(Styles.NoItalic("abc")).Style.Italic);
            }
        }

        public class NoItalicTests : TestFixture
        {
            public void AString_IsGivenAnExplicitOff()
            {
                CheckEqual(new TextStyle { Italic = false }, Styles.NoItalic("abc").Style);
            }

            public void ANumber_IsGivenAnExplicitOff()
            {
                StyledText styled = Styles.NoItalic(Styles.Plain(5));

                CheckEqual(5L, styled.Number);
                CheckEqual((bool?)false, styled.Style.Italic);
            }
        }

        public class NoStrikethroughTests : TestFixture
        {
            public void AString_IsGivenAnExplicitOff()
            {
                StyledText styled = Styles.NoStrikethrough("abc");

                CheckEqual("abc", styled.Text);
                CheckEqual(new TextStyle { Strikethrough = false }, styled.Style);
            }

            public void ANumber_IsGivenAnExplicitOff()
            {
                StyledText styled = Styles.NoStrikethrough(Styles.Plain(5));

                CheckEqual(5L, styled.Number);
                CheckEqual((bool?)false, styled.Style.Strikethrough);
            }
        }
    }
}