inabox/InABox.Core/Postable/PosterUtils.cs

using InABox.Configuration;
using InABox.Core.Postable;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime;
using System.Text;

namespace InABox.Core
{
    public static class PosterUtils
    {
        private class EngineType
        {
            public Type Engine { get; set; }

            public Type Entity { get; set; }

            public Type Poster { get; set; }
        }

        private static EngineType[]? _posterEngines;
        private static Type[]? _posters = null;

        public static Type[] GetPosters()
        {
            _posters ??= CoreUtils.TypeList(
                AppDomain.CurrentDomain.GetAssemblies(),
                x => x.IsClass
                    && !x.IsAbstract
                    && !x.IsGenericType
                    && x.HasInterface(typeof(IPoster<,>))).ToArray();
            return _posters;
        }

        private static EngineType[] GetPosterEngines()
        {
            _posterEngines ??= CoreUtils.TypeList(
                AppDomain.CurrentDomain.GetAssemblies(),
                x => x.IsClass
                    && !x.IsAbstract
                    && x.GetTypeInfo().GenericTypeParameters.Length == 1
                    && x.HasInterface(typeof(IPosterEngine<,,>))
            ).Select(x => new EngineType
            {
                Engine = x,
                Entity = x.GetInterfaceDefinition(typeof(IPosterEngine<,,>))!.GenericTypeArguments[0],
                Poster = x.GetInterfaceDefinition(typeof(IPosterEngine<,,>))!.GenericTypeArguments[1].GetGenericTypeDefinition()
            }).ToArray();
            return _posterEngines;
        }

        #region Postable Settings

        private static PostableSettings FixPostableSettings<TPostable>(PostableSettings settings)
            where TPostable : Entity, IPostable
        {
            if (string.IsNullOrWhiteSpace(settings.PostableType))
            {
                settings.PostableType = typeof(TPostable).EntityName();
            }
            return settings;
        }

        public static PostableSettings LoadPostableSettings<T>()
            where T : Entity, IPostable
        {
            return FixPostableSettings<T>(new GlobalConfiguration<PostableSettings>(typeof(T).Name).Load());
        }

        public static void SavePostableSettings<T>(PostableSettings settings)
            where T : Entity, IPostable
        {
            new GlobalConfiguration<PostableSettings>(typeof(T).Name).Save(FixPostableSettings<T>(settings));
        }

        #endregion

        #region Poster Settings

        private static TSettings FixPosterSettings<TPostable, TSettings>(TSettings settings)
            where TPostable : IPostable
            where TSettings : PosterSettings, new()
        {
            if (string.IsNullOrWhiteSpace(settings.PostableType))
            {
                settings.PostableType = typeof(TPostable).EntityName();
            }
            return settings;
        }

        private static MethodInfo _loadPosterSettingsMethod = typeof(PosterUtils).GetMethods(BindingFlags.Static | BindingFlags.Public)
            .Where(x => x.Name == nameof(LoadPosterSettings) && x.IsGenericMethod)
            .Single();
        private static MethodInfo _savePosterSettingsMethod = typeof(PosterUtils).GetMethods(BindingFlags.Static | BindingFlags.Public)
            .Where(x => x.Name == nameof(SavePosterSettings) && x.IsGenericMethod)
            .Single();

        public static TSettings LoadPosterSettings<TPostable, TSettings>()
            where TPostable : IPostable
            where TSettings : PosterSettings, new()
        {
            return FixPosterSettings<TPostable, TSettings>(new GlobalConfiguration<TSettings>(typeof(TPostable).Name).Load());
        }

        public static PosterSettings LoadPosterSettings(Type TPostable, Type TSettings)
        {
            return (_loadPosterSettingsMethod.MakeGenericMethod(TPostable, TSettings).Invoke(null, Array.Empty<object>()) as PosterSettings)!;
        }

        public static void SavePosterSettings<TPostable, TSettings>(TSettings settings)
            where TPostable : IPostable
            where TSettings : PosterSettings, new()
        {
            new GlobalConfiguration<TSettings>(typeof(TPostable).Name).Save(FixPosterSettings<TPostable, TSettings>(settings));
        }

        public static void SavePosterSettings(Type TPostable, Type TSettings, PosterSettings settings)
        {
            _savePosterSettingsMethod.MakeGenericMethod(TPostable, TSettings).Invoke(null, new object[] { settings });
        }

