using System;
using Glass.Typesetting;
using UnitTestSharp;

namespace Glass.UnitTests.Typesetting
{
    public class HardBreaksTests : TestFixture
    {
        public static readonly string NextLine = ((char)0x85).ToString();
        public static readonly string LineSeparator = ((char)0x2028).ToString();
        public static readonly string ParagraphSeparator = ((char)0x2029).ToString();
        public static readonly string VerticalTab = ((char)0x0B).ToString();
        public static readonly string FormFeed = ((char)0x0C).ToString();

        public class IsHardBreakTests : TestFixture
        {
            public void EveryKindOfHardBreak_Is()
            {
                foreach (string hardBreak in new[]
                {
                    "\n", "\r", NextLine, LineSeparator, ParagraphSeparator, VerticalTab, FormFeed,
                })
                {
                    Check(HardBreaks.IsHardBreak(hardBreak[0]));
                }
            }

            public void OtherCharacters_AreNot()
            {
                foreach (char character in new[] { 'a', ' ', '\t', '-', (char)0x200B, (char)0xD842 })
                {
                    CheckFalse(HardBreaks.IsHardBreak(character));
                }
            }
        }

        public class LengthAtTests : TestFixture
        {
            public void LineFeed_IsOne()
            {
                CheckEqual(1, HardBreaks.LengthAt("a\nb", 1));
            }

            public void LoneCarriageReturn_IsOne()
            {
                CheckEqual(1, HardBreaks.LengthAt("a\rb", 1));
            }

            public void CarriageReturnLineFeed_IsTwo()
            {
                CheckEqual(2, HardBreaks.LengthAt("a\r\nb", 1));
            }

            public void CarriageReturnAtTheEnd_IsOne()
            {
                CheckEqual(1, HardBreaks.LengthAt("a\r", 1));
            }

            public void TheLineFeedOfAPair_IsOne()
            {
                CheckEqual(1, HardBreaks.LengthAt("a\r\nb", 2));
            }

            public void OtherKindsOfBreak_AreOne()
            {
                CheckEqual(1, HardBreaks.LengthAt("a" + NextLine, 1));
                CheckEqual(1, HardBreaks.LengthAt("a" + LineSeparator, 1));
                CheckEqual(1, HardBreaks.LengthAt("a" + ParagraphSeparator, 1));
                CheckEqual(1, HardBreaks.LengthAt("a" + VerticalTab, 1));
                CheckEqual(1, HardBreaks.LengthAt("a" + FormFeed, 1));
            }

            public void NoBreak_IsZero()
            {
                CheckEqual(0, HardBreaks.LengthAt("a\nb", 0));
            }

            public void AtTheEnd_IsZero()
            {
                CheckEqual(0, HardBreaks.LengthAt("a\n", 2));
            }

            public void NullText_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                HardBreaks.LengthAt(null, 0);
            }

            public void IndexPastTheEnd_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                HardBreaks.LengthAt("ab", 3);
            }

