using System;
using System.Collections.Generic;

namespace Developpez.Dotnet.Windows.Service
{
    /// <summary>
    /// Fournit un accès global à un ensemble de services via leur interface et éventuellement leur nom
    /// </summary>
    public sealed class ServiceLocator : IServiceProvider
    {
        #region Private data

        private readonly Dictionary<Type, Dictionary<string, object>> _services;

        #endregion

        #region Constructor

        private ServiceLocator()
        {
            _services = new Dictionary<Type, Dictionary<string, object>>();
        }

        #endregion

        #region Singleton implementation

        private readonly static ServiceLocator _instance;

        static ServiceLocator()
        {
            _instance = new ServiceLocator();
        }

        /// <summary>
        /// Renvoie l'unique instance de la classe ServiceLocator
        /// </summary>
        public static ServiceLocator Instance
        {
            get { return _instance; }
        }

        #endregion

        #region RegisterService methods

        /// <summary>
        /// Inscrit un service en spécifiant le type de l'interface, le nom du service et l'objet qui implémente le service.
        /// </summary>
        /// <param name="serviceType">Interface du service</param>
        /// <param name="name">Nom du service</param>
        /// <param name="service">Implémentation du service</param>
        public void RegisterService(Type serviceType, string name, object service)
        {
            lock (_services)
            {
                var services = GetServicesForType(serviceType, true);
                services.Add(name ?? string.Empty, service);
            }
        }

        /// <summary>
        /// Inscrit un service en spécifiant le type de l'interface et l'objet qui implémente le service.
        /// Le nom utilisé pour le service est une chaine vide.
        /// </summary>
        /// <param name="serviceType">Interface du service</param>
        /// <param name="service">Implémentation du service</param>
        public void RegisterService(Type serviceType, object service)
        {
            RegisterService(serviceType, string.Empty, service);
        }

        /// <summary>
        /// Inscrit un service en spécifiant le type de l'interface, le nom du service et l'objet qui implémente le service.
        /// </summary>
        /// <typeparam name="T">Interface du service</typeparam>
        /// <param name="name">Nom du service</param>
        /// <param name="service">Implémentation du service</param>
        public void RegisterService<T>(string name, T service)
        {
            RegisterService(typeof(T), name, service);
        }

        /// <summary>
        /// Inscrit un service en spécifiant le type de l'interface et l'objet qui implémente le service.
        /// Le nom utilisé pour le service est une chaine vide.
        /// </summary>
        /// <typeparam name="T">Interface du service</typeparam>
        /// <param name="service">Implémentation du service</param>
        public void RegisterService<T>(T service)
        {
            RegisterService(typeof(T), string.Empty, service);
        }

        #endregion

        #region GetService methods

        /// <summary>
        /// Obtient un service d'après son interface et son nom.
        /// </summary>
        /// <param name="serviceType">Interface du service</param>
        /// <param name="name">Nom du service</param>
        /// <returns>Le service spécifié s'il existe. Sinon, lève une ServiceNotFoundException</returns>
        public object GetService(Type serviceType, string name)
        {
            var service = GetServiceInternal(serviceType, name);
            if (service == null)
                throw new ServiceNotFoundException(serviceType, name, string.Format("No service registered for type '{0}' and name '{1}'", serviceType.FullName, name));
            return service;
        }

        /// <summary>
        /// Obtient un service sans nom d'après son interface.
        /// </summary>
        /// <param name="serviceType">Interface du service</param>
        /// <returns>Le service spécifié s'il existe. Sinon, lève une ServiceNotFoundException</returns>
        public object GetService(Type serviceType)
        {
            return GetService(serviceType, string.Empty);
        }

        /// <summary>
        /// Obtient un service d'après son interface et son nom.
        /// </summary>
        /// <typeparam name="T">Interface du service</typeparam>
        /// <param name="name">Nom du service</param>
        /// <returns>Le service spécifié s'il existe. Sinon, lève une ServiceNotFoundException</returns>
        public T GetService<T>(string name)
        {
            return (T)GetService(typeof(T), name);
        }

