using System;
using Glass.UnitTests.Typesetting;
using UnitTestSharp;

namespace Glass.UnitTests
{
    public class FontFamilyTests : TestFixture
    {
        private static SpriteFontDefinition Face(int letterWidth = 10, string page = "family.png") =>
            FacedMeasuringTests.Face(letterWidth, page: page);

        private static FontFamily FamilyOf(Type holder, string fieldName) =>
            FontFamily.FromField(holder.GetField(fieldName));

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

            public void RegularAlone_LeavesTheOthersOut()
            {
                SpriteFontDefinition regular = Face();

                var family = new FontFamily(regular);

                CheckTrue(ReferenceEquals(regular, family.Regular));
                CheckNull(family.Bold);
                CheckNull(family.Italic);
                CheckNull(family.BoldItalic);
            }

            public void Faces_AreKept()
            {
                SpriteFontDefinition regular = Face(10);
                SpriteFontDefinition bold = Face(11);
                SpriteFontDefinition italic = Face(12);
                SpriteFontDefinition boldItalic = Face(13);

                var family = new FontFamily(regular, bold, italic, boldItalic);

                CheckTrue(ReferenceEquals(bold, family.Bold));
                CheckTrue(ReferenceEquals(italic, family.Italic));
                CheckTrue(ReferenceEquals(boldItalic, family.BoldItalic));
            }

            public void EveryFace_IsToldItsFamily()
            {
                SpriteFontDefinition regular = Face(10);
                SpriteFontDefinition bold = Face(11);
                SpriteFontDefinition italic = Face(12);
                SpriteFontDefinition boldItalic = Face(13);

                var family = new FontFamily(regular, bold, italic, boldItalic);

                CheckTrue(ReferenceEquals(family, regular.Family));
                CheckTrue(ReferenceEquals(family, bold.Family));
                CheckTrue(ReferenceEquals(family, italic.Family));
                CheckTrue(ReferenceEquals(family, boldItalic.Family));
            }

            public void BoldOnAnotherPage_Throws()
            {
                SpriteFontDefinition regular = Face();
                SpriteFontDefinition bold = Face(page: "other.png");

                CheckThrow(typeof(ArgumentException));
                new FontFamily(regular, bold);
            }

            public void ItalicOnAnotherPage_Throws()
            {
                SpriteFontDefinition regular = Face();
                SpriteFontDefinition italic = Face(page: "other.png");

                CheckThrow(typeof(ArgumentException));
                new FontFamily(regular, italic: italic);
            }

            public void BoldItalicOnAnotherPage_Throws()
            {
                SpriteFontDefinition regular = Face();
                SpriteFontDefinition boldItalic = Face(page: "other.png");

                CheckThrow(typeof(ArgumentException));
                new FontFamily(regular, boldItalic: boldItalic);
            }

            public void AFaceAlreadyInAFamily_Throws()
            {
                SpriteFontDefinition taken = Face();
                new FontFamily(taken);

                CheckThrow(typeof(InvalidOperationException));
                new FontFamily(Face(), bold: taken);
            }

            public void AFaceAlreadyInAFamily_LeavesTheOthersWithoutOne()
            {
                SpriteFontDefinition taken = Face();
                new FontFamily(taken);
                SpriteFontDefinition regular = Face();

                try
                {
                    new FontFamily(regular, bold: Face(), italic: taken);
                }
                catch (InvalidOperationException)
                {
                }

                CheckNull(regular.Family);
            }
        }

        public class IsBoldTests : TestFixture
        {
            private static FontFamily Complete(out SpriteFontDefinition[] faces)
            {
                faces = new[] { Face(10), Face(11), Face(12), Face(13) };
                return new FontFamily(faces[0], faces[1], faces[2], faces[3]);
            }

            public void TheBoldFaces_Are()
            {
                FontFamily family = Complete(out SpriteFontDefinition[] faces);

                CheckTrue(family.IsBold(faces[1]));
                CheckTrue(family.IsBold(faces[3]));
            }

            public void TheOtherFaces_Arent()
            {
                FontFamily family = Complete(out SpriteFontDefinition[] faces);

                CheckFalse(family.IsBold(faces[0]));
                CheckFalse(family.IsBold(faces[2]));
            }

            public void AFontOfNoFamily_Isnt()
            {
                CheckFalse(Complete(out _).IsBold(Face()));
            }

            public void NoFont_Isnt()
            {
                CheckFalse(new FontFamily(Face()).IsBold(null));
            }
        }

        public class IsItalicTests : TestFixture
        {
            private static FontFamily Complete(out SpriteFontDefinition[] faces)
            {
                faces = new[] { Face(10), Face(11), Face(12), Face(13) };
                return new FontFamily(faces[0], faces[1], faces[2], faces[3]);
            }

            public void TheItalicFaces_Are()
            {
                FontFamily family = Complete(out SpriteFontDefinition[] faces);

                CheckTrue(family.IsItalic(faces[2]));
                CheckTrue(family.IsItalic(faces[3]));
            }

            public void TheOtherFaces_Arent()
            {
                FontFamily family = Complete(out SpriteFontDefinition[] faces);

                CheckFalse(family.IsItalic(faces[0]));
                CheckFalse(family.IsItalic(faces[1]));
            }

            public void NoFont_Isnt()
            {
                CheckFalse(new FontFamily(Face()).IsItalic(null));
            }
        }

