using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnitTestSharp;

namespace Glass.UnitTests
{
    public class StringViewTests : TestFixture
    {
        public class Ctor : TestFixture
        {   
            public void Basic()
            {
                string text = "test";
                var view = new StringView(text);

                CheckEqual(text, view.Text);
                CheckEqual(0, view.StartIndex);
                CheckEqual(4, view.EndIndex);
            }

            public void NullStringNoPositioning()
            {
                string text = null;

                CheckThrow(typeof(ArgumentNullException));
                var view = new StringView(text);
            }

            public void SetStart()
            {
                string text = "test";
                var view = new StringView(text, 1, null);

                CheckEqual(text, view.Text);
                CheckEqual(1, view.StartIndex);
                CheckEqual(4, view.EndIndex);
            }

            public void SetEnd()
            {
                string text = "test";
                var view = new StringView(text, null, 2);

                CheckEqual(text, view.Text);
                CheckEqual(0, view.StartIndex);
                CheckEqual(2, view.EndIndex);
            }

            public void SetNone()
            {
                string text = "test";
                var view = new StringView(text, null, null);

                CheckEqual(text, view.Text);
                CheckEqual(0, view.StartIndex);
                CheckEqual(4, view.EndIndex);
            }

            public void StartSetAtStringEnd()
            {
                string text = "test";
                var view = new StringView(text, 4, 4);

                CheckEqual(text, view.Text);
                CheckEqual(4, view.StartIndex);
                CheckEqual(4, view.EndIndex);
            }

            public void EndSetAtStringEnd()
            {
                string text = "test";
                var view = new StringView(text, 2, 4);

                CheckEqual(text, view.Text);
                CheckEqual(2, view.StartIndex);
                CheckEqual(4, view.EndIndex);
            }

            public void NullStringPositionSet()
            {
                string text = null;

                CheckThrow(typeof(ArgumentNullException));
                new StringView(text, null, null);
            }

            public void NegativeStartIndex()
            {
                string text = "test";

                CheckThrow(typeof(ArgumentOutOfRangeException));
                new StringView(text, -1, null);
            }

            public void NegativeEndIndex()
            {
                string text = "test";

                CheckThrow(typeof(ArgumentOutOfRangeException));
                new StringView(text, null, -1);
            }

            public void TooLargeStartIndex()
            {
                string text = "test";

                CheckThrow(typeof(ArgumentOutOfRangeException));
                new StringView(text, 5, null);
            }

            public void TooLargeEndIndex()
            {
                string text = "test";

                CheckThrow(typeof(ArgumentOutOfRangeException));
                new StringView(text, null, 5);
            }

            public void StartIndexPastEndIndex()
            {
                string text = "test";

                CheckThrow(typeof(ArgumentOutOfRangeException));
                new StringView(text, 3, 2);
            }
        }

        public class ImplicitStringConversion : TestFixture
        {
            public void Basic()
            {
                string text = "test";
                StringView view = text;

                CheckEqual(text, view.Text);
                CheckEqual(0, view.StartIndex);
                CheckEqual(4, view.EndIndex);
            }

            public void NullString()
            {
                string text = null;

                CheckThrow(typeof(ArgumentNullException));
                StringView view = text;
            }
        }

        public class Length : TestFixture
        {
            public void Basic()
            {
                string text = "test";
                StringView view = text;
                CheckEqual(4, view.Length);
            }

            public void StartIndex()
            {
                string text = "test";
                StringView view = text.GetView(1, null);
                CheckEqual(3, view.Length);
            }

            public void EndIndex()
            {
                string text = "test";
                StringView view = text.GetView(null, 2);
                CheckEqual(2, view.Length);
            }

            public void BothStartAndEndIndex()
            {
                string text = "test";
                StringView view = text.GetView(2, 3);
                CheckEqual(1, view.Length);
            }

            public void ZeroLength()
            {
                string text = "test";
                StringView view = text.GetView(4, 4);
                CheckEqual(0, view.Length);
            }
        }

        public class CharacterIndexOperator : TestFixture
        {
            public void Basic()
            {
                string test = "tesd";
                StringView view = test;
                CheckEqual('t', view[0]);
                CheckEqual('e', view[1]);
                CheckEqual('s', view[2]);
                CheckEqual('d', view[3]);
            }

            public void StringViewStart()
            {
                string test = "tesd";
                StringView view = test.GetView(1, null);
                CheckEqual('e', view[0]);
                CheckEqual('s', view[1]);
                CheckEqual('d', view[2]);                
            }

            public void NegativeIndex()
            {
                string test = "tesd";
                StringView view = test;

                CheckThrow(typeof(ArgumentOutOfRangeException));
                char c = view[-1];
            }

