using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Xml.Serialization;

namespace ChadSoft
{
    /// <summary>
    /// Supported serialization methods 
    /// </summary>
    public enum SerializationMethod
    {
        /// <summary>
        /// Serialization to XML format (System.Xml.Serialization.XmlSerializer)
        /// </summary>
        XML,
        /// <summary>
        /// Serialization to Binary format
        /// (System.Runtime.Serialization.Formatters.Binary.BinaryFormatter)
        /// </summary>
        Binary
    }

    /// <summary>
    /// Serialization helper class used to make serialization more manageable
    /// by removing the implementation details until the last possible call.
    /// </summary>
    public static class Serializer
    {

        #region DefaultSerializationMethod
        private static readonly SerializationMethod _DefaultSerializationMethod =
            Parse.AppSetting<SerializationMethod>("SerializationMethod");
        /// <summary>
        /// Gets the default serialization method.
        /// </summary>
        /// <value>The default serialization method.</value>
        public static SerializationMethod DefaultSerializationMethod
        {
            get { return _DefaultSerializationMethod; }
        }
        #endregion

        #region Serialize
        
        #region To File
        /// <summary>
        /// Serializes the source to a file 
        /// using the specified <see cref="SerializationMethod"/>.
        /// </summary>
        /// <typeparam name="T">The target Type to serialize to</typeparam>
        /// <param name="source">The object to be serialized.</param>
        /// <param name="filename">Path to the file used to store the result of the serialization.</param>
        public static void Serialize<T>(T source, string filename)
        {
            Serialize(DefaultSerializationMethod, source, filename);
        }

        /// <summary>
        /// Serializes the source to a file 
        /// using the specified <see cref="SerializationMethod"/>.
        /// </summary>
        /// <typeparam name="T">The target Type to serialize to</typeparam>
        /// <param name="method">The <see cref="SerializationMethod"/> to use to serialize the source.</param>
        /// <param name="source">The object to be serialized.</param>
        /// <param name="filename">Path to the file used to store the result of the serialization.</param>
        public static void Serialize<T>(SerializationMethod method, T source, string filename)
        {
            using (FileStream fileStream = new FileStream(filename, FileMode.Create))
            {
                Serialize(method, source, fileStream);
            }
        }
        #endregion

        #region To String
        /// <summary>
        /// Serializes the <paramref name="source"/> to a string using
        /// the specified <see cref="SerializationMethod"/>.
        /// </summary>
        /// <typeparam name="T">The target Type to serialize to</typeparam>
        /// <param name="source">The source object.</param>
        /// <returns>String containing the serialized data of the <paramref name="source"/></returns>
        public static string Serialize<T>(T source)
        {
            return Serialize(DefaultSerializationMethod, source);
        }

        /// <summary>
        /// Serializes the <paramref name="source"/> to a string using
        /// the specified <see cref="SerializationMethod"/>.
        /// </summary>
        /// <typeparam name="T">The target Type to serialize to</typeparam>
        /// <param name="method">The <see cref="SerializationMethod"/> to serialize with.</param>
        /// <param name="source">The source object.</param>
        /// <returns>String containing the serialized data of the <paramref name="source"/></returns>
        public static string Serialize<T>(SerializationMethod method, T source)
        {
            string serializedSource;

            using (MemoryStream stream = new MemoryStream())
            {
                Serialize(method, source, stream);
                stream.Seek(0, SeekOrigin.Begin);

                using (StreamReader reader = new StreamReader(stream))
                {
                    serializedSource = reader.ReadToEnd();
                }
            }
            return serializedSource;
        }
        #endregion

        #region To Stream

        /// <summary>
        /// Serializes the source to the specified stream 
        /// using the specified <see cref="SerializationMethod"/>.
        /// </summary>
        /// <typeparam name="T">The target Type to serialize to</typeparam>
        /// <param name="source">The object to be serialized.</param>
        /// <param name="stream">The stream to pipe the output of the serialization to.</param>
        public static void Serialize<T>(T source, Stream stream)
        {
            Serialize(DefaultSerializationMethod, source, stream);
        }

