using System;
using System.Linq;
using Glass.Typesetting;
using UnitTestSharp;
using static Glass.Typesetting.LineBreakClass;
using static Glass.Typesetting.LineBreakClassSetTable;

namespace Glass.UnitTests.Typesetting
{
    public class LineBreakClassSetTableTests : TestFixture
    {
        public static LineBreakClass[] AllClasses =>
            Enum.GetValues(typeof(LineBreakClass)).Cast<LineBreakClass>().ToArray();

        /// <summary>
        /// Every value the table has room for: the classes, the sentinels, and the unused values between them.
        /// </summary>
        public static LineBreakClass[] AllValues =>
            Enumerable.Range(0, 64).Select(value => (LineBreakClass)value).ToArray();

        public static string Describe(params LineBreakClass[] members)
        {
            return string.Join(" ", members.OrderBy(member => member).Select(member => member.ToString()));
        }

        public class StartOfTextTests : TestFixture
        {
            public void IsNoClass()
            {
                CheckFalse(AllClasses.Contains(StartOfText));
            }
        }

        public class EndOfTextTests : TestFixture
        {
            public void IsNoClass()
            {
                CheckFalse(AllClasses.Contains(EndOfText));
            }
        }

        public class IsTests : TestFixture
        {
            public void ClassInTheSet_IsTrue()
            {
                CheckTrue(HL.Is(LineBreakClassSets.Alphabetic));
            }

            public void ClassOutsideTheSet_IsFalse()
            {
                CheckFalse(NU.Is(LineBreakClassSets.Alphabetic));
            }

            public void ClassInAnyOfSeveralSets_IsTrue()
            {
                CheckTrue(HY.Is(LineBreakClassSets.Alphabetic | LineBreakClassSets.Hyphen));
            }

            public void NoSets_IsFalse()
            {
                CheckFalse(AL.Is(LineBreakClassSets.None));
            }
        }

        public class SetsOfTests : TestFixture
        {
            [IgnoreTest]
            private void CheckMembers(LineBreakClassSets set, params LineBreakClass[] expected)
            {
                LineBreakClass[] actual = AllValues.Where(value => (SetsOf(value) & set) != 0).ToArray();
                CheckEqual(Describe(expected), Describe(actual));
            }

            public void UnusedValues_BelongToNoSet()
            {
                var unused = AllValues.Where(value => !AllClasses.Contains(value) && value != StartOfText
                    && value != EndOfText);
                CheckEqual(14, unused.Count());
                CheckTrue(unused.All(value => SetsOf(value) == LineBreakClassSets.None));
            }

            public void HardBreak_HoldsBKCRLFNL()
            {
                CheckMembers(LineBreakClassSets.HardBreak, BK, CR, LF, NL);
            }

            public void Trailing_HoldsSPBKCRLFNL()
            {
                CheckMembers(LineBreakClassSets.Trailing, BK, CR, LF, NL, SP);
            }

            public void HardBreakOrSpace_HoldsBKCRLFNLSPZW()
            {
                CheckMembers(LineBreakClassSets.HardBreakOrSpace, BK, CR, LF, NL, SP, ZW);
            }

            public void AbsorbsCombiningMarks_HoldsEveryClassButBKCRLFNLSPZW()
            {
                CheckMembers(LineBreakClassSets.AbsorbsCombiningMarks,
                    AllClasses.Except(new[] { BK, CR, LF, NL, SP, ZW }).ToArray());
            }

            public void CombiningMark_HoldsCMZWJ()
            {
                CheckMembers(LineBreakClassSets.CombiningMark, CM, ZWJ);
            }

            public void SpaceOrHyphen_HoldsSPHYHHSoftHyphen()
            {
                CheckMembers(LineBreakClassSets.SpaceOrHyphen, SP, HY, HH, SoftHyphen);
            }

            public void ClosedBefore_HoldsCLCPEXSY()
            {
                CheckMembers(LineBreakClassSets.ClosedBefore, CL, CP, EX, SY);
            }

            public void Lb15aOpener_HoldsStartOfTextBKCRLFNLOPQUGLSPZW()
            {
                CheckMembers(LineBreakClassSets.Lb15aOpener,
                    StartOfText, BK, CR, LF, NL, OP, QU, QU_Pi, QU_Pf, GL, SP, ZW);
            }

