using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Chernobyl.Reflection.Template.Xml;
using NUnit.Framework;

namespace Chernobyl.Reflection.Template
{
    [TestFixture, Description("A series of tests for testing the TypeParser type")]
    public class TypesParserTests : EnumerationTests<Type>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="TypesParserTests"/> class.
        /// </summary>
        public TypesParserTests() : base(true)
        {}

        [Test, Description("A test that ensures the TypeParser is capable of " +
            "parsing one type.")]
        public void ParseOneTypeTest()
        {
            TypesParser parser = CreateParser("Int32");

            Assert.AreEqual(1, parser.Count(), "The parser must " +
                "contain only one type.");
            Assert.AreEqual(typeof(Int32), parser.First(), "The parser must " +
                "contain one Int32 type.");
        }

        [Test, Description("A test that ensures the TypeParser is capable of " +
            "parsing two types.")]
        public void ParseTwoTypesTest()
        {
            TypesParser parser = CreateParser("Int32, Collections:ArrayList");

            Assert.AreEqual(2, parser.Count(), "The parser must " +
                "contain two types.");
            Assert.AreEqual(typeof(Int32), parser.First(), "The parser must " +
                "contain one Int32 type for it's first element.");
            Assert.AreEqual(typeof(ArrayList), parser.ElementAt(1), "The parser must " +
                "contain one ArrayList type for it's second element.");
        }

        [Test, Description("A test that ensures the TypeParser is capable of " +
            "parsing one type containing one generic argument.")]
        public void ParseOneGenericTypeTest()
        {
            TypesParser parser = CreateParser("GenCollections:List{Int32}");

            Assert.AreEqual(1, parser.Count(), "The parser must " +
                "contain only one type.");
            Assert.AreEqual(typeof(List<Int32>), parser.First(), "The parser must " +
                "contain one List<Int32> type.");
        }

        [Test, Description("A test that ensures the TypeParser is capable of " +
            "parsing one type with two generic arguments.")]
        public void ParseTwoGenericTypesTest()
        {
            TypesParser parser = CreateParser("GenCollections:KeyValuePair{String, GenCollections:List{Int32}}");

            Assert.AreEqual(1, parser.Count(), "The parser must " +
                "contain only one type.");
            Assert.AreEqual(typeof(KeyValuePair<String, List<Int32>>),
                parser.First(), "The parser must contain one " +
                "KeyValuePair<String, List<Int32>> type.");
        }

        [Test, Description("A test that ensures the TypeParser is capable of " +
            "parsing a one dimensional array type.")]
        public void Parse1DArrayTest()
        {
            // TODO: add support for parsing one dimensional arrays
            Assert.Ignore("Parsing one dimensional arrays are not currently supported.");

            TypesParser parser = CreateParser("Int32[]");

            Assert.AreEqual(1, parser.Count(), "The parser must " +
                "contain only one type.");
            Assert.AreEqual(typeof(Int32[]),
                parser.First(), "The parser must contain one " +
                "Int32[] type.");
        }

        [Test, Description("A test that ensures the TypeParser is capable of " +
            "parsing a two dimensional array type.")]
        public void Parse2DArrayTest()
        {
            // TODO: add support for parsing two dimensional arrays
            Assert.Ignore("Parsing two dimensional arrays are not currently supported.");

            TypesParser parser = CreateParser("Int32[,]");

            Assert.AreEqual(1, parser.Count(), "The parser must " +
                "contain only one type.");
            Assert.AreEqual(typeof(Int32[,]),
                parser.First(), "The parser must contain one " +
                "Int32[,] type.");
        }

        [Test, Description("A test that ensures the TypeParser throws the " +
            "proper exception when it finds badly formed text.")]
        public void ExceptionOnBadText()
        {
            TypesParser parser = CreateParser("Int32zfda");
            // ReSharper disable ReturnValueOfPureMethodIsNotUsed
            Assert.Throws<TypeLoadException>(() => parser.Count());
            // ReSharper restore ReturnValueOfPureMethodIsNotUsed
        }

