using System.Collections.Generic;
using System.Reflection;
using Caliburn.Events.Brokering;
using Spring.Objects.Factory.Config;

namespace Caliburn.Spring
{
    public class EventRegistrationObjectPostProcessor : IObjectPostProcessor
    {
        private readonly Dictionary<string, IDictionary<PublishAttribute, EventInfo>> _publishers =
            new Dictionary<string, IDictionary<PublishAttribute, EventInfo>>();

        private readonly Dictionary<string, IDictionary<SubscribeAttribute, MethodInfo>> _subscribers =
            new Dictionary<string, IDictionary<SubscribeAttribute, MethodInfo>>();

        private static IEventBroker _eventBroker
        {
            get { return DI.Resolve<IEventBroker>(); }
        }

        #region IObjectPostProcessor Members

        public object PostProcessBeforeInitialization(object instance, string name)
        {
            return instance;
        }

        public object PostProcessAfterInitialization(object instance, string objectName)
        {
            return WireEvents(instance, objectName);
        }

        #endregion

        private object WireEvents(object instance, string name)
        {
            HandleSubscribers(instance, name);
            HandlePublishers(instance, name);
            return instance;
        }

        private void HandleSubscribers(object instance, string name)
        {
            IDictionary<SubscribeAttribute, MethodInfo> subscribedMethods = GetSubscribedMethods(instance, name);

            foreach(KeyValuePair<SubscribeAttribute, MethodInfo> subscribedMethod in subscribedMethods)
            {
                _eventBroker.Subscribe(
                    subscribedMethod.Key.EventNodeName,
                    new Subscription(instance, subscribedMethod.Value, subscribedMethod.Key.IsAsync)
                    );
            }
        }

        private IDictionary<SubscribeAttribute, MethodInfo> GetSubscribedMethods(object instance, string name)
        {
            IDictionary<SubscribeAttribute, MethodInfo> subscribedMethods;

            if(!_subscribers.TryGetValue(name, out subscribedMethods))
            {
                subscribedMethods = _eventBroker.GetSubscribedMethods(instance.GetType());
                _subscribers[name] = subscribedMethods;
            }

            return subscribedMethods;
        }

        private void HandlePublishers(object instance, string name)
        {
            IDictionary<PublishAttribute, EventInfo> publishedEvents = GetPublishedEvents(instance, name);

            foreach(KeyValuePair<PublishAttribute, EventInfo> publishedEvent in publishedEvents)
            {
                _eventBroker.Publish(
                    instance,
                    publishedEvent.Value,
                    publishedEvent.Key.BuildPublication()
                    );
            }
        }

        private IDictionary<PublishAttribute, EventInfo> GetPublishedEvents(object instance, string name)
        {
            IDictionary<PublishAttribute, EventInfo> publishedEvents;

            if(!_publishers.TryGetValue(name, out publishedEvents))
            {
                publishedEvents = _eventBroker.GetPublishedEvents(instance.GetType());
                _publishers[name] = publishedEvents;
            }

            return publishedEvents;
        }
    }
}