using System;
using System.ComponentModel;
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 est inspirée de celle 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 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>
        /// Raccourci pour vérifier si la valeur d'une propriété est modifiée,
        /// affecter la nouvelle valeur au champ, et déclencher si besoin l'évènement
        /// PropertyChanged.
        /// </summary>
        /// <typeparam name="T">Type de la propriété</typeparam>
        /// <param name="backingField">Champ qui stocke la valeur de la propriété</param>
        /// <param name="newValue">Nouvelle valeur affectée à la propriété</param>
        /// <param name="propertyName">Nom de la propriété</param>
        protected void SetProperty<T>(ref T backingField, T newValue, string propertyName)
        {
            if (!Equals(backingField, newValue))
            {
                backingField = newValue;
                OnPropertyChanged(propertyName);
            }
        }

        /// <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)
        {
            PropertyChangedEventHandler handler = this.PropertyChanged;
            if (handler != null)
                handler(this, new PropertyChangedEventArgs(propertyName));
        }

        #endregion // Membres de INotifyPropertyChanged

        #region Membres de IDisposable

        /// <summary>
        /// Libère les ressources liées à cet objet
        /// </summary>
        public virtual void Dispose()
        {
        }

        #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; }
    }
}