            public void IndexTooLarge()
            {
                string test = "tesd";
                StringView view = test;

                CheckThrow(typeof(ArgumentOutOfRangeException));
                char c = view[4];
            }

            public void IndexTooLargeForStringViewButNotOriginalString()
            {
                string test = "tesd";
                StringView view = test.GetView(1, 2);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                char c = view[1];
            }
        }

        public class SliceOperator : TestFixture
        {
            public void Basic()
            {
                string test = "test";
                StringView view = test;
                StringView slice = view[1, 3];
                
                CheckEqual(test, slice.Text);
                CheckEqual(1, slice.StartIndex);
                CheckEqual(3, slice.EndIndex);
            }

            public void AddsStartIndexOfSource()
            {
                string text = "testABC";
                StringView view = text.GetView(2, null);
                StringView slice = view[1, 3];
                
                CheckEqual(text, slice.Text);
                CheckEqual(3, slice.StartIndex);
                CheckEqual(5, slice.EndIndex);
            }

            public void StartIndexNegative()
            {
                string test = "testABC";
                StringView view = test.GetView(2, 4);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                StringView slice = view[-1, 3];
            }

            public void EndIndexNegative()
            {
                string test = "testABC";
                StringView view = test.GetView(2, 4);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                StringView slice = view[0, -1];
            }

            public void StartIndexTooLarge()
            {
                string test = "testABC";
                StringView view = test.GetView(0, 4);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                StringView slice = view[5, 3];
            }

            public void EndIndexTooLarge()
            {
                string test = "testABC";
                StringView view = test.GetView(0, 4);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                StringView slice = view[3, 5];
            }

            public void EndIndexBeforeStartIndex()
            {
                string test = "test";
                StringView view = test;

                CheckThrow(typeof(ArgumentOutOfRangeException));
                StringView slice = view[3, 2];
            }

            public void NestingViews_SpecifyEndIndex()
            {
                string test = "test ABC";
                StringView view1 = test.GetView(2, 6);
                StringView view2 = view1[1, 3];

                CheckEqual(test, view2.Text);
                CheckEqual(3, view2.StartIndex);
                CheckEqual(5, view2.EndIndex);
            }

            public void NestingViews_NoSpecifyEndIndex()
            {
                string test = "test ABC";
                StringView view1 = test.GetView(2, 6);
                StringView view2 = view1[1, null];

                CheckEqual(test, view2.Text);
                CheckEqual(3, view2.StartIndex);
                CheckEqual(6, view2.EndIndex);
            }
        }

        public class SplitAt : TestFixture
        {
            public void Basic()
            {
                string text = "test ABC";
                StringView view = text;
                (StringView lhs, StringView rhs) = view.SplitAt(4);

                CheckEqual(text, lhs.Text);
                CheckEqual(0, lhs.StartIndex);
                CheckEqual(4, lhs.EndIndex);

                CheckEqual(text, rhs.Text);
                CheckEqual(4, rhs.StartIndex);
                CheckEqual(8, rhs.EndIndex);
            }

            public void SplitAtZero()
            {
                string text = "test ABC";
                StringView view = text;
                (StringView lhs, StringView rhs) = view.SplitAt(0);

                CheckEqual(text, lhs.Text);
                CheckEqual(0, lhs.StartIndex);
                CheckEqual(0, lhs.EndIndex);

                CheckEqual(text, rhs.Text);
                CheckEqual(0, rhs.StartIndex);
                CheckEqual(8, rhs.EndIndex);
            }

            public void SplitAtLength()
            {
                string text = "test ABC";
                StringView view = text;
                (StringView lhs, StringView rhs) = view.SplitAt(8);

                CheckEqual(text, lhs.Text);
                CheckEqual(0, lhs.StartIndex);
                CheckEqual(8, lhs.EndIndex);

                CheckEqual(text, rhs.Text);
                CheckEqual(8, rhs.StartIndex);
                CheckEqual(8, rhs.EndIndex);
            }

            public void NegativeIndex()
            {
                string text = "test ABC";
                StringView view = text;

                CheckThrow(typeof(ArgumentOutOfRangeException));
                view.SplitAt(-1);
            }

            public void IndexTooLarge()
            {
                string text = "test";
                StringView view = text;

                CheckThrow(typeof(ArgumentOutOfRangeException));
                view.SplitAt(5);
            }
        }

        public class ToStringTests : TestFixture
        {
            public void Basic()
            {
                string text = "test";
                StringView view = text;

                CheckEqual("test", view.ToString());
            }

            public void EmptyString()
            {
                string text = "test";
                StringView view = text.GetView(0, 0);

                CheckEqual("", view.ToString());
            }

