using System;
using Amphora;
using Glass.Editing;
using UnitTestSharp;

namespace Glass.UnitTests.Editing
{
    public class StepTextTests : TestFixture
    {
        public static PagedText.PageRun Pages(int length)
        {
            return PagedTextTests.Paged(new string('x', length)).TakeOut(0, length);
        }

        public static StepText HoldingChars(string text)
        {
            var returnMe = new StepText();
            returnMe.Set(EditSide.OfChars(new StringView(text)));

            return returnMe;
        }

        public static StepText HoldingPages(int length)
        {
            var returnMe = new StepText();
            returnMe.Set(EditSide.OfPages(Pages(length)));

            return returnMe;
        }

        public static StepText InDocument(int length)
        {
            var returnMe = new StepText();
            returnMe.Set(EditSide.InDocument(length));

            return returnMe;
        }

        public class LengthTests : TestFixture
        {
            public void WhenEmpty_IsZero()
            {
                CheckEqual(0, new StepText().Length);
            }

            public void CountsChars()
            {
                CheckEqual(3, HoldingChars("abc").Length);
            }

            public void CountsPages()
            {
                CheckEqual(40, HoldingPages(40).Length);
            }

            public void CountsTextInTheDocument()
            {
                CheckEqual(900, InDocument(900).Length);
            }
        }

        public class StoredLengthTests : TestFixture
        {
            public void CountsChars()
            {
                CheckEqual(3, HoldingChars("abc").StoredLength);
            }

            public void CountsPages()
            {
                CheckEqual(40, HoldingPages(40).StoredLength);
            }

            public void IgnoresTextInTheDocument()
            {
                CheckEqual(0, InDocument(900).StoredLength);
            }
        }

        public class KindTests : TestFixture
        {
            public void AnEmptySide_HoldsChars()
            {
                var text = new StepText();

                CheckFalse(text.HoldsPages);
                CheckFalse(text.IsInDocument);
            }

            public void PagesAreHeldAsPages()
            {
                StepText text = HoldingPages(40);

                CheckTrue(text.HoldsPages);
                CheckFalse(text.IsInDocument);
            }

            public void TextInTheDocumentIsInTheDocument()
            {
                StepText text = InDocument(900);

                CheckTrue(text.IsInDocument);
                CheckFalse(text.HoldsPages);
            }
        }

        public class CharsTests : TestFixture
        {
            public void ReturnsTheChars()
            {
                CheckEqual("abc", HoldingChars("abc").Chars.ToString());
            }

            public void WhenHeldAsPages_Throws()
            {
                StepText text = HoldingPages(40);

                CheckThrow(typeof(InvalidOperationException));
                Check(text.Chars != null);
            }

            public void WhenInTheDocument_Throws()
            {
                StepText text = InDocument(900);

                CheckThrow(typeof(InvalidOperationException));
                Check(text.Chars != null);
            }
        }

        public class PagesTests : TestFixture
        {
            public void ReturnsThePages()
            {
                CheckEqual(40, HoldingPages(40).Pages.Length);
            }

            public void WhenHeldAsChars_Throws()
            {
                StepText text = HoldingChars("abc");

                CheckThrow(typeof(InvalidOperationException));
                Check(text.Pages != null);
            }

            public void WhenInTheDocument_Throws()
            {
                StepText text = InDocument(900);

                CheckThrow(typeof(InvalidOperationException));
                Check(text.Pages != null);
            }
        }

        public class SetTests : TestFixture
        {
            public void OfPagesWithNoChars_HoldsChars()
            {
                var text = new StepText();

                text.Set(EditSide.OfPages(new PagedText.PageRun()));

                CheckFalse(text.HoldsPages);
                CheckEqual(0, text.Length);
            }

            public void OfAZeroLengthInTheDocument_HoldsChars()
            {
                var text = new StepText();

                text.Set(EditSide.InDocument(0));

                CheckFalse(text.IsInDocument);
                CheckEqual("", text.Chars.ToString());
            }

            public void ReplacesWhatItHeld()
            {
                StepText text = HoldingPages(40);

                text.Set(EditSide.OfChars(new StringView("ab")));

                CheckFalse(text.HoldsPages);
                CheckEqual("ab", text.Chars.ToString());
            }

            public void ReplacesChars_WithTextInTheDocument()
            {
                StepText text = HoldingChars("abc");

                text.Set(EditSide.InDocument(7));

                CheckTrue(text.IsInDocument);
                CheckEqual(7, text.Length);
            }

            public void ReplacesTextInTheDocument_WithChars()
            {
                StepText text = InDocument(900);

                text.Set(EditSide.OfChars(new StringView("ab")));

                CheckFalse(text.IsInDocument);
                CheckEqual("ab", text.Chars.ToString());
            }
        }

        public class TakePagesTests : TestFixture
        {
            public void ReturnsThePagesAndLeavesTheSideEmpty()
            {
                StepText text = HoldingPages(40);

                PagedText.PageRun run = text.TakePages();

                CheckEqual(40, run.Length);
                CheckFalse(text.HoldsPages);
                CheckEqual(0, text.Length);
            }

            public void WhenHeldAsChars_Throws()
            {
                StepText text = HoldingChars("abc");

                CheckThrow(typeof(InvalidOperationException));
                text.TakePages();
            }
        }

        public class ClearTests : TestFixture
        {
            public void EmptiesChars()
            {
                StepText text = HoldingChars("abc");

                text.Clear();

                CheckEqual(0, text.Length);
            }

            public void ForgetsPages()
            {
                StepText text = HoldingPages(40);

                text.Clear();

                CheckEqual(0, text.Length);
                CheckFalse(text.HoldsPages);
            }

            public void ForgetsTextInTheDocument()
            {
                StepText text = InDocument(900);

                text.Clear();

                CheckEqual(0, text.Length);
                CheckFalse(text.IsInDocument);
            }
        }
    }
}