            public void Lb15bFollower_HoldsSPGLWJCLQUCPEXISSYBKCRLFNLZWEndOfText()
            {
                CheckMembers(LineBreakClassSets.Lb15bFollower,
                    SP, GL, WJ, CL, QU, QU_Pi, QU_Pf, CP, EX, IS, SY, BK, CR, LF, NL, ZW, EndOfText);
            }

            public void Closing_HoldsCLCP()
            {
                CheckMembers(LineBreakClassSets.Closing, CL, CP);
            }

            public void NonInitialQuotation_HoldsQUButNotPi()
            {
                CheckMembers(LineBreakClassSets.NonInitialQuotation, QU, QU_Pf);
            }

            public void NonFinalQuotation_HoldsQUButNotPf()
            {
                CheckMembers(LineBreakClassSets.NonFinalQuotation, QU, QU_Pi);
            }

            public void Quotation_HoldsEveryQU()
            {
                CheckMembers(LineBreakClassSets.Quotation, QU, QU_Pi, QU_Pf);
            }

            public void Lb20aPreceding_HoldsStartOfTextBKCRLFNLSPZWCBGL()
            {
                CheckMembers(LineBreakClassSets.Lb20aPreceding, StartOfText, BK, CR, LF, NL, SP, ZW, CB, GL);
            }

            public void Hyphen_HoldsHYHHSoftHyphen()
            {
                CheckMembers(LineBreakClassSets.Hyphen, HY, HH, SoftHyphen);
            }

            public void Alphabetic_HoldsALHLDottedCircle()
            {
                CheckMembers(LineBreakClassSets.Alphabetic, AL, HL, DottedCircle);
            }

            public void Lb21Follower_HoldsBAHHHYNSSoftHyphen()
            {
                CheckMembers(LineBreakClassSets.Lb21Follower, BA, HH, HY, NS, SoftHyphen);
            }

            public void IdeographicOrEmoji_HoldsIDEBEM()
            {
                CheckMembers(LineBreakClassSets.IdeographicOrEmoji, ID, EB, EM);
            }

            public void Affix_HoldsPRPO()
            {
                CheckMembers(LineBreakClassSets.Affix, PR, PO);
            }

            public void Lb25BeforeNumber_HoldsPRPOHYIS()
            {
                CheckMembers(LineBreakClassSets.Lb25BeforeNumber, PR, PO, HY, IS);
            }

            public void NumberInfix_HoldsSYIS()
            {
                CheckMembers(LineBreakClassSets.NumberInfix, SY, IS);
            }

            public void Lb26AfterLeading_HoldsJLJVH2H3()
            {
                CheckMembers(LineBreakClassSets.Lb26AfterLeading, JL, JV, H2, H3);
            }

            public void EndsInVowel_HoldsJVH2()
            {
                CheckMembers(LineBreakClassSets.EndsInVowel, JV, H2);
            }

            public void Lb26AfterVowel_HoldsJVJT()
            {
                CheckMembers(LineBreakClassSets.Lb26AfterVowel, JV, JT);
            }

            public void EndsInTrailing_HoldsJTH3()
            {
                CheckMembers(LineBreakClassSets.EndsInTrailing, JT, H3);
            }

            public void KoreanSyllable_HoldsJLJVJTH2H3()
            {
                CheckMembers(LineBreakClassSets.KoreanSyllable, JL, JV, JT, H2, H3);
            }

            public void AksaraStart_HoldsAKASDottedCircle()
            {
                CheckMembers(LineBreakClassSets.AksaraStart, AK, AS, DottedCircle);
            }

            public void Lb28aAfterVirama_HoldsAKDottedCircle()
            {
                CheckMembers(LineBreakClassSets.Lb28aAfterVirama, AK, DottedCircle);
            }

            public void Virama_HoldsVFVI()
            {
                CheckMembers(LineBreakClassSets.Virama, VF, VI);
            }

            public void Alphanumeric_HoldsALHLNUDottedCircle()
            {
                CheckMembers(LineBreakClassSets.Alphanumeric, AL, HL, NU, DottedCircle);
            }

            public void SeenPastSpaces_HoldsZWOPCLCPB2()
            {
                CheckMembers(LineBreakClassSets.SeenPastSpaces, ZW, OP, CL, CP, B2);
            }
        }
    }
}