using System;
using System.Collections.Generic;
using System.IO;
using System.Xml;
using System.Xml.Serialization;

namespace Developpez.Dotnet.Xml.Serialization
{
    /// <summary>
    /// Fournit des méthodes d'extension pour faciliter la sérialization XML
    /// </summary>
    public static class XmlSerializationExtensions
    {
        #region Membres privés

        private static readonly Dictionary<Type, XmlSerializer> _serializers;

        static XmlSerializationExtensions()
        {
            _serializers = new Dictionary<Type, XmlSerializer>();
        }

        private static XmlSerializer GetSerializer<T>()
        {
            lock (_serializers)
            {
                XmlSerializer xs;
                if (!_serializers.TryGetValue(typeof(T), out xs))
                {
                    xs = new XmlSerializer(typeof(T));
                    _serializers.Add(typeof(T), xs);
                }
                return xs;
            }
        }

        #endregion

        #region Raccourcis pour la sérialisation XML

        /// <summary>
        /// Renvoie une chaine de caractères contenant la représentation XML
        /// de l'objet
        /// </summary>
        /// <typeparam name="T">Type de l'objet à sérialiser</typeparam>
        /// <param name="obj">Objet à sérialiser</param>
        /// <returns>La représentation XML de l'objet</returns>
        public static string ToXml<T>(this T obj)
        {
            return obj.ToXml(null);
        }

        /// <summary>
        /// Renvoie une chaine de caractères contenant la représentation XML
        /// de l'objet, en précisant les namespaces XML à utiliser
        /// </summary>
        /// <typeparam name="T">Type de l'objet à sérialiser</typeparam>
        /// <param name="obj">Objet à sérialiser</param>
        /// <param name="namespaces">Namespaces XML à utiliser</param>
        /// <returns>La représentation XML de l'objet</returns>
        public static string ToXml<T>(this T obj, XmlSerializerNamespaces namespaces)
        {
            using (StringWriter wr = new StringWriter())
            {
                obj.WriteXml(wr, namespaces);
                return wr.ToString();
            }
        }

        /// <summary>
        /// Crée un objet à partir de sa représentation XML
        /// </summary>
        /// <typeparam name="T">Type de l'objet à désérialiser</typeparam>
        /// <param name="xml">Représentation XML de l'objet</param>
        /// <returns>L'objet correspondant à la représentation XML</returns>
        public static T ParseXml<T>(this string xml)
        {
            using (StringReader rd = new StringReader(xml))
            {
                return rd.ReadXml<T>();
            }
        }

        /// <summary>
        /// Sérialise un objet en XML dans le fichier spécifié
        /// </summary>
        /// <typeparam name="T">Type de l'objet à sérialiser</typeparam>
        /// <param name="obj">Objet à sérialiser</param>
        /// <param name="path">Chemin du fichier</param>
        public static void WriteXml<T>(this T obj, string path)
        {
            obj.WriteXml(path, null);
        }

        /// <summary>
        /// Sérialise un objet en XML dans le fichier spécifié, en utilisant les
        /// namespaces XML spécifiés
        /// </summary>
        /// <typeparam name="T">Type de l'objet à sérialiser</typeparam>
        /// <param name="obj">Objet à sérialiser</param>
        /// <param name="path">Chemin du fichier</param>
        /// <param name="namespaces">Namespaces XML à utiliser</param>
        public static void WriteXml<T>(this T obj, string path, XmlSerializerNamespaces namespaces)
        {
            using (Stream stream = File.OpenWrite(path))
            {
                obj.WriteXml(stream, namespaces);
            }
        }

        /// <summary>
        /// Sérialise un objet en XML dans le flux spécifié
        /// </summary>
        /// <typeparam name="T">Type de l'objet à sérialiser</typeparam>
        /// <param name="obj">Objet à sérialiser</param>
        /// <param name="stream">Flux dans lequel sérialiser l'objet</param>
        public static void WriteXml<T>(this T obj, Stream stream)
        {
            obj.WriteXml(stream, null);
        }

        /// <summary>
        /// Sérialise un objet en XML dans le flux spécifié, en utilisant les
        /// namespaces XML spécifiés
        /// </summary>
        /// <typeparam name="T">Type de l'objet à sérialiser</typeparam>
        /// <param name="obj">Objet à sérialiser</param>
        /// <param name="stream">Flux dans lequel sérialiser l'objet</param>
        /// <param name="namespaces">Namespaces XML à utiliser</param>
        public static void WriteXml<T>(this T obj, Stream stream, XmlSerializerNamespaces namespaces)
        {
            var xs = GetSerializer<T>();
            xs.Serialize(stream, obj, namespaces);
        }

        /// <summary>
        /// Sérialise un objet en XML dans le TextWriter spécifié
        /// </summary>
        /// <typeparam name="T">Type de l'objet à sérialiser</typeparam>
        /// <param name="obj">Objet à sérialiser</param>
        /// <param name="writer">TextWriter dans lequel sérialiser l'objet</param>
        public static void WriteXml<T>(this T obj, TextWriter writer)
        {
            obj.WriteXml(writer, null);
        }