        /// <summary>
        /// Serializes the source to the specified stream 
        /// using the specified <see cref="SerializationMethod"/>.
        /// </summary>
        /// <typeparam name="T">The target Type to serialize to</typeparam>
        /// <param name="method">The <see cref="SerializationMethod"/> to use to serialize the source.</param>
        /// <param name="source">The object to be serialized.</param>
        /// <param name="stream">The stream to pipe the output of the serialization to.</param>
        public static void Serialize<T>(SerializationMethod method, T source, Stream stream)
        {
            switch (method)
            {
                case SerializationMethod.Binary:
                    SerializeBinary(source, stream);
                    break;
                case SerializationMethod.XML:
                    SerializeXml(source, stream);
                    break;
                default:
                    throw new NotSupportedException(String.Format(
                        "SerializationMethod {0} is not a supported serialization method!",
                        method));
            }
        }
        #endregion

        #endregion

        #region Deserialize

        #region From String
        /// <summary>
        /// Deserializes the specified string containing serialized data.
        /// </summary>
        /// <typeparam name="T">The target Type to deserialize to</typeparam>
        /// <param name="serializedData">A string containing serialized data of the target type.</param>
        /// <returns>
        /// Deserialized object from <paramref name="serializedData"/>
        /// </returns>
        public static T Deserialize<T>(string serializedData)
        {
            return Deserialize<T>(DefaultSerializationMethod, serializedData);
        }

        /// <summary>
        /// Deserializes the specified string containing serialized data.
        /// </summary>
        /// <typeparam name="T">The target Type to deserialize to</typeparam>
        /// <param name="method">
        /// The <see cref="SerializationMethod"/> originally used to serialize the object.
        /// </param>
        /// <param name="serializedData">A string containing serialized data of the target type.</param>
        /// <returns>
        /// Deserialized object from <paramref name="serializedData"/>
        /// </returns>
        public static T Deserialize<T>(SerializationMethod method, string serializedData)
        {
            T retVal;
            using(Stream stream = new MemoryStream(Encoding.Unicode.GetBytes(serializedData)))
            {
                stream.Flush();
                retVal = Deserialize<T>(method, stream);
            }
            return retVal;
        }
        #endregion

        #region From Stream
        /// <summary>
        /// Deserializes the specified stream.
        /// </summary>
        /// <typeparam name="T">The target Type to deserialize to</typeparam>
        /// <param name="stream">The stream.</param>
        /// <returns>Deserialized object from <paramref name="stream"/></returns>
        public static T Deserialize<T>(Stream stream)
        {
            return Deserialize<T>(DefaultSerializationMethod, stream);
        }

        /// <summary>
        /// Deserializes the specified stream.
        /// </summary>
        /// <typeparam name="T">The target Type to deserialize to</typeparam>
        /// <param name="method">
        /// The <see cref="SerializationMethod"/> originally used to serialize the object.
        /// </param>
        /// <param name="stream">The stream.</param>
        /// <returns>Deserialized object from <paramref name="stream"/></returns>
        public static T Deserialize<T>(SerializationMethod method, Stream stream)
        {
            switch (method)
            {
                case SerializationMethod.Binary:
                    return DeserializeBinary<T>(stream);
                case SerializationMethod.XML:
                    return DeserializeXml<T>(stream);
                default:
                    throw new NotSupportedException(String.Format(
                        "SerializationMethod {0} is not a supported deserialization method!",
                        method));
            }
        }
        #endregion

        #endregion

        #region Helpers

        #region Binary Serialization Helpers
        private static void SerializeBinary(object target, Stream stream)
        {
            new BinaryFormatter().Serialize(stream, target);
        }
        private static T DeserializeBinary<T>(Stream stream)
        {
            return (T)(new BinaryFormatter().Deserialize(stream));
        }
        #endregion

        #region XML Serialization Helpers
        private static void SerializeXml<T>(T target, Stream stream)
        {
            new XmlSerializer(typeof(T)).Serialize(stream, target);
        }
        private static T DeserializeXml<T>(Stream stream)
        {
            return (T)new XmlSerializer(typeof(T)).Deserialize(stream);
        }
        #endregion

        #endregion
    
    }

}