using System;
using Glass.Typesetting;
using UnitTestSharp;

namespace Glass.UnitTests.Typesetting
{
    public class FaceRunsTests : TestFixture
    {
        public static readonly IFontMetrics Base = FacedMeasuringTests.Narrow;
        public static readonly IFontMetrics Bold = FacedMeasuringTests.Wide;
        public static readonly IFontMetrics Italic = FacedMeasuringTests.Face(letterWidth: 11);

        public class CtorTests : TestFixture
        {
            public void NullBaseFont_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                new FaceRuns(null);
            }

            public void KeepsTheBaseFont()
            {
                CheckTrue(ReferenceEquals(Base, new FaceRuns(Base).BaseFont));
            }

            public void SetsEverythingInTheBaseFont()
            {
                var faces = new FaceRuns(Base);

                CheckTrue(ReferenceEquals(Base, faces.FontAt(0)));
                CheckTrue(ReferenceEquals(Base, faces.FontAt(1000)));
            }
        }

        public class IsUniformTests : TestFixture
        {
            public void NoRuns_IsTrue()
            {
                CheckTrue(new FaceRuns(Base).IsUniform);
            }

            public void ARunInAnotherFont_IsFalse()
            {
                var faces = new FaceRuns(Base);
                faces.Add(2, 4, Bold);

                CheckFalse(faces.IsUniform);
            }

            public void OnlyRunsInTheBaseFont_IsTrue()
            {
                var faces = new FaceRuns(Base);
                faces.Add(2, 4, Base);

                CheckTrue(faces.IsUniform);
            }

            public void AfterClearing_IsTrue()
            {
                var faces = new FaceRuns(Base);
                faces.Add(2, 4, Bold);
                faces.Clear();

                CheckTrue(faces.IsUniform);
            }
        }

        public class AddTests : TestFixture
        {
            public void ARun_SetsItsCharactersInItsFont()
            {
                var faces = new FaceRuns(Base);

                faces.Add(2, 5, Bold);

                CheckTrue(ReferenceEquals(Base, faces.FontAt(1)));
                CheckTrue(ReferenceEquals(Bold, faces.FontAt(2)));
                CheckTrue(ReferenceEquals(Bold, faces.FontAt(4)));
                CheckTrue(ReferenceEquals(Base, faces.FontAt(5)));
            }

            public void ARunFromTheStart_SetsItsCharactersInItsFont()
            {
                var faces = new FaceRuns(Base);

                faces.Add(0, 3, Bold);

                CheckTrue(ReferenceEquals(Bold, faces.FontAt(0)));
                CheckTrue(ReferenceEquals(Bold, faces.FontAt(2)));
                CheckTrue(ReferenceEquals(Base, faces.FontAt(3)));
            }

            public void RunsApart_LeaveTheBaseFontBetweenThem()
            {
                var faces = new FaceRuns(Base);

                faces.Add(1, 2, Bold);
                faces.Add(4, 6, Italic);

                CheckTrue(ReferenceEquals(Bold, faces.FontAt(1)));
                CheckTrue(ReferenceEquals(Base, faces.FontAt(2)));
                CheckTrue(ReferenceEquals(Base, faces.FontAt(3)));
                CheckTrue(ReferenceEquals(Italic, faces.FontAt(4)));
                CheckTrue(ReferenceEquals(Italic, faces.FontAt(5)));
                CheckTrue(ReferenceEquals(Base, faces.FontAt(6)));
            }

            public void RunsInDifferentFontsThatMeet_StaySeparate()
            {
                var faces = new FaceRuns(Base);

                faces.Add(1, 3, Bold);
                faces.Add(3, 5, Italic);

                CheckTrue(ReferenceEquals(Bold, faces.FontAt(2)));
                CheckTrue(ReferenceEquals(Italic, faces.FontAt(3)));
                CheckTrue(ReferenceEquals(Base, faces.FontAt(5)));
            }

            public void RunsInTheSameFontThatMeet_AreOne()
            {
                var faces = new FaceRuns(Base);

                faces.Add(1, 3, Bold);
                faces.Add(3, 5, Bold);

                CheckEqual(3, faces.Count);
                CheckTrue(ReferenceEquals(Bold, faces.FontAt(4)));
                CheckTrue(ReferenceEquals(Base, faces.FontAt(5)));
            }

            public void RunsInTheSameFontWithAGapBetween_StayApart()
            {
                var faces = new FaceRuns(Base);

                faces.Add(1, 3, Bold);
                faces.Add(4, 5, Bold);

                CheckEqual(5, faces.Count);
                CheckTrue(ReferenceEquals(Base, faces.FontAt(3)));
            }

            public void ARunInTheBaseFont_ChangesNothing()
            {
                var faces = new FaceRuns(Base);

                faces.Add(1, 3, Base);

                CheckEqual(1, faces.Count);
            }

