using System;
using System.Reflection;

namespace Caliburn.Events
{
    public static class LooseEvent
    {
        private static readonly Type genericEventHandlerType = typeof(GenericEventHandler<,,,>);

        public static IEventHandler Wire(object sender, string eventName)
        {
            EventInfo eventInfo = sender.GetType().GetEvent(eventName);
            return Wire(sender, eventInfo);
        }

        public static IEventHandler Wire(object sender, EventInfo eventInfo)
        {
            ParameterInfo[] parameters = eventInfo.EventHandlerType.GetMethod("Invoke").GetParameters();

            Type[] typeParameters = GetTypeParamters(parameters);

            IEventHandler handler = (IEventHandler) Activator.CreateInstance(
                                                        genericEventHandlerType.MakeGenericType(typeParameters)
                                                        );

            eventInfo.AddEventHandler(
                sender,
                Delegate.CreateDelegate(eventInfo.EventHandlerType, handler, "Invoke")
                );

            return handler;
        }

        private static Type[] GetTypeParamters(ParameterInfo[] parameters)
        {
            switch(parameters.Length)
            {
                case 0:
                    return new Type[]
                        {
                            typeof(object),
                            typeof(object),
                            typeof(object),
                            typeof(object)
                        };
                case 1:
                    return new Type[]
                        {
                            parameters[0].ParameterType,
                            typeof(object),
                            typeof(object),
                            typeof(object)
                        };
                case 2:
                    return new Type[]
                        {
                            parameters[0].ParameterType,
                            parameters[1].ParameterType,
                            typeof(object),
                            typeof(object)
                        };
                case 3:
                    return new Type[]
                        {
                            parameters[0].ParameterType,
                            parameters[1].ParameterType,
                            parameters[2].ParameterType,
                            typeof(object)
                        };
                case 4:
                    return new Type[]
                        {
                            parameters[0].ParameterType,
                            parameters[1].ParameterType,
                            parameters[2].ParameterType,
                            parameters[3].ParameterType
                        };
                default:
                    throw new CaliburnException("Cannot bind to events with more than four paramters.");
            }
        }
    }
}