using Neo.Afx.Utilities;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;
using System.Xml.Serialization;

namespace Neo.Afx.Common
{
    /// <summary>
    /// Serialization Utilities
    /// </summary>
    public static class SerializationUtilities
    {
        static Newtonsoft.Json.JsonSerializer JsonSerializer;

        #region Serialize
        /// <summary>
        /// Serialize
        /// </summary>
        /// <param name="obj">obj</param>
        /// <returns>byte[]</returns>
        public static byte[] Serialize(object obj)
        {
            if (obj.GetType() == typeof(XElement))
            {
                return SerializeXElement(obj);
            }
            else
            {
                return SerializeJson(obj);
            }
        } 
        #endregion

        #region Deserialize
        /// <summary>
        /// Deserialize
        /// </summary>
        public static T Deserialize<T>(byte[] stream)
        {
            if (typeof(T) == typeof(XElement))
            {
                return DerializeXElement<T>(stream);
            }
            else
            {
                return DeserializeJson<T>(stream);
            }
        } 
        #endregion

        #region Json Serialization
        static byte[] SerializeJson(object o)
        {
            if (JsonSerializer == null)
            {
                var settings = new Newtonsoft.Json.JsonSerializerSettings
                {
                    ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Error,
                    DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc,
                    StringEscapeHandling = Newtonsoft.Json.StringEscapeHandling.EscapeHtml
                };

                JsonSerializer = Newtonsoft.Json.JsonSerializer.Create(settings);
            }

            var json = "";

            using (var sw = new StringWriter())
            {
                JsonSerializer.Serialize(sw, o);
                json = sw.ToString();
            }

            return StringUtilities.StringToByteArray(json);
        }

        static T DeserializeJson<T>(byte[] stream)
        {
            return (T)Newtonsoft.Json.JsonConvert.DeserializeObject(StringUtilities.ByteArrayToString(stream), typeof(T));            
        }
        #endregion

        #region Binary Serialization
        static byte[] SerializeBinary(object o)
        {
            if (o == null)
            {
                return null;
            }

            BinaryFormatter binaryFormatter = new BinaryFormatter();

            try
            {
                using (MemoryStream memoryStream = new MemoryStream())
                {
                    binaryFormatter.Serialize(memoryStream, o);
                    byte[] objectDataAsStream = memoryStream.ToArray();
                    return objectDataAsStream;
                }
            }
            catch (Exception)
            {
                return null;
            }

        }

        static T DeserializeBinary<T>(byte[] stream)
        {
            if (stream == null)
            {
                return default(T);
            }

            BinaryFormatter binaryFormatter = new BinaryFormatter();
            using (MemoryStream memoryStream = new MemoryStream(stream))
            {
                T result = (T)binaryFormatter.Deserialize(memoryStream);
                return result;
            }
        }
        #endregion

        #region XmlSerialization
        static byte[] SerializeXElement(object obj)
        {
            using (var memoryStream = new MemoryStream())
            {
                using (TextWriter streamWriter = new StreamWriter(memoryStream))
                {
                    var xmlSerializer = new XmlSerializer(typeof(XElement));
                    xmlSerializer.Serialize(streamWriter, obj);
                    return memoryStream.ToArray();
                }
            }
        }

        static T DerializeXElement<T>(byte[] stream)
        {
            if (stream == null)
            {
                return default(T);
            }

            var xs = new XmlSerializer(typeof(XElement));
            using (MemoryStream memoryStream = new MemoryStream(stream))
            {
                return (T)xs.Deserialize(memoryStream);
            }
        }
        #endregion
    }
}