            public void ARunInTheBaseFontBetweenOthers_StillLeavesThemApart()
            {
                var faces = new FaceRuns(Base);

                faces.Add(0, 2, Bold);
                faces.Add(2, 4, Base);
                faces.Add(4, 6, Bold);

                CheckEqual(4, faces.Count);
                CheckTrue(ReferenceEquals(Base, faces.FontAt(3)));
                CheckTrue(ReferenceEquals(Bold, faces.FontAt(4)));
            }

            public void NullFont_Throws()
            {
                var faces = new FaceRuns(Base);

                CheckThrow(typeof(ArgumentNullException));
                faces.Add(1, 3, null);
            }

            public void EmptyRun_Throws()
            {
                var faces = new FaceRuns(Base);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                faces.Add(2, 2, Bold);
            }

            public void BackwardsRun_Throws()
            {
                var faces = new FaceRuns(Base);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                faces.Add(3, 2, Bold);
            }

            public void NegativeStart_Throws()
            {
                var faces = new FaceRuns(Base);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                faces.Add(-1, 2, Bold);
            }

            public void RunOverlappingTheLast_Throws()
            {
                var faces = new FaceRuns(Base);
                faces.Add(2, 6, Bold);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                faces.Add(5, 8, Italic);
            }

            public void RunBeforeTheLast_Throws()
            {
                var faces = new FaceRuns(Base);
                faces.Add(4, 6, Bold);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                faces.Add(0, 2, Italic);
            }

            public void OverlapInTheBaseFont_StillThrows()
            {
                var faces = new FaceRuns(Base);
                faces.Add(2, 6, Bold);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                faces.Add(3, 4, Base);
            }
        }

        public class ClearTests : TestFixture
        {
            public void ForgetsEveryRun()
            {
                var faces = new FaceRuns(Base);
                faces.Add(1, 3, Bold);

                faces.Clear();

                CheckEqual(1, faces.Count);
                CheckTrue(ReferenceEquals(Base, faces.FontAt(2)));
            }

            public void LetsRunsStartOverFromTheStart()
            {
                var faces = new FaceRuns(Base);
                faces.Add(5, 8, Bold);
                faces.Clear();

                faces.Add(0, 2, Italic);

                CheckTrue(ReferenceEquals(Italic, faces.FontAt(1)));
            }

            public void KeepsTheBaseFont()
            {
                var faces = new FaceRuns(Base);
                faces.Clear();

                CheckTrue(ReferenceEquals(Base, faces.BaseFont));
            }
        }

        public class FontAtTests : TestFixture
        {
            public void BeforeTheText_IsTheFirstRunsFont()
            {
                var faces = new FaceRuns(Base);
                faces.Add(0, 2, Bold);

                CheckTrue(ReferenceEquals(Bold, faces.FontAt(-1)));
            }

            public void EveryRun_IsFoundWhateverHowManyThereAre()
            {
                var fonts = new[] { Bold, Italic, Bold, Italic, Bold, Italic, Bold };
                var faces = new FaceRuns(Base);
                for (int i = 0; i < fonts.Length; ++i)
                {
                    faces.Add(i * 3 + 1, i * 3 + 3, fonts[i]);
                }

                for (int i = 0; i < fonts.Length; ++i)
                {
                    CheckTrue(ReferenceEquals(Base, faces.FontAt(i * 3)));
                    CheckTrue(ReferenceEquals(fonts[i], faces.FontAt(i * 3 + 1)));
                    CheckTrue(ReferenceEquals(fonts[i], faces.FontAt(i * 3 + 2)));
                }
            }

            public void PastTheLastRun_IsTheBaseFont()
            {
                var faces = new FaceRuns(Base);
                faces.Add(1, 3, Bold);

                CheckTrue(ReferenceEquals(Base, faces.FontAt(int.MaxValue)));
            }
        }

        public class CountTests : TestFixture
        {
            public void CountsTheBaseFontStretchesBetweenAndAfterRuns()
            {
                var faces = new FaceRuns(Base);

                faces.Add(2, 5, Bold);

                CheckEqual(3, faces.Count);
            }
        }

        public class StartOfTests : TestFixture
        {
            public void IsWhereEachRunStarts()
            {
                var faces = new FaceRuns(Base);
                faces.Add(2, 5, Bold);

                CheckEqual(0, faces.StartOf(0));
                CheckEqual(2, faces.StartOf(1));
                CheckEqual(5, faces.StartOf(2));
            }
        }

        public class FontOfTests : TestFixture
        {
            public void IsTheFontOfEachRun()
            {
                var faces = new FaceRuns(Base);
                faces.Add(2, 5, Bold);

                CheckTrue(ReferenceEquals(Base, faces.FontOf(0)));
                CheckTrue(ReferenceEquals(Bold, faces.FontOf(1)));
                CheckTrue(ReferenceEquals(Base, faces.FontOf(2)));
            }
        }
    }
}