using System.Reflection;
using System.Windows;
using Caliburn.Actions;
using Caliburn.Messaging;

namespace Caliburn.Metadata
{
    public class ActionInfo : InfoBase
    {
        #region Fields

        private ActionExecutor _executor;
        private MethodInfo _methodInfo;
        private PresenterInfo _owner;
        private ParameterInfo[] _parameters;

        #endregion

        #region Constructor

        private ActionInfo() {}

        #endregion

        #region Properties

        public string Name
        {
            get { return _methodInfo.Name; }
        }

        public MethodInfo MethodInfo
        {
            get { return _methodInfo; }
        }

        public PresenterInfo Owner
        {
            get { return _owner; }
        }

        public ParameterInfo[] Parameters
        {
            get { return _parameters; }
        }

        public ActionExecutor Executor
        {
            get { return _executor; }
        }

        #endregion

        #region Methods

        public void Execute(object target, ActionMessage message, DependencyObject messageSource)
        {
            _executor.Execute(messageSource, message, target);
        }

        #endregion

        #region Factory

        public static ActionInfo Create(PresenterInfo owner, MethodInfo methodInfo)
        {
            ActionInfo actionInfo = new ActionInfo();

            actionInfo._owner = owner;
            actionInfo._methodInfo = methodInfo;
            actionInfo._parameters = methodInfo.GetParameters();

            LoadMetadata(methodInfo, actionInfo);

            return actionInfo;
        }

        private static void LoadMetadata(MethodInfo methodInfo, ActionInfo actionInfo)
        {
            object[] attributes = methodInfo.GetCustomAttributes(true);

            foreach(object att in attributes)
            {
                MetadataProvider provider = att as MetadataProvider;
                if(provider != null) actionInfo.AddMetadata(provider);
                else
                {
                    ActionAttribute actionAttribute = att as ActionAttribute;
                    if(actionAttribute != null)
                    {
                        if(!string.IsNullOrEmpty(actionAttribute.Rescue))
                            actionInfo.InitializeRescue(methodInfo.DeclaringType, actionAttribute.Rescue);

                        AsyncActionAttribute asyncActionAttribute = actionAttribute as AsyncActionAttribute;
                        if(asyncActionAttribute != null)
                        {
                            AsynchronousActionExecutor executor = new AsynchronousActionExecutor(actionInfo);

                            if(!string.IsNullOrEmpty(asyncActionAttribute.Callback))
                                executor.InitializeCallback(methodInfo.DeclaringType, asyncActionAttribute.Callback);

                            actionInfo._executor = executor;
                        }
                        else actionInfo._executor = new SynchronousActionExecutor(actionInfo);
                    }
                }
            }

            if(actionInfo._executor == null)
                actionInfo._executor = new SynchronousActionExecutor(actionInfo);
        }

        #endregion
    }
}