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

namespace SysBaseLibs
{
    public class XMLSerialization
    {
        #region SerializeToStream
        public static Stream SerializeToStream(object obj)
        {
            Stream s = (Stream)(new MemoryStream());
            SerializeToStream(s, obj);
            return s;
        }

        public static void SerializeToStream(Stream s, object obj)
        {
            BinaryFormatter bf = new BinaryFormatter();
            bf.Serialize(s, obj);
        }
        #endregion

        #region SerializeToXml
        public static string SerializeToXml(object obj)
        {
            return SerializeToXml(obj, "", "");
        }

        public static string SerializeToXml(object obj, string xsi, string xsd)
        {
            XmlSerializer serializer = new XmlSerializer(obj.GetType());
            //XmlSerializerNamespaces xsn = new XmlSerializerNamespaces();
            //xsn.Add(xsi, xsd);
            StringBuilder sb = new StringBuilder();

            using (TextWriter tw = new StringWriter(sb))
            {
                serializer.Serialize(tw, obj);
            }

            return sb.ToString();
        }
        #endregion

        #region DeserializeFromStream
        public static object DeserializeFromStream(Stream s, Type type)
        {
            BinaryFormatter bf = new BinaryFormatter();
            s.Position = 0;
            return bf.Deserialize(s);
        }

        public static T DeserializeFromStream<T>(Stream s)
        {
            return (T)DeserializeFromStream(s, typeof(T));
        }
        #endregion

        #region DeserializeFromXml
        public static object DeserializeFromXml(string xml, Type type)
        {
            XmlSerializer serializer = new XmlSerializer(type);
            object obj = null;

            using (StringReader sr = new StringReader(xml))
            {
                obj = serializer.Deserialize((TextReader)sr);
            }

            return obj;
        }

        public static T DeserializeFromXml<T>(string xml)
        {
            return (T)DeserializeFromXml(xml, typeof(T));
        }
        #endregion
    }

    /// <summary>
    /// Serialize and Deserialize object
    /// Generic
    /// </summary>
    public class SimpleSerializer
    {
        #region Static methods

        /// <summary>
        /// Serialize object
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static string Serialize<T>(T t)
        {
            using (MemoryStream mem = new MemoryStream())
            {
                XmlSerializer xz = new XmlSerializer(t.GetType());

                XmlTextWriter writer = new XmlTextWriter(mem, Encoding.UTF8);
                writer.Formatting = Formatting.Indented;
                xz.Serialize(writer, t);
                writer.Close();

                return Encoding.UTF8.GetString(mem.ToArray());
            }
        }

        /// <summary>
        /// Serialize object with code
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        public static string Serialize<T>(T t, Encoding e)
        {
            using (MemoryStream mem = new MemoryStream())
            {
                XmlSerializer xz = new XmlSerializer(t.GetType());

                XmlTextWriter writer = new XmlTextWriter(mem, e);
                writer.Formatting = Formatting.Indented;
                xz.Serialize(writer, t);
                writer.Close();

                return Encoding.UTF8.GetString(mem.ToArray());
            }
        }

        /// <summary>
        /// Deserialize object
        /// </summary>
        /// <param name="type"></param>
        /// <param name="s"></param>
        /// <returns></returns>
        public static object Deserialize(Type type, string s)
        {
            using (StringReader sr = new StringReader(s))
            {
                XmlSerializer xz = new XmlSerializer(type);
                return xz.Deserialize(sr);
            }
        }

        /// <summary>
        /// Deserialize object 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="s"></param>
        /// <returns></returns>
        public static T Deserialize<T>(string s)
        {
            XmlSerializer xz = new XmlSerializer(typeof(T));
            StreamReader sr = new StreamReader(
                new MemoryStream(Encoding.UTF8.GetBytes(s)), Encoding.UTF8);

            return (T)xz.Deserialize(sr);
        }

        /// <summary>
        ///  Deserialize object  with code
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="s"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        public static T Deserialize<T>(string s, Encoding e)
        {
            XmlSerializer xz = new XmlSerializer(typeof(T));
            StreamReader sr = new StreamReader(
                new MemoryStream(Encoding.UTF8.GetBytes(s)), e);

            return (T)xz.Deserialize(sr);
        }

        #endregion
    }
}