        /// <summary>
        /// This method should return a new <see cref="IEnumerable{T}"/> that can
        /// be iterated over exactly once. This method should create a new
        /// <see cref="IEnumerable{T}"/> every time it is invoked and not reuse
        /// instances.
        /// </summary>
        /// <returns>
        /// The <see cref="IEnumerable{T}"/> containing a single item.
        /// </returns>
        protected override IEnumerable<Type> CreateSingleItemEnumerable()
        {
            return CreateParser("String");
        }

        /// <summary>
        /// This method should return a new <see cref="IEnumerable{T}"/> that can
        /// be iterated over five or more times. The items will be compared to
        /// the items in <see cref="EnumerationTests{T}.OrderedItems"/> but only
        /// if the  <see cref="EnumerationTests{T}.TestIterationOrder"/> property
        /// is set to true. This method should create a new
        /// <see cref="IEnumerable{T}"/> every time it is invoked and not reuse
        /// instances. All instances returned  through iteration of the
        /// <see cref="IEnumerable{T}"/> should be unique.
        /// </summary>
        /// <returns>
        /// The <see cref="IEnumerable{T}"/> containing many items.
        /// </returns>
        protected override IEnumerable<Type> CreateManyItemEnumerable()
        {
            return CreateParser("String, Collections:ArrayList, Int32, Single, " +
                "GenCollections:KeyValuePair{Int32, String}, Type, Int16");
        }

        /// <summary>
        /// Creates the parser that is to be tested. This method should return
        /// a <see cref="TypesParser.TypeParser"/> that parses the text passed
        /// to this method.This method should never return the same
        /// <see cref="TypesParser.TypeParser"/> more than once.
        /// </summary>
        /// <returns>The <see cref="TypesParser.TypeParser"/> that is to be
        /// tested.</returns>
        protected virtual TypesParser CreateParser(string text)
        {
            return new TypesParser(text, NamespaceAssemblyLookup);
        }

        protected override IEnumerable<Type> OrderedItems
        {
            get
            {
                if(_orderedItems == null)
                {
                    _orderedItems = new[] { typeof(String), typeof(ArrayList),
                        typeof(Int32), typeof(Single),
                        typeof(KeyValuePair<Int32, String>), typeof(Type),
                        typeof(Int16) };
                }

                return _orderedItems;
            }
        }

        /// <summary>
        /// Retrieves the <see cref="NamespaceAssembly"/> that is referenced by
        /// the prefix. This method only handles the cases where prefix is empty
        /// or where the prefix is equal to "Collections".
        /// </summary>
        /// <param name="prefix">The prefix whose <see cref="NamespaceAssembly"/>
        /// is to be found.</param>
        /// <returns>If prefix is empty, returns the "System" namespace in the
        /// "mscorlib" assembly. If prefix is equal to "Collections", returns
        /// "System.Collections.Generic" in the "mscorlib" assembly.</returns>
        /// <exception cref="ArgumentException">The prefix is not know, you must
        /// either extend this method or override it to add your own prefix
        /// lookup.</exception>
        protected virtual NamespaceAssembly NamespaceAssemblyLookup(string prefix)
        {
            NamespaceAssembly result;
            if(prefix == string.Empty)
                result = new NamespaceAssembly(typeof(Int32).Namespace, typeof(Int32).Assembly.GetName());
            else if (prefix == "Collections")
                result = new NamespaceAssembly(typeof(ArrayList).Namespace, typeof(ArrayList).Assembly.GetName());
            else if(prefix == "GenCollections")
                result = new NamespaceAssembly(typeof(List<>).Namespace, typeof(List<>).Assembly.GetName());
            else
            {
                throw new ArgumentException("The NamespaceAssembly prefix \"" + prefix +
                    "\" is unknown. Please extend this method or override it to " +
                    "add the prefix.");
            }

            return result;
        }

        /// <summary>
        /// The backing field to <see cref="OrderedItems"/>.
        /// </summary>
        IEnumerable<Type> _orderedItems;
    }
}