using System;
using System.Collections.Generic;
using Glass.Typesetting;
using UnitTestSharp;

namespace Glass.UnitTests.Typesetting
{
    public class KerningClassifierTests : TestFixture
    {
        private static Dictionary<char, List<(char Other, short Amount)>> Rows(
            params (char Glyph, (char Other, short Amount)[] Entries)[] rows)
        {
            var result = new Dictionary<char, List<(char Other, short Amount)>>();
            foreach ((char glyph, (char Other, short Amount)[] entries) in rows)
            {
                result[glyph] = new List<(char, short)>(entries);
            }
            return result;
        }

        public class BuildTests : TestFixture
        {
            public void NullRows_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                KerningClassifier.Build(null);
            }

            public void EmptyRows_OnlyHasTheReservedNoneClass()
            {
                KerningClassifier classifier = KerningClassifier.Build(Rows());
                CheckEqual(1, classifier.Count);
            }

            public void TwoGlyphsWithIdenticalRows_ShareAClass()
            {
                KerningClassifier classifier = KerningClassifier.Build(Rows(
                    ('A', new[] { ('V', (short)-2), ('W', (short)-1) }),
                    ('B', new[] { ('V', (short)-2), ('W', (short)-1) })));

                CheckEqual(classifier.ClassOf('A'), classifier.ClassOf('B'));
            }

            public void TwoGlyphsWithDifferentRows_GetDifferentClasses()
            {
                KerningClassifier classifier = KerningClassifier.Build(Rows(
                    ('A', new[] { ('V', (short)-2) }),
                    ('B', new[] { ('V', (short)-3) })));

                Check(classifier.ClassOf('A') != classifier.ClassOf('B'));
            }

            public void RowOrderDoesNotAffectGrouping()
            {
                KerningClassifier classifier = KerningClassifier.Build(Rows(
                    ('A', new[] { ('V', (short)-2), ('W', (short)-1) }),
                    ('B', new[] { ('W', (short)-1), ('V', (short)-2) })));

                CheckEqual(classifier.ClassOf('A'), classifier.ClassOf('B'));
            }

            public void CountIsDistinctSignaturesPlusTheReservedNoneClass()
            {
                KerningClassifier classifier = KerningClassifier.Build(Rows(
                    ('A', new[] { ('V', (short)-2) }),
                    ('B', new[] { ('V', (short)-2) }),
                    ('C', new[] { ('V', (short)-3) })));

                CheckEqual(3, classifier.Count);
            }

            public void MoreThan255DistinctSignatures_Throws()
            {
                var rows = new (char, (char, short)[])[256];
                for (int i = 0; i < rows.Length; ++i)
                {
                    rows[i] = ((char)i, new[] { ('X', (short)i) });
                }

                CheckThrow(typeof(NotSupportedException));
                KerningClassifier.Build(Rows(rows));
            }
        }

        public class ClassOfTests : TestFixture
        {
            public void GlyphNeverSeen_IsTheReservedNoneClass()
            {
                KerningClassifier classifier = KerningClassifier.Build(Rows(('A', new[] { ('V', (short)-2) })));
                CheckEqual(KerningClass.None, classifier.ClassOf('Z'));
            }

            public void GlyphBeyondTheBuiltRange_IsTheReservedNoneClass()
            {
                KerningClassifier classifier = KerningClassifier.Build(Rows(('A', new[] { ('V', (short)-2) })));
                CheckEqual(KerningClass.None, classifier.ClassOf((char)0xFFFF));
            }

            public void EmptyClassifier_EveryGlyphIsTheReservedNoneClass()
            {
                KerningClassifier classifier = KerningClassifier.Build(Rows());
                CheckEqual(KerningClass.None, classifier.ClassOf('A'));
            }
        }
    }
}