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

namespace Ariadne.Vellum
{
    /// <summary>
    /// Builds an arc through the constructor that loads it from a save.
    /// </summary>
    public static class ArcLoader
    {
        /// <summary>
        /// Returns the constructor <paramref name="arcType"/> loads itself through.
        /// </summary>
        /// <exception cref="InvalidOperationException">The class has no such constructor.</exception>
        public static ConstructorInfo FindConstructor(Type arcType)
        {
            ConstructorInfo returnMe = arcType.GetConstructor(
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, binder: null,
                types: new[] { typeof(IArcReader) }, modifiers: null);
            if (returnMe == null)
            {
                throw new InvalidOperationException(arcType.FullName + " has no constructor taking an IArcReader to " +
                    "load it from a save.  Is it partial, and does its assembly run Ariadne.Generator?");
            }

            return returnMe;
        }

        /// <summary>
        /// Hands <paramref name="lister"/> every field and local <paramref name="arcType"/> and its base classes load,
        /// base classes first, and returns true.  Returns false if some class in the chain doesn't list its own.
        /// </summary>
        public static bool TryListParts(Type arcType, IArcPartLister lister)
        {
            var chain = new Stack<Type>();
            for (Type type = arcType; type != null && !IsArcBase(type); type = type.BaseType)
            {
                chain.Push(type);
            }

            var listers = new List<MethodInfo>();
            foreach (Type type in chain)
            {
                MethodInfo method = type.GetMethod("__ListParts",
                    BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly,
                    binder: null, types: new[] { typeof(IArcPartLister) }, modifiers: null);
                if (method == null)
                {
                    return false;
                }

                listers.Add(method);
            }

            foreach (MethodInfo method in listers)
            {
                method.Invoke(null, new object[] { lister });
            }

            return true;
        }

        private static bool IsArcBase(Type type)
        {
            return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Arc<>);
        }

        /// <summary>
        /// Returns a new <paramref name="arcType"/> loaded from <paramref name="reader"/>.
        /// </summary>
        /// <exception cref="InvalidOperationException">The class has no loading constructor.</exception>
        public static object Create(Type arcType, IArcReader reader)
        {
            return Create(FindConstructor(arcType), reader);
        }

        /// <summary>
        /// Returns a new arc loaded from <paramref name="reader"/> by <paramref name="constructor"/>, one
        /// <see cref="FindConstructor"/> found.
        /// </summary>
        public static object Create(ConstructorInfo constructor, IArcReader reader)
        {
            try
            {
                return constructor.Invoke(new object[] { reader });
            }
            catch (TargetInvocationException exception)
            {
                // The caller wants the save's own error, not reflection's wrapper around it.
                ExceptionDispatchInfo.Capture(exception.InnerException).Throw();
                throw;
            }
        }
    }
}