using System;
using System.Reflection;
using System.Resources;
using System.Windows;
using System.Windows.Markup;
using Developpez.Dotnet.Windows.Properties;

namespace Developpez.Dotnet.Windows.Localization
{
    /// <summary>
    /// Classe de base pour les markup extensions renvoyant une ressource localisée
    /// </summary>
    [MarkupExtensionReturnType(typeof(object))]
    public abstract class LocResourceExtensionBase : MarkupExtension
    {
        /// <summary>
        /// Initialise une nouvelle instance de LocResourceExtensionBase
        /// </summary>
        protected LocResourceExtensionBase() { }

        /// <summary>
        /// Initialise une nouvelle instance de LocResourceExtensionBase, avec la clé de ressource spécifiée
        /// </summary>
        /// <param name="resourceKey">Clé de ressource pour cette instance de LocResourceExtensionBase</param>
        protected LocResourceExtensionBase(string resourceKey)
        {
            this.ResourceKey = resourceKey;
        }

        /// <summary>
        /// Clé de la ressource souhaitée
        /// </summary>
        [ConstructorArgument("resourceKey")]
        public string ResourceKey { get; set; }

        // Objet à mettre à jour lors d'un changement de culture
        // On ne garde qu'une référence faible pour ne pas empêcher que l'objet soit ramassé par le GC
        private WeakReference _targetObjectRef;

        // Propriété à mettre à jour lors d'un changement de culture
        private object _targetProperty;

        // ResourceManager à utiliser pour récupérer les resources
        private ResourceManager _resourceManager;

        #region Implémentation de MarkupExtension

        /// <summary>
        /// Renvoie une version localisée de la ressource spécifiée
        /// </summary>
        /// <param name="serviceProvider">Objet qui peut fournir des services pour la markup extension</param>
        /// <returns>Une version localisée de la ressource spécifiée</returns>
        public sealed override object ProvideValue(IServiceProvider serviceProvider)
        {
            if (string.IsNullOrEmpty(ResourceKey))
                throw new InvalidOperationException(ExceptionMessages.ResourceKeyNotSet);

            // On récupère le ResourceManager en fonction de l'URI
            IUriContext uriContext = serviceProvider.GetService(typeof(IUriContext)) as IUriContext;
            if (uriContext != null)
            {
                _resourceManager = LocalizationManager.GetResourceManager(uriContext);
            }

            // On récupère l'objet et la propriété cible pour pouvoir la mettre à
            // jour lors d'un changement de culture
            IProvideValueTarget target = serviceProvider.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget;
            if (target != null)
            {
                // En mode design, la cible n'est pas définie : elle ne sera donc pas mise à jour
                if (target.TargetObject != null && target.TargetProperty != null)
                {
                    this._targetObjectRef = new WeakReference(target.TargetObject);
                    this._targetProperty = target.TargetProperty;
                    // On s'abonne à l'évènement UICultureChanged pour mettre à jour la propriété
                    LocalizationManager.UICultureChanged += LocManager_UICultureChanged;
                }
            }

            return ProvideValueInternal(_resourceManager);
        }

        #endregion

        /// <summary>
        /// Quand elle est redéfinie dans une classe dérivée, cette méthode renvoie une ressource à partir du ResourceManager spécifié
        /// </summary>
        /// <param name="resourceManager">ResourceManager à partir duquel obtenir la ressource</param>
        /// <returns>La ressource dont la clé est spécifiée par la propriété ResourceKey</returns>
        protected abstract object ProvideValueInternal(ResourceManager resourceManager);

        private void LocManager_UICultureChanged(object sender, EventArgs e)
        {
            Refresh();
        }

        // Cette méthode met à jour la cible pour prendre en compte le changement de culture
        private void Refresh()
        {
            object targetObject = _targetObjectRef.Target;
            // On vérifie que l'objet à mettre à jour existe encore
            if (targetObject == null)
            {
                // L'objet a été ramassé par le GC, on se désabonne de l'évènement UICultureChanged
                LocalizationManager.UICultureChanged -= LocManager_UICultureChanged;
                return;
            }

            object value = ProvideValueInternal(_resourceManager);

            // Si targetProperty est une DependencyProperty, targetObject est un DependencyObject
            // Sinon, targetProperty est un PropertyInfo, et targetObject un object quelconque
            if (_targetProperty is DependencyProperty)
            {
                DependencyObject obj = targetObject as DependencyObject;
                DependencyProperty prop = _targetProperty as DependencyProperty;
                obj.SetValue(prop, value);
            }
            else
            {
                PropertyInfo prop = _targetProperty as PropertyInfo;
                prop.SetValue(targetObject, value, null);
            }
        }
    }

}