        /// <summary>
        /// Obtient un service sans nom d'après son interface.
        /// </summary>
        /// <typeparam name="T">Interface du service</typeparam>
        /// <returns>Le service spécifié s'il existe. Sinon, lève une ServiceNotFoundException</returns>
        public T GetService<T>()
        {
            return (T)GetService(typeof(T), string.Empty);
        }

        /// <summary>
        /// Implémente explicitement l'interface IServiceProvider. Equivalent à
        /// ServiceLocator.GetService(Type), mais renvoie null si le service n'est
        /// pas trouvé au lieu de lever une exception.
        /// </summary>
        /// <param name="serviceType">Interface du service</param>
        /// <returns>Le service demandé s'il existe, sinon null</returns>
        object IServiceProvider.GetService(Type serviceType)
        {
            return GetServiceInternal(serviceType, string.Empty);
        }

        #endregion

        #region Private methods

        private Dictionary<string, object> GetServicesForType(Type serviceType, bool create)
        {
            lock (_services)
            {
                Dictionary<string, object> services;
                if (!_services.TryGetValue(serviceType, out services))
                {
                    if (create)
                    {
                        services = new Dictionary<string, object>();
                        _services[serviceType] = services;
                    }
                }
                return services;
            }
        }

        private object GetServiceInternal(Type serviceType, string name)
        {
            lock (_services)
            {
                var services = GetServicesForType(serviceType, false);
                if (services != null)
                {
                    object service;
                    services.TryGetValue(name ?? string.Empty, out service);
                    return service;
                }
                return null;
            }
        }

        #endregion
    }

    /// <summary>
    /// Exception levée quand le ServiceLocator ne trouve pas le service demandé
    /// </summary>
    [Serializable]
    public class ServiceNotFoundException : Exception
    {
        private readonly Type _serviceType;
        private readonly string _serviceName;

        /// <summary>
        /// Type du service demandé
        /// </summary>
        public Type ServiceType
        {
            get { return _serviceType; }
        }

        /// <summary>
        /// Nom du service demandé
        /// </summary>
        public string ServiceName
        {
            get { return _serviceName; }
        }

        /// <summary>
        /// Initialise une nouvelle instance de ServiceNotFoundException avec le message par défaut
        /// </summary>
        /// <param name="serviceType">Type du service demandé</param>
        public ServiceNotFoundException(Type serviceType)
            : this(serviceType, string.Empty)
        {
        }

        /// <summary>
        /// Initialise une nouvelle instance de ServiceNotFoundException avec le message par défaut
        /// </summary>
        /// <param name="serviceType">Type du service demandé</param>
        /// <param name="serviceName">Nom du service demandé</param>
        public ServiceNotFoundException(Type serviceType, string serviceName)
        {
            _serviceType = serviceType;
            _serviceName = serviceName;
        }

        /// <summary>
        /// Initialise une nouvelle instance de ServiceNotFoundException avec le message spécifié
        /// </summary>
        /// <param name="serviceType">Type du service demandé</param>
        /// <param name="serviceName">Nom du service demandé</param>
        /// <param name="message">Message de l'exception</param>
        public ServiceNotFoundException(Type serviceType, string serviceName, string message)
            : base(message)
        {
            _serviceType = serviceType;
            _serviceName = serviceName;
        }

        /// <summary>
        /// Initialise une nouvelle instance de ServiceNotFoundException avec le message et l'exception interne spécifiés
        /// </summary>
        /// <param name="serviceType">Type du service demandé</param>
        /// <param name="serviceName">Nom du service demandé</param>
        /// <param name="message">Message de l'exception</param>
        /// <param name="inner">Exception interne</param>
        public ServiceNotFoundException(Type serviceType, string serviceName, string message, Exception inner)
            : base(message, inner)
        {
            _serviceType = serviceType;
            _serviceName = serviceName;
        }

        /// <summary>
        /// Initialise une nouvelle instance de ServiceNotFoundException à partir de données sérialisées.
        /// </summary>
        /// <param name="info">SerializationInfo qui contient les données d'objet sérialisées relatives à l'exception levée.</param>
        /// <param name="context">StreamingContext qui contient des informations contextuelles sur la source ou la destination.</param>
        protected ServiceNotFoundException(
          System.Runtime.Serialization.SerializationInfo info,
          System.Runtime.Serialization.StreamingContext context)
            : base(info, context) { }
    }
}