using System;
using System.Reflection;
using System.Windows;
using System.Windows.Input;
using System.Windows.Markup;

namespace Developpez.Dotnet.Windows.Input
{
    /// <summary>
    /// Permet de binder la commande d'un InputBinding sur une commande du DataContext
    /// </summary>
    /// <remarks>Le binding n'est possible que sur le DataContext de la racine du document XAML</remarks>
    [MarkupExtensionReturnType(typeof(ICommand))]
    public class CommandBindingExtension : MarkupExtension
    {
        /// <summary>
        /// Crée une instance de CommandBindingExtension
        /// </summary>
        public CommandBindingExtension()
        {
        }

        /// <summary>
        /// Crée une instance de CommandBindingExtension avec le nom de commande spécifié
        /// </summary>
        /// <param name="commandName">Nom de la commande dans le DataContext</param>
        public CommandBindingExtension(string commandName)
        {
            this.CommandName = commandName;
        }

        /// <summary>
        /// Nom de la commande dans le DataContext
        /// </summary>
        [ConstructorArgument("commandName")]
        public string CommandName { get; set; }

        /// <summary>
        /// Objet cible de la markup extension
        /// </summary>
        protected object TargetObject { get; set; }

        /// <summary>
        /// Propriété cible de la markup extension
        /// </summary>
        protected object TargetProperty { get; set; }

        /// <summary>
        /// Renvoie la commande à affecter à la propriété cible
        /// </summary>
        /// <param name="serviceProvider">Objet qui peut fournir des services pour la markup extension</param>
        /// <returns>La commande à affecter à la propriété cible</returns>
        public override object ProvideValue(IServiceProvider serviceProvider)
        {
            IProvideValueTarget provideValueTarget = serviceProvider.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget;
            if (provideValueTarget != null)
            {
                TargetObject = provideValueTarget.TargetObject;
                TargetProperty = provideValueTarget.TargetProperty;
            }

            if (!string.IsNullOrEmpty(CommandName))
            {
                ParserContext parserContext = GetPrivateFieldValue<ParserContext>(serviceProvider, "_context");
                if (parserContext != null)
                {
                    FrameworkElement rootElement = GetPrivateFieldValue<FrameworkElement>(parserContext, "_rootElement");
                    if (rootElement != null)
                    {
                        object dataContext = rootElement.DataContext;
                        if (dataContext != null)
                        {
                            ICommand command = GetCommand(dataContext, CommandName);
                            if (command != null)
                                return command;
                        }
                        else
                        {
                            if (!dataContextChangeHandlerSet)
                            {
                                rootElement.DataContextChanged += new DependencyPropertyChangedEventHandler(rootElement_DataContextChanged);
                                dataContextChangeHandlerSet = true;
                            }
                        }
                    }
                }
            }

            return DummyCommand.Instance;
        }

        /// <summary>
        /// Renvoie la commande spécifiée de l'objet spécifié.
        /// </summary>
        /// <param name="dataContext">L'objet dont on veut récupérer une commande</param>
        /// <param name="commandName">Le nom de la commande</param>
        /// <returns>L'objet ICommand demandé, si la propriété existe
        /// et est une commande, null dans les autres cas</returns>
        private ICommand GetCommand(object dataContext, string commandName)
        {
            PropertyInfo prop = dataContext.GetType().GetProperty(commandName);
            if (prop != null)
            {
                ICommand command = prop.GetValue(dataContext, null) as ICommand;
                return command;
            }
            return null;
        }

        /// <summary>
        /// Affecte la commande à la propriété cible
        /// </summary>
        /// <param name="command">La commande à affecter</param>
        private void AssignCommand(ICommand command)
        {
            if (TargetObject != null && TargetProperty != null)
            {
                if (TargetProperty is DependencyProperty)
                {
                    DependencyObject depObj = TargetObject as DependencyObject;
                    DependencyProperty depProp = TargetProperty as DependencyProperty;
                    depObj.SetValue(depProp, command);
                }
                else
                {
                    PropertyInfo prop = TargetProperty as PropertyInfo;
                    prop.SetValue(TargetObject, command, null);
                }
            }
        }

        private bool dataContextChangeHandlerSet = false;

        /// <summary>
        /// En cas de changement du DataContext, actualise la propriété cible avec la commande
        /// du nouveau DataContext
        /// </summary>
        private void rootElement_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
        {
            FrameworkElement rootElement = sender as FrameworkElement;
            if (rootElement != null)
            {
                object dataContext = rootElement.DataContext;
                if (dataContext != null)
                {
                    ICommand command = GetCommand(dataContext, CommandName);
                    if (command != null)
                    {
                        AssignCommand(command);
                    }
                }
            }
        }

        /// <summary>
        /// Renvoie la valeur d'un champ non public d'un objet
        /// </summary>
        /// <typeparam name="T">Type du champ à obtenir</typeparam>
        /// <param name="target">Objet dont on veut obtenir la valeur du champ</param>
        /// <param name="fieldName">Nom du champ</param>
        /// <returns>La valeur de ce champ s'il existe, ou la valeur par défaut du type spécifié si le champ n'existe pas</returns>
        private T GetPrivateFieldValue<T>(object target, string fieldName)
        {
            FieldInfo field = target.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic);
            if (field != null)
            {
                return (T)field.GetValue(target);
            }
            return default(T);
        }

        /// <summary>
        /// Commande "bouchon" qui ne fait rien, utilisée comme commande par défaut
        /// </summary>
        private class DummyCommand : ICommand
        {

            #region Pattern Singleton

            /// <summary>
            /// Constructeur privé
            /// </summary>
            private DummyCommand()
            {
            }

            private static DummyCommand _instance = null;

            /// <summary>
            /// Renvoie l'instance unique de la classe
            /// </summary>
            public static DummyCommand Instance
            {
                get
                {
                    if (_instance == null)
                    {
                        _instance = new DummyCommand();
                    }
                    return _instance;
                }
            }

            #endregion // Pattern Singleton

            #region Membres de ICommand

            /// <summary>
            /// Indique si la commande peut être exécutée
            /// </summary>
            /// <param name="parameter">Paramètre de la commande</param>
            /// <returns>Renvoie toujours false</returns>
            public bool CanExecute(object parameter)
            {
                return false;
            }

            /// <summary>
            /// Se produit lorsque des modifications influent sur l'exécution de la commande
            /// Inutilisé, présent uniquement pour se conformer à l'interface
            /// </summary>
            event EventHandler ICommand.CanExecuteChanged
            {
                add { }
                remove { }
            }

            /// <summary>
            /// Ne fait rien
            /// </summary>
            /// <param name="parameter">Paramètre de la commande</param>
            public void Execute(object parameter)
            {
            }

            #endregion // Membres de ICommand
        }
    }
}