        #endregion

        #region Global Poster Settings

        private static MethodInfo _loadGlobalPosterSettingsMethod = typeof(PosterUtils).GetMethods(BindingFlags.Static | BindingFlags.Public)
            .Where(x => x.Name == nameof(LoadGlobalPosterSettings) && x.IsGenericMethod)
            .Single();
        private static MethodInfo _saveGlobalPosterSettingsMethod = typeof(PosterUtils).GetMethods(BindingFlags.Static | BindingFlags.Public)
            .Where(x => x.Name == nameof(SaveGlobalPosterSettings) && x.IsGenericMethod)
            .Single();

        public static IGlobalPosterSettings LoadGlobalPosterSettings(Type TGlobalSettings)
        {
            return (_loadGlobalPosterSettingsMethod.MakeGenericMethod(TGlobalSettings).Invoke(null, Array.Empty<object>()) as IGlobalPosterSettings)!;
        }
        public static TGlobalSettings LoadGlobalPosterSettings<TGlobalSettings>()
            where TGlobalSettings : BaseObject, IGlobalPosterSettings, new()
        {
            return new GlobalConfiguration<TGlobalSettings>().Load();
        }

        public static void SaveGlobalPosterSettings<TGlobalSettings>(TGlobalSettings settings)
            where TGlobalSettings : BaseObject, IGlobalPosterSettings, new()
        {
            new GlobalConfiguration<TGlobalSettings>().Save(settings);
        }

        public static void SaveGlobalPosterSettings(Type TGlobalSettings, IGlobalPosterSettings settings)
        {
            _saveGlobalPosterSettingsMethod.MakeGenericMethod(TGlobalSettings).Invoke(null, new object[] { settings });
        }

        #endregion

        /// <summary>
        /// Get the <see cref="IPosterEngine{TPostable,TPoster,TSettings}"/> for <typeparamref name="T"/>
        /// based on the current <see cref="PostableSettings"/> for <typeparamref name="T"/>.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static Type GetEngine<T>()
            where T : Entity, IPostable, IRemotable, IPersistent, new()
        {
            var settings = LoadPostableSettings<T>();
            if (string.IsNullOrWhiteSpace(settings.PosterType))
            {
                throw new MissingSettingsException(typeof(T));
            }
            var poster = GetPosters()?.FirstOrDefault(x => x.EntityName() == settings.PosterType)!;

            var engines = GetPosterEngines().Where(x => poster.HasInterface(x.Poster)).ToList();
            if (!engines.Any())
            {
                throw new Exception("No poster for the given settings.");
            }
            else if(engines.Count == 1)
            {
                return engines[0].Engine.MakeGenericType(typeof(T));
            }
            else
            {
                return engines.Single(x => x.Entity == typeof(T)).Engine.MakeGenericType(typeof(T));
            }
        }

        public static IPosterEngine<T> CreateEngine<T>()
            where T : Entity, IPostable, IRemotable, IPersistent, new()
        {
            var engine = GetEngine<T>();
            return (Activator.CreateInstance(engine) as IPosterEngine<T>)!;
        }

        /// <summary>
        /// Process <paramref name="model"/> with the currently set <see cref="IPosterEngine{TPostable, TPoster, TSettings}"/>
        /// for <typeparamref name="T"/>.
        /// </summary>
        /// <typeparam name="T">The type of <paramref name="model"/> that needs to be processed.</typeparam>
        /// <param name="model"></param>
        /// <exception cref="EmptyPostException">If there are no items to post. In this case, nothing happens.</exception>
        /// <exception cref="RepostedException">If any of the <typeparamref name="T"/> have already been processed. In this case, nothing happens.</exception>
        /// <exception cref="MissingSettingsException">If the <see cref="PostableSettings"/> for <typeparamref name="T"/> do not exist.</exception>
        /// <exception cref="PostCancelledException">If the post has been cancelled by the user.</exception>
        /// <returns><see langword="null"/> if post was unsuccessful.</returns>
        /// 
        public static IPostResult<T>? Process<T>(IDataModel<T> model)
            where T : Entity, IPostable, IRemotable, IPersistent, new()
        {
            return CreateEngine<T>().Process(model);
        }
    }
}