        public class FaceForTests : TestFixture
        {
            public void EachCombination_IsItsFace()
            {
                SpriteFontDefinition[] faces = { Face(10), Face(11), Face(12), Face(13) };
                var family = new FontFamily(faces[0], faces[1], faces[2], faces[3]);

                CheckTrue(ReferenceEquals(faces[0], family.FaceFor(bold: false, italic: false)));
                CheckTrue(ReferenceEquals(faces[1], family.FaceFor(bold: true, italic: false)));
                CheckTrue(ReferenceEquals(faces[2], family.FaceFor(bold: false, italic: true)));
                CheckTrue(ReferenceEquals(faces[3], family.FaceFor(bold: true, italic: true)));
            }

            public void AMissingFace_IsNull()
            {
                var family = new FontFamily(Face());

                CheckNull(family.FaceFor(bold: true, italic: false));
                CheckNull(family.FaceFor(bold: false, italic: true));
                CheckNull(family.FaceFor(bold: true, italic: true));
            }
        }

        public static class CompleteFields
        {
            [Font("regular.fnt", Bold = nameof(BoldFace), Italic = nameof(ItalicFace),
                BoldItalic = nameof(BoldItalicFace))]
            public static SpriteFontDefinition Regular;
            public static SpriteFontDefinition BoldFace;
            public static SpriteFontDefinition ItalicFace;
            public static SpriteFontDefinition BoldItalicFace;
        }

        public static class BoldOnlyFields
        {
            [Font("regular.fnt", Bold = nameof(BoldFace))]
            public static SpriteFontDefinition Regular;
            public static SpriteFontDefinition BoldFace;
        }

        public static class NoFacesFields
        {
            [Font("regular.fnt")]
            public static SpriteFontDefinition Regular;

            public static SpriteFontDefinition Unattributed;
        }

        public static class MissingFieldFields
        {
            [Font("regular.fnt", Bold = "NoSuchField")]
            public static SpriteFontDefinition Regular;
        }

        public static class UnloadedFaceFields
        {
            [Font("regular.fnt", Bold = nameof(BoldFace))]
            public static SpriteFontDefinition Regular;
            public static SpriteFontDefinition BoldFace;
        }

        public static class UnloadedRegularFields
        {
            [Font("regular.fnt", Bold = nameof(BoldFace))]
            public static SpriteFontDefinition Regular;
            public static SpriteFontDefinition BoldFace;
        }

        public class FromFieldTests : TestFixture
        {
            public void AllFacesNamed_MakeAFamilyOfThem()
            {
                CompleteFields.Regular = Face(10);
                CompleteFields.BoldFace = Face(11);
                CompleteFields.ItalicFace = Face(12);
                CompleteFields.BoldItalicFace = Face(13);

                FontFamily family = FamilyOf(typeof(CompleteFields), nameof(CompleteFields.Regular));

                CheckTrue(ReferenceEquals(CompleteFields.Regular, family.Regular));
                CheckTrue(ReferenceEquals(CompleteFields.BoldFace, family.Bold));
                CheckTrue(ReferenceEquals(CompleteFields.ItalicFace, family.Italic));
                CheckTrue(ReferenceEquals(CompleteFields.BoldItalicFace, family.BoldItalic));
                CheckTrue(ReferenceEquals(family, CompleteFields.BoldFace.Family));
            }

            public void OnlyBoldNamed_LeavesTheOthersOut()
            {
                BoldOnlyFields.Regular = Face(10);
                BoldOnlyFields.BoldFace = Face(11);

                FontFamily family = FamilyOf(typeof(BoldOnlyFields), nameof(BoldOnlyFields.Regular));

                CheckTrue(ReferenceEquals(BoldOnlyFields.BoldFace, family.Bold));
                CheckNull(family.Italic);
                CheckNull(family.BoldItalic);
            }

            public void NoFacesNamed_MakesNoFamily()
            {
                NoFacesFields.Regular = Face();

                CheckNull(FamilyOf(typeof(NoFacesFields), nameof(NoFacesFields.Regular)));
                CheckNull(NoFacesFields.Regular.Family);
            }

            public void NoAttribute_MakesNoFamily()
            {
                NoFacesFields.Unattributed = Face();

                CheckNull(FamilyOf(typeof(NoFacesFields), nameof(NoFacesFields.Unattributed)));
            }

            public void AFaceNamedByAFieldThatDoesntExist_Throws()
            {
                MissingFieldFields.Regular = Face();

                CheckThrow(typeof(InvalidOperationException));
                FamilyOf(typeof(MissingFieldFields), nameof(MissingFieldFields.Regular));
            }

            public void AFaceNamedByAFieldHoldingNoFont_Throws()
            {
                UnloadedFaceFields.Regular = Face();
                UnloadedFaceFields.BoldFace = null;

                CheckThrow(typeof(InvalidOperationException));
                FamilyOf(typeof(UnloadedFaceFields), nameof(UnloadedFaceFields.Regular));
            }

            public void ARegularFieldHoldingNoFont_Throws()
            {
                UnloadedRegularFields.Regular = null;
                UnloadedRegularFields.BoldFace = Face();

                CheckThrow(typeof(InvalidOperationException));
                FamilyOf(typeof(UnloadedRegularFields), nameof(UnloadedRegularFields.Regular));
            }
        }
    }
}