        /// <summary>
        /// Sérialise un objet en XML dans le TextWriter spécifié, en utilisant les
        /// namespaces XML spécifiés
        /// </summary>
        /// <typeparam name="T">Type de l'objet à sérialiser</typeparam>
        /// <param name="obj">Objet à sérialiser</param>
        /// <param name="writer">TextWriter dans lequel sérialiser l'objet</param>
        /// <param name="namespaces">Namespaces XML à utiliser</param>
        public static void WriteXml<T>(this T obj, TextWriter writer, XmlSerializerNamespaces namespaces)
        {
            var xs = GetSerializer<T>();
            xs.Serialize(writer, obj, namespaces);
        }

        /// <summary>
        /// Sérialise un objet en XML dans le XmlWriter spécifié
        /// </summary>
        /// <typeparam name="T">Type de l'objet à sérialiser</typeparam>
        /// <param name="obj">Objet à sérialiser</param>
        /// <param name="writer">XmlWriter dans lequel sérialiser l'objet</param>
        public static void WriteXml<T>(this T obj, XmlWriter writer)
        {
            obj.WriteXml(writer, null);
        }

        /// <summary>
        /// Sérialise un objet en XML dans le XmlWriter spécifié, en utilisant les
        /// namespaces XML spécifiés
        /// </summary>
        /// <typeparam name="T">Type de l'objet à sérialiser</typeparam>
        /// <param name="obj">Objet à sérialiser</param>
        /// <param name="writer">XmlWriter dans lequel sérialiser l'objet</param>
        /// <param name="namespaces">Namespaces XML à utiliser</param>
        public static void WriteXml<T>(this T obj, XmlWriter writer, XmlSerializerNamespaces namespaces)
        {
            var xs = GetSerializer<T>();
            xs.Serialize(writer, obj, namespaces);
        }

        /// <summary>
        /// Crée un objet à partir de sa représentation XML dans le fichier spécifié
        /// </summary>
        /// <typeparam name="T">Type de l'objet à désérialiser</typeparam>
        /// <param name="path">Chemin du fichier</param>
        /// <returns>L'objet correspondant à la représentation XML</returns>
        public static T ReadXml<T>(this string path)
        {
            using (Stream stream = File.OpenRead(path))
            {
                return stream.ReadXml<T>();
            }
        }

        /// <summary>
        /// Crée un objet à partir de sa représentation XML dans le flux spécifié
        /// </summary>
        /// <typeparam name="T">Type de l'objet à désérialiser</typeparam>
        /// <param name="stream">Flux contenant la représentation XML de l'objet</param>
        /// <returns>L'objet correspondant à la représentation XML</returns>
        public static T ReadXml<T>(this Stream stream)
        {
            var xs = GetSerializer<T>();
            return (T)xs.Deserialize(stream);
        }

        /// <summary>
        /// Crée un objet à partir de sa représentation XML dans le TextReader spécifié
        /// </summary>
        /// <typeparam name="T">Type de l'objet à désérialiser</typeparam>
        /// <param name="reader">TextReader contenant la représentation XML de l'objet</param>
        /// <returns>L'objet correspondant à la représentation XML</returns>
        public static T ReadXml<T>(this TextReader reader)
        {
            var xs = GetSerializer<T>();
            return (T)xs.Deserialize(reader);
        }

#if !SILVERLIGHT // XmlDeserializationEvents non supporté en SL
        /// <summary>
        /// Crée un objet à partir de sa représentation XML dans le XmlReader spécifié
        /// </summary>
        /// <typeparam name="T">Type de l'objet à désérialiser</typeparam>
        /// <param name="reader">XmlReader contenant la représentation XML de l'objet</param>
        /// <returns>L'objet correspondant à la représentation XML</returns>
        public static T ReadXml<T>(this XmlReader reader)
        {
            return reader.ReadXml<T>(default(XmlDeserializationEvents));
        }

        /// <summary>
        /// Crée un objet à partir de sa représentation XML dans le XmlReader spécifié, en utilisant
        /// les évènements de désérialisation spécifiés
        /// </summary>
        /// <typeparam name="T">Type de l'objet à désérialiser</typeparam>
        /// <param name="reader">XmlReader contenant la représentation XML de l'objet</param>
        /// <param name="events">Evènements de désérialisation à utiliser</param>
        /// <returns>L'objet correspondant à la représentation XML</returns>
        public static T ReadXml<T>(this XmlReader reader, XmlDeserializationEvents events)
        {
            var xs = GetSerializer<T>();
            return (T)xs.Deserialize(reader, events);
        }
#endif

        #endregion

        #region Sérialisation d'un dictionnaire

        /// <summary>
        /// Renvoie un objet sérialisable en XML representant les données d'un dictionnaire
        /// </summary>
        /// <typeparam name="TKey">Type de clé</typeparam>
        /// <typeparam name="TValue">Type de valeur</typeparam>
        /// <param name="dictionary">Dictionnaire à sérialiser</param>
        /// <returns>Une collection de paires clé/valeur, équivalente au dictionnaire et sérialisable en XML</returns>
        public static XmlDictionaryEntryCollection<TKey, TValue> AsXmlSerializable<TKey, TValue>(this IDictionary<TKey, TValue> dictionary)
        {
            if (dictionary != null)
                return new XmlDictionaryEntryCollection<TKey, TValue>(dictionary);
            return null;
        }

        #endregion
    }
}