using System;
using System.ComponentModel;
using System.Diagnostics;
using Developpez.Dotnet.Windows.Service;

namespace Developpez.Dotnet.Windows.ViewModel
{
    /// <summary>
    /// Classe de base pour toutes les classes ViewModel (Vue-Modèle) dans le cadre du pattern MVVM
    /// Fournit le support pour la notification de changement des propriétés (interface INotifyPropertyChanged)
    /// et propose une propriété DisplayName. Cette classe est abstraite.
    /// </summary>
    /// <remarks>Cette classe a été proposée par Josh Smith dans son article sur le pattern MVVM.</remarks>
    public abstract class ViewModelBase : IDisposable, INotifyPropertyChanged
    {

        #region Constructeur

        /// <summary>
        /// Crée une nouvelle instance de ViewModelBase. Ce constructeur est protégé et ne peut
        /// être appelé que par les classes dérivées.
        /// </summary>
        protected ViewModelBase()
        {
        }

        #endregion // Constructeur

        #region Propriétés publiques

        /// <summary>
        /// Renvoie le nom convivial de cet objet.
        /// Les classes dérivées peuvent affecter une nouvelle valeur à cette propriété,
        /// ou modifier son implémentation pour déterminer la valeur à la demande
        /// </summary>
        public virtual string DisplayName
        {
            get;
            protected set;
        }

        #endregion // Propriétés publiques

        #region Utilitaires de débogage

        /// <summary>
        /// Avertit le développeur si cet objet n'a pas de propriété avec le nom spécifié.
        /// Cette méthode n'existe pas en version Release.
        /// </summary>
        /// <param name="propertyName">Nom de la propriété</param>
        [Conditional("DEBUG")]
        [DebuggerStepThrough]
        public void VerifyPropertyName(string propertyName)
        {
            // Vérifie que le nom de propriété correspond à une vraie
            // propriété publique d'instance de l'objet
            if (TypeDescriptor.GetProperties(this)[propertyName] == null)
            {
                string msg = string.Format(ExceptionMessages.BadPropertyName, propertyName);

                if (this.ThrowOnInvalidPropertyName)
                    throw new Exception(msg);
                else
                    Debug.Fail(msg);
            }
        }

        /// <summary>
        /// Indique si une exception doit être levée, ou si Debug.Fail est utilisé quand
        /// un nom de propriété incorrect est passé à la méthode VerifyPropertyName.
        /// La valeur par défaut est false, mais les classes dérivées peuvent modifier ce
        /// comportement.
        /// </summary>
        public virtual bool ThrowOnInvalidPropertyName
        {
            get;
            protected set;
        }

        #endregion // Utilitaires de débogage

        #region Membres de INotifyPropertyChanged

        /// <summary>
        /// Se produit quand la valeur d'une propriété de cet objet est modifiée
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Déclenche l'évènement PropertyChanged sur cet objet.
        /// </summary>
        /// <param name="propertyName">La propriété dont la valeur a changé</param>
        protected virtual void OnPropertyChanged(string propertyName)
        {
            this.VerifyPropertyName(propertyName);

            PropertyChangedEventHandler handler = this.PropertyChanged;
            if (handler != null)
            {
                var e = new PropertyChangedEventArgs(propertyName);
                handler(this, e);
            }
        }

        #endregion // Membres de INotifyPropertyChanged

        #region Membres de IDisposable

        /// <summary>
        /// Appelé pour libérer les ressources liées à cet objet
        /// </summary>
        public void Dispose()
        {
            this.OnDispose();
        }

        /// <summary>
        /// Les classes dérivées peuvent redéfinir cette méthode pour effectuer
        /// des opérations de nettoyage, comme la suppression de gestionnaires d'évènement
        /// </summary>
        protected virtual void OnDispose()
        {
        }

#if DEBUG
        /// <summary>
        /// Utile pour vérifier que les objets ViewModel sont correctement ramassés par le
        /// garbage collector.
        /// </summary>
        ~ViewModelBase()
        {
            string msg = string.Format("{0} ({1}) ({2}) Finalized", this.GetType().Name, this.DisplayName, this.GetHashCode());
            System.Diagnostics.Debug.WriteLine(msg);
        }
#endif

        #endregion // Membres de IDisposable

        #region GetService

        /// <summary>
        /// Renvoie le service du type spécifié avec le nom spécifié
        /// </summary>
        /// <typeparam name="TService">Type du service</typeparam>
        /// <param name="name">Nom du service</param>
        /// <returns>Le service demandé s'il existe. Sinon, une ServiceNotFoundException est levée.</returns>
        public virtual TService GetService<TService>(string name)
        {
            return ServiceLocator.Instance.GetService<TService>(name);
        }

        /// <summary>
        /// Renvoie le service sans nom du type spécifié
        /// </summary>
        /// <typeparam name="TService">Type du service</typeparam>
        /// <returns>Le service demandé s'il existe. Sinon, une ServiceNotFoundException est levée.</returns>
        public TService GetService<TService>()
        {
            return GetService<TService>(null);
        }

        #endregion
    }

    /// <summary>
    /// Classe de base pour un ViewModel qui expose le modèle via une propriété fortement typée
    /// </summary>
    /// <typeparam name="TModel">Type du modèle</typeparam>
    public abstract class ViewModelBase<TModel> : ViewModelBase
    {
        /// <summary>
        /// Renvoie le modèle lié à ce ViewModel
        /// </summary>
        public TModel Model { get; protected set; }
    }
}