using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.ExceptionServices;

namespace Glass.Testbed
{
    /// <summary>
    /// Finds the test cases in an assembly without building any of them.
    /// </summary>
    public static class TestCaseCatalog
    {
        /// <summary>
        /// The namespace a case's category sits under.  A case in <c>Glass.Testbed.TestCases.Text</c> is in the Text
        /// category.
        /// </summary>
        public const string RootNamespace = "Glass.Testbed.TestCases";

        /// <summary>
        /// What a menu needs to list a case before it exists.
        /// </summary>
        public sealed class Entry
        {
            public readonly string Category;
            public readonly string Name;
            public readonly Type Type;

            public Entry(string category, string name, Type type)
            {
                Category = category;
                Name = name;
                Type = type;
            }
        }

        private static string CategoryOf(Type caseType)
        {
            string prefix = RootNamespace + ".";

            if (caseType.Namespace == null || !caseType.Namespace.StartsWith(prefix, StringComparison.Ordinal))
            {
                throw new InvalidOperationException(
                    $"{caseType.FullName} is a test case, so it belongs in a category namespace under " +
                    $"{RootNamespace}.");
            }

            string returnMe = caseType.Namespace.Substring(prefix.Length);
            if (returnMe.Contains("."))
            {
                throw new InvalidOperationException(
                    $"{caseType.FullName} is in a namespace nested below its category {returnMe}.");
            }

            return returnMe;
        }

        private static ConstructorInfo ConstructorOf(Type caseType)
        {
            ConstructorInfo returnMe = caseType.GetConstructor(new[] { typeof(World) }) ??
                caseType.GetConstructor(Type.EmptyTypes);

            if (returnMe == null)
            {
                throw new InvalidOperationException(
                    $"{caseType.FullName} needs a public constructor that takes a {nameof(World)}, or none at all.");
            }

            return returnMe;
        }

        /// <summary>
        /// Returns every concrete test case in <paramref name="assembly"/>, ordered by category and then name.  Throws
        /// for one that couldn't be built or placed, so a broken case fails at startup instead of when it's clicked.
        /// </summary>
        public static List<Entry> Find(Assembly assembly)
        {
            return Find(assembly.GetTypes());
        }

        /// <summary>
        /// Returns the concrete test cases among <paramref name="types"/>, as the assembly overload does.
        /// </summary>
        public static List<Entry> Find(IEnumerable<Type> types)
        {
            var returnMe = new List<Entry>();

            foreach (Type type in types)
            {
                if (type.IsAbstract || type.IsGenericTypeDefinition || !typeof(TestCase).IsAssignableFrom(type))
                {
                    continue;
                }

                ConstructorOf(type);
                returnMe.Add(new Entry(CategoryOf(type), TestCase.NameFor(type), type));
            }

            returnMe.Sort((left, right) =>
            {
                int byCategory = string.CompareOrdinal(left.Category, right.Category);
                return byCategory != 0 ? byCategory : string.CompareOrdinal(left.Name, right.Name);
            });

            return returnMe;
        }

        /// <summary>
        /// Builds the case <paramref name="entry"/> describes, handing it <paramref name="world"/> if it takes one.
        /// </summary>
        public static TestCase Create(Entry entry, World world)
        {
            ConstructorInfo constructor = ConstructorOf(entry.Type);

            try
            {
                if (constructor.GetParameters().Length == 0)
                {
                    return (TestCase)constructor.Invoke(null);
                }

                return (TestCase)constructor.Invoke(new object[] { world });
            }
            catch (TargetInvocationException exception)
            {
                ExceptionDispatchInfo.Capture(exception.InnerException).Throw();
                throw;
            }
        }
    }
}