using System;
using System.Collections.Generic;
using System.IO;
using UnitTestSharp;

namespace Vellum.UnitTests
{
    public class SavedComparerTests : TestFixture
    {
        /// <summary>
        /// A comparer no save can name, which calls every pair of values equal.
        /// </summary>
        public class EveryoneEqual<ItemType> : IEqualityComparer<ItemType>
        {
            public bool Equals(ItemType left, ItemType right)
            {
                return true;
            }

            public int GetHashCode(ItemType value)
            {
                return 0;
            }
        }

        public static SaveNode WrittenFor<ItemType>(IEqualityComparer<ItemType> comparer)
        {
            SaveNode returnMe = SaveNode.NewTable();
            SavedComparer.Write(returnMe, comparer);
            return returnMe;
        }

        public static SaveNode Naming(string name)
        {
            SaveNode returnMe = SaveNode.NewTable();
            returnMe.Entries[SavedComparer.Key] = SaveNode.OfText(name);
            return returnMe;
        }

        public class WriteTests : TestFixture
        {
            public void DefaultComparer_IsLeftOut()
            {
                CheckEqual(0, WrittenFor(EqualityComparer<int>.Default).Entries.Count);
                CheckEqual(0, WrittenFor(EqualityComparer<string>.Default).Entries.Count);
            }

            public void NullComparer_IsLeftOut()
            {
                CheckEqual(0, WrittenFor<string>(null).Entries.Count);
            }

            public void StringComparers_AreSavedByName()
            {
                CheckEqual("Ordinal", WrittenFor<string>(StringComparer.Ordinal).Entries[SavedComparer.Key].Text);
                CheckEqual("OrdinalIgnoreCase",
                    WrittenFor<string>(StringComparer.OrdinalIgnoreCase).Entries[SavedComparer.Key].Text);
                CheckEqual("InvariantCulture",
                    WrittenFor<string>(StringComparer.InvariantCulture).Entries[SavedComparer.Key].Text);
                CheckEqual("InvariantCultureIgnoreCase",
                    WrittenFor<string>(StringComparer.InvariantCultureIgnoreCase).Entries[SavedComparer.Key].Text);
            }

            public void CurrentCultureComparer_Throws()
            {
                CheckThrow(typeof(NotSupportedException));
                WrittenFor<string>(StringComparer.CurrentCulture);
            }

            public void OtherComparerOfStrings_Throws()
            {
                CheckThrow(typeof(NotSupportedException));
                WrittenFor<string>(new EveryoneEqual<string>());
            }

            public void OtherComparerOfAnotherType_Throws()
            {
                CheckThrow(typeof(NotSupportedException));
                WrittenFor<int>(new EveryoneEqual<int>());
            }
        }

        public class ReadTests : TestFixture
        {
            public void NoComparer_IsNull()
            {
                CheckNull(SavedComparer.Read<string>(SaveNode.NewTable()));
            }

            public void StringComparers_AreReadByName()
            {
                CheckTrue(SavedComparer.Read<string>(Naming("Ordinal")) == StringComparer.Ordinal);
                CheckTrue(SavedComparer.Read<string>(Naming("OrdinalIgnoreCase")) == StringComparer.OrdinalIgnoreCase);
                CheckTrue(SavedComparer.Read<string>(Naming("InvariantCulture")) == StringComparer.InvariantCulture);
                CheckTrue(SavedComparer.Read<string>(Naming("InvariantCultureIgnoreCase"))
                    == StringComparer.InvariantCultureIgnoreCase);
            }

            public void UnknownName_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                SavedComparer.Read<string>(Naming("CurrentCulture"));
            }

            public void NameForAnotherType_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                SavedComparer.Read<int>(Naming("Ordinal"));
            }

            public void NameThatIsNotText_Throws()
            {
                SaveNode table = SaveNode.NewTable();
                table.Entries[SavedComparer.Key] = SaveNode.NewList();

                CheckThrow(typeof(InvalidDataException));
                SavedComparer.Read<string>(table);
            }
        }

        public class WriteOrderingTests : TestFixture
        {
            public static SaveNode WrittenForOrdering<ItemType>(IComparer<ItemType> ordering)
            {
                SaveNode returnMe = SaveNode.NewTable();
                SavedComparer.WriteOrdering(returnMe, ordering);
                return returnMe;
            }

            public void DefaultOrderingOrNone_IsLeftOut()
            {
                CheckEqual(0, WrittenForOrdering(Comparer<int>.Default).Entries.Count);
                CheckEqual(0, WrittenForOrdering<string>(null).Entries.Count);
            }

            public void StringOrderings_AreSavedByName()
            {
                CheckEqual("Ordinal", WrittenForOrdering<string>(StringComparer.Ordinal).Entries["comparer"].Text);
                CheckEqual("InvariantCultureIgnoreCase",
                    WrittenForOrdering<string>(StringComparer.InvariantCultureIgnoreCase).Entries["comparer"].Text);
            }

            public void OtherOrdering_Throws()
            {
                CheckThrow(typeof(NotSupportedException));
                WrittenForOrdering(Comparer<int>.Create((left, right) => right.CompareTo(left)));
            }
        }

        public class ReadOrderingTests : TestFixture
        {
            public void NoOrdering_IsNull()
            {
                CheckNull(SavedComparer.ReadOrdering<string>(SaveNode.NewTable()));
            }

            public void StringOrdering_IsReadByName()
            {
                CheckTrue(SavedComparer.ReadOrdering<string>(Naming("OrdinalIgnoreCase"))
                    == StringComparer.OrdinalIgnoreCase);
            }

            public void UnknownName_Throws()
            {
                CheckThrow(typeof(InvalidDataException));
                SavedComparer.ReadOrdering<int>(Naming("Ordinal"));
            }
        }
    }
}