            public void RespectsNestingViewStartingIndices()
            {
                string text = "test";
                StringView view = text.GetView(1, null);
                StringView view2 = view[1, null];

                CheckEqual("st", view2.ToString());
            }
        }

        public class EnumeratorTests : TestFixture
        {
            public void Basic()
            {
                int index = 0;
                string text = "test";
                StringView view = text;
                foreach (char c in view)
                {
                    CheckEqual(text[index++], c);                    
                }
            }

            public void EmptyString()
            {
                string text = "";
                StringView view = text;
                foreach (char c in view)
                {
                    throw new InvalidOperationException();
                }
            }
        }

        public class EmptyTests : TestFixture
        {
            public void NotEmpty()
            {
                StringView view = "test";
                CheckFalse(view.Empty);
            }

            public void Empty()
            {
                StringView view = "";
                CheckTrue(view.Empty);
            }
        }

        public class EqualsStrings : TestFixture
        {
            public void Basic()
            {
                StringView view = "test";
                string str = "test";

                CheckEqual(str, view);
                CheckEqual(view, str);
                Check(view.Equals(str));
                Check(Object.Equals(view, str));
                Check(view == str);
                Check(str == view);
                CheckFalse(view != str);
                CheckFalse(str != view);

                // Unfortunately these will return false and there's nothing we can do about it, since the behavior
                // depends on code inside C#'s implementation of string and Object.
                CheckFalse(str.Equals(view));
                CheckFalse(Object.Equals(str, view));
            }

            public void NullString()
            {
                StringView view = "test";
                string str = null;

                CheckNotEqual(str, view);
                CheckNotEqual(view, str);
                CheckFalse(view.Equals(str));
                CheckFalse(string.Equals(str, view));
                CheckFalse(null == view);
                CheckFalse(view == null);
                Check(null != view);
                Check(view != null);
            }

            public void UnequalStrings()
            {
                StringView view = "test1";
                string str = "test2";

                CheckNotEqual(str, view);
                CheckNotEqual(view, str);
                CheckFalse(view.Equals(str));
                CheckFalse(str.Equals(view));
                CheckFalse(view == str);
                CheckFalse(str == view);
                Check(view != str);
                Check(str != view);
            }

            public void UnequalLengths()
            {
                StringView view = "test";
                string str = "test2";

                CheckNotEqual(str, view);
                CheckNotEqual(view, str);
                CheckFalse(view.Equals(str));
                CheckFalse(str.Equals(view));
                CheckFalse(view == str);
                CheckFalse(str == view);
                Check(view != str);
                Check(str != view);
            }
        }

        public class EqualsStringView : TestFixture
        {
            public void Basic()
            {
                StringView view1 = "test";
                StringView view2 = "test";

                CheckEqual(view1, view2);
                CheckEqual(view2, view1);
                Check(view1.Equals(view2));
                Check(view2.Equals(view1));
                Check(view1 == view2);
                Check(view2 == view1);
                CheckFalse(view1 != view2);
                CheckFalse(view2 != view1);
            }

            public void DifferentCharacters()
            {
                StringView view1 = "testA";
                StringView view2 = "testB";

                CheckNotEqual(view1, view2);
                CheckNotEqual(view2, view1);
                CheckFalse(view1.Equals(view2));
                CheckFalse(view2.Equals(view1));
                CheckFalse(view1 == view2);
                CheckFalse(view2 == view1);
                Check(view1 != view2);
                Check(view2 != view1);
            }

            public void DifferentLengths()
            {
                StringView view1 = "test1";
                StringView view2 = "test";

                CheckNotEqual(view1, view2);
                CheckNotEqual(view2, view1);
                CheckFalse(view1.Equals(view2));
                CheckFalse(view2.Equals(view1));
                CheckFalse(view1 == view2);
                CheckFalse(view2 == view1);
                Check(view1 != view2);
                Check(view2 != view1);
            }
        }

        public class HashCode : TestFixture
        {
            public void IdenticalValuesProduceIdenticalCodes()
            {
                StringView view1 = "test";
                StringView view2 = "test";

                CheckEqual(view1.GetHashCode(), view2.GetHashCode());
            }

            public void DifferentValuesProduceDifferentCodes()
            {
                StringView view1 = "test1";
                StringView view2 = "test2";

                CheckNotEqual(view1.GetHashCode(), view2.GetHashCode());
            }

            public void IdenticalValuesDifferentOffsetsProduceIdenticalCodes()
            {
                StringView view1 = new StringView("AtestBC", 1, 5);
                StringView view2 = new StringView("ABtestC", 2, 6);

                CheckEqual(view1.GetHashCode(), view2.GetHashCode());
            }
        }
    }
}