using System.Collections.Generic;
using System.Reflection;
using Caliburn.Events.Brokering;
using Castle.Core;
using Castle.MicroKernel.Facilities;

namespace Caliburn.Castle
{
    public class EventRegistrationFacility : AbstractFacility
    {
        private IEventBroker _eventBroker;

        protected override void Init()
        {
            Kernel.AddComponent("IEventBroker", typeof(IEventBroker), typeof(EventBroker));
            _eventBroker = (IEventBroker) Kernel.Resolve(typeof(IEventBroker));

            Kernel.ComponentModelBuilder.AddContributor(new EventPublicationContributer(_eventBroker));
            Kernel.ComponentModelBuilder.AddContributor(new EventSubscriptionContributer(_eventBroker));

            Kernel.ComponentCreated += Kernel_ComponentCreated;
        }

        private void Kernel_ComponentCreated(ComponentModel model, object instance)
        {
            HandlePublishers(instance, model);
            HandleSubscribers(instance, model);
        }

        private void HandleSubscribers(object instance, ComponentModel model)
        {
            IDictionary<SubscribeAttribute, MethodInfo> subscribedMethods =
                (IDictionary<SubscribeAttribute, MethodInfo>)
                model.ExtendedProperties[EventSubscriptionContributer.SubcsribedMethods];

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

        private void HandlePublishers(object instance, ComponentModel model)
        {
            IDictionary<PublishAttribute, EventInfo> publishedEvents =
                (IDictionary<PublishAttribute, EventInfo>)
                model.ExtendedProperties[EventPublicationContributer.PublishedEvents];

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