            public void NegativeIndex_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                HardBreaks.LengthAt("ab", -1);
            }
        }

        public class LengthBeforeTests : TestFixture
        {
            public void LineFeed_IsOne()
            {
                CheckEqual(1, HardBreaks.LengthBefore("a\nb", 2));
            }

            public void LoneCarriageReturn_IsOne()
            {
                CheckEqual(1, HardBreaks.LengthBefore("a\rb", 2));
            }

            public void CarriageReturnLineFeed_IsTwo()
            {
                CheckEqual(2, HardBreaks.LengthBefore("a\r\nb", 3));
            }

            public void LineFeedAtTheStartOfTheText_IsOne()
            {
                CheckEqual(1, HardBreaks.LengthBefore("\n", 1));
            }

            public void BetweenTheHalvesOfAPair_IsOneForTheCarriageReturn()
            {
                CheckEqual(1, HardBreaks.LengthBefore("a\r\nb", 2));
            }

            public void OtherKindsOfBreak_AreOne()
            {
                CheckEqual(1, HardBreaks.LengthBefore("a" + NextLine + "b", 2));
                CheckEqual(1, HardBreaks.LengthBefore("a" + LineSeparator + "b", 2));
                CheckEqual(1, HardBreaks.LengthBefore("a" + ParagraphSeparator + "b", 2));
            }

            public void NoBreak_IsZero()
            {
                CheckEqual(0, HardBreaks.LengthBefore("a\nb", 3));
            }

            public void AtTheStart_IsZero()
            {
                CheckEqual(0, HardBreaks.LengthBefore("\n", 0));
            }

            public void NullText_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                HardBreaks.LengthBefore(null, 0);
            }

            public void IndexPastTheEnd_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                HardBreaks.LengthBefore("ab", 3);
            }
        }

        public class IsInsideCarriageReturnLineFeedTests : TestFixture
        {
            public void BetweenCarriageReturnAndLineFeed_IsInside()
            {
                Check(HardBreaks.IsInsideCarriageReturnLineFeed("a\r\nb", 2));
            }

            public void AroundThePair_IsNotInside()
            {
                CheckFalse(HardBreaks.IsInsideCarriageReturnLineFeed("a\r\nb", 1));
                CheckFalse(HardBreaks.IsInsideCarriageReturnLineFeed("a\r\nb", 3));
            }

            public void OtherBreakPairs_AreNotInside()
            {
                CheckFalse(HardBreaks.IsInsideCarriageReturnLineFeed("a\n\nb", 2));
                CheckFalse(HardBreaks.IsInsideCarriageReturnLineFeed("a\r\rb", 2));
                CheckFalse(HardBreaks.IsInsideCarriageReturnLineFeed("a\n\rb", 2));
            }

            public void StartAndEndOfText_AreNotInside()
            {
                CheckFalse(HardBreaks.IsInsideCarriageReturnLineFeed("\r\n", 0));
                CheckFalse(HardBreaks.IsInsideCarriageReturnLineFeed("\r\n", 2));
            }

            public void NullText_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                HardBreaks.IsInsideCarriageReturnLineFeed(null, 0);
            }

            public void IndexPastTheEnd_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                HardBreaks.IsInsideCarriageReturnLineFeed("ab", 3);
            }

            public void NegativeIndex_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                HardBreaks.IsInsideCarriageReturnLineFeed("ab", -1);
            }
        }

        public class StartOfLineTests : TestFixture
        {
            public void FirstLine_IsTheStartOfTheText()
            {
                CheckEqual(0, HardBreaks.StartOfLine("ab\ncd", 1));
            }

            public void LaterLine_StartsAfterTheBreak()
            {
                CheckEqual(3, HardBreaks.StartOfLine("ab\ncd", 4));
            }

            public void IndexAtTheStartOfALine_IsItself()
            {
                CheckEqual(3, HardBreaks.StartOfLine("ab\ncd", 3));
            }

            public void IndexAtTheEndOfALine_StaysOnThatLine()
            {
                CheckEqual(0, HardBreaks.StartOfLine("ab\ncd", 2));
            }

            public void CarriageReturnLineFeed_StartsAfterBoth()
            {
                CheckEqual(4, HardBreaks.StartOfLine("ab\r\ncd", 5));
            }

            public void BetweenTheHalvesOfAPair_IsTheLineThePairEnds()
            {
                CheckEqual(0, HardBreaks.StartOfLine("ab\r\ncd", 3));
            }

            public void EveryKindOfBreak_StartsALine()
            {
                CheckEqual(3, HardBreaks.StartOfLine("ab" + LineSeparator + "cd", 4));
                CheckEqual(3, HardBreaks.StartOfLine("ab" + NextLine + "cd", 4));
                CheckEqual(3, HardBreaks.StartOfLine("ab" + VerticalTab + "cd", 4));
                CheckEqual(3, HardBreaks.StartOfLine("ab\rcd", 4));
            }

            public void BlankLine_StartsAtItself()
            {
                CheckEqual(2, HardBreaks.StartOfLine("a\n\nb", 2));
            }

            public void NullText_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                HardBreaks.StartOfLine(null, 0);
            }

            public void IndexPastTheEnd_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                HardBreaks.StartOfLine("ab", 3);
            }
        }

        public class EndOfLineTests : TestFixture
        {
            public void FirstLine_EndsAtTheBreak()
            {
                CheckEqual(2, HardBreaks.EndOfLine("ab\ncd", 0));
            }

            public void LastLine_EndsAtTheEndOfTheText()
            {
                CheckEqual(5, HardBreaks.EndOfLine("ab\ncd", 3));
            }

            public void IndexAtTheEndOfALine_IsItself()
            {
                CheckEqual(2, HardBreaks.EndOfLine("ab\ncd", 2));
            }

            public void CarriageReturnLineFeed_EndsBeforeBoth()
            {
                CheckEqual(2, HardBreaks.EndOfLine("ab\r\ncd", 0));
            }

            public void BetweenTheHalvesOfAPair_IsTheLineThePairEnds()
            {
                CheckEqual(2, HardBreaks.EndOfLine("ab\r\ncd", 3));
            }

            public void EveryKindOfBreak_EndsALine()
            {
                CheckEqual(2, HardBreaks.EndOfLine("ab" + ParagraphSeparator + "cd", 0));
                CheckEqual(2, HardBreaks.EndOfLine("ab" + NextLine + "cd", 0));
                CheckEqual(2, HardBreaks.EndOfLine("ab" + FormFeed + "cd", 0));
                CheckEqual(2, HardBreaks.EndOfLine("ab\rcd", 0));
            }

            public void BlankLine_EndsAtItself()
            {
                CheckEqual(2, HardBreaks.EndOfLine("a\n\nb", 2));
            }

            public void NullText_Throws()
            {
                CheckThrow(typeof(ArgumentNullException));
                HardBreaks.EndOfLine(null, 0);
            }

            public void IndexPastTheEnd_Throws()
            {
                CheckThrow(typeof(ArgumentOutOfRangeException));
                HardBreaks.EndOfLine("ab", 3);
            }
        }
    }
}