using System;
using System.Threading.Tasks;
using SimpleInjector;
using System.Reflection;
using SimpleInjector.Lifestyles;

namespace TestCore
{
    class Program
    {
        public abstract class BaseDecorator<TIn, TOut> : IDecoratorHandler<TIn, TOut>
        {
            protected bool _isDecoratorInjected;
            protected IHandler<TIn, TOut> _decorated;
            public IHandler<TIn, TOut> NextHandler { get; private set; }

            public BaseDecorator() { }

            public abstract Task<TOut> Handle(TIn input);

            public void InjectDecorator(IHandler<TIn, TOut> handler)
            {
                if (_isDecoratorInjected)
                    throw new InvalidOperationException("Decorator already has injected");

                _isDecoratorInjected = true;
                _decorated = handler;
            }
        }

        public class IntegrationSenderDecorator<TIn, TOut> : BaseDecorator<TIn, TOut>
        {
            public IntegrationSenderDecorator() { }

            public override async Task<TOut> Handle(TIn input)
            {
                var res = await _decorated.Handle(input);
                // ...
                return res;
            }
        }

        public class SaveChangesDecorator<TIn, TOut> : BaseDecorator<TIn, TOut>
        {
            public SaveChangesDecorator() { }

            public override async Task<TOut> Handle(TIn input)
            {
                var res = await _decorated.Handle(input);
                // ...
                return res;
            }
        }

        public class OrderCreatedCmdHandler : IHandler<string, int>
        {
            public OrderCreatedCmdHandler(
                IntegrationSenderDecorator<string, int> integrationSenderDecorator,
                SaveChangesDecorator<string, int> saveChangesDecorator)
            {
                //_pipeline = DecoratorPipelineBuilder<string, int>.Create()
                //    .Add(integrationSenderDecorator)
                //    .Add(saveChangesDecorator)
                //    .Build(logicHandler); // skip

                // analog Build code:
                integrationSenderDecorator.InjectDecorator(saveChangesDecorator);
            }

            public async Task<int> Handle(string input)
            {
                return 123;
            }
        }

        public interface IDecoratorHandler<TIn, TOut> : IHandler<TIn, TOut>
        {
            IHandler<TIn, TOut> NextHandler { get; }

            void InjectDecorator(IHandler<TIn, TOut> handler);
        }
        
        public interface IHandler<in TIn, TOut>
        {
            Task<TOut> Handle(TIn input);
        }

        public class IntegrationEventHandler1
        {
            public IntegrationEventHandler1(IHandler<string, int> cmdHandler) { }
        }

        public class IntegrationEventHandler2
        {
            public IntegrationEventHandler2(IHandler<string, int> cmdHandler) { }
            //public IntegrationEventHandler2(/*IHandler<string, int> cmdHandler*/) { } // Everything is working
        }

        static void Main(string[] args)
        {
            var container = new Container();
            container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
            container.Options.DefaultLifestyle = Lifestyle.Scoped;
            //container.Options.DefaultLifestyle = Lifestyle.Transient; // Everything is working
            container.Register<IHandler<string, int>, OrderCreatedCmdHandler>(Lifestyle.Transient);
            container.Register<IntegrationEventHandler1>(Lifestyle.Transient);
            container.Register<IntegrationEventHandler2>(Lifestyle.Transient);

            var typesToRegister = container.GetTypesToRegister(typeof(IDecoratorHandler<,>), 
                new Assembly[] { typeof(Program).Assembly },
                new TypesToRegisterOptions {
                    IncludeGenericTypeDefinitions = true,
                    IncludeComposites = false
                });

            container.Collection.Register(typeof(IDecoratorHandler<,>), typesToRegister);
            container.Verify();
        }
    }
}