#region

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using EIT.Foundation.Diagnostics;
using Ninject;
using Ninject.Components;
using Ninject.Extensions.Interception;
using Ninject.Extensions.Interception.Advice;
using Ninject.Extensions.Interception.Planning.Directives;
using Ninject.Extensions.Interception.Registry;
using Ninject.Planning;
using Ninject.Planning.Strategies;

#endregion

namespace EIT.Foundation.Interception.Ninject
{
    public class AttributeInterceptionStrategy<TAttribute, TInterceptor>
        : NinjectComponent, IPlanningStrategy
        where TAttribute : Attribute
        where TInterceptor : IInterceptor
    {
        private readonly IAdviceFactory _adviceFactory;
        private readonly IAdviceRegistry _adviceRegistry;

        public AttributeInterceptionStrategy(IAdviceFactory adviceFactory, IAdviceRegistry adviceRegistry)
        {
            Guard.AgainstNullArgument("adviceFactory", adviceFactory);
            Guard.AgainstNullArgument("adviceRegistry", adviceRegistry);

            _adviceFactory = adviceFactory;
            _adviceRegistry = adviceRegistry;
        }

        public void Execute(IPlan plan)
        {
            var methods = GetCandidateMethods(plan.Type);
            foreach (var advice in from method in methods
                let attributes = method.GetCustomAttributes(
                    typeof (TAttribute), true) as TAttribute[]
                where attributes == null ||
                      attributes.Length != 0
                select _adviceFactory.Create(method))
            {
                advice.Callback = request => request.Kernel.Get<TInterceptor>();
                _adviceRegistry.Register(advice);

                if (!plan.Has<ProxyDirective>())
                {
                    plan.Add(new ProxyDirective());
                }
            }
        }

        private static IEnumerable<MethodInfo> GetCandidateMethods(IReflect type)
        {
            var methods = type.GetMethods(
                BindingFlags.Public |
                BindingFlags.NonPublic |
                BindingFlags.Instance
                );

            return methods.Where(ShouldIntercept);
        }

        private static bool ShouldIntercept(MethodInfo methodInfo)
        {
            var result = methodInfo.DeclaringType != typeof (object) &&
                   !methodInfo.IsPrivate &&
                   !methodInfo.IsFinal;
            return result;
        }
    }
}