using System.Text;
using System.Xml;
using System.Xml.Serialization;

namespace YLErp.Helpers
{
    public class XmlHelper
    {
        #region 序列化

        /// <summary>
        /// 序列化object对象为XML字符串
        /// </summary>
        /// <param name="ObjectToSerialize">要序列化的类</param>
        /// <param name="indent">是否缩进</param>
        /// <returns>结果</returns>
        public static string Serializable(object ObjectToSerialize, bool indent = false)
        {
            string result = null;
            try
            {
                #region 去除XML自带命名空间
                var ns = new XmlSerializerNamespaces();
                ns.Add("", "");
                #endregion

                #region 去除XML声明

                var setting = new XmlWriterSettings();
                setting.Indent = indent;
                setting.Encoding = Encoding.Default;

                #endregion

                var xmlSerializer = new XmlSerializer(ObjectToSerialize.GetType());
                using (var memoryStream = new MemoryStream())
                {
                    var xmlTextWriter = new XmlTextWriter(memoryStream, new UTF8Encoding(false));
                    xmlTextWriter.Formatting = indent ? Formatting.Indented : Formatting.None;
                    xmlSerializer.Serialize(xmlTextWriter, ObjectToSerialize, ns);//最后一个ns参数为指定命名空间
                    xmlTextWriter.Flush();
                    xmlTextWriter.Close();
                    var uTF8Encoding = new UTF8Encoding(false, true);
                    result = uTF8Encoding.GetString(memoryStream.ToArray());
                }
            }
            catch (Exception innerException)
            {
                throw new ApplicationException("Couldn't Serialize Object:" + ObjectToSerialize.GetType().Name, innerException);
            }
            return result;
        }

        #endregion

        #region 反序列化

        /// <summary>
        /// 反序列化XML字符串为指定类型
        /// </summary>
        /// <typeparam name="T">转换后的类型</typeparam>
        /// <param name="xmlString">包含XML的字符串</param>
        /// <param name="normalization">是否忽略属性里的换行符</param>
        /// <returns></returns>
        public static T Deserialize<T>(string xmlString, bool normalization = true)
        {
            var rt = default(T);
            var xmlSerializer = new XmlSerializer(typeof(T));
            using (Stream xmlStream = new MemoryStream(Encoding.UTF8.GetBytes(xmlString)))
            {
                if (!normalization)
                {
                    using (var reader = new XmlTextReader(xmlStream))
                    {
                        // 注意一定要创建出一个 XmlTextReader出来，   
                        // 因为MS默认的 reader.Normalization = true   
                        // 设置成false就不会把回车去掉了   
                        reader.Normalization = false;
                        var obj = xmlSerializer.Deserialize(reader);
                        rt = (T)obj;
                    }
                }
                else
                {
                    var obj = xmlSerializer.Deserialize(xmlStream);
                    rt = (T)obj;
                }
            }
            return rt;
        }

        #endregion

        #region 格式化

        /// <summary>
        /// 格式化显示Xml
        /// </summary>
        /// <param name="source">Xml字符串</param>
        /// <returns>格式化后的Xml字符串</returns>
        public static string FormatXml(string source)
        {
            StringBuilder sb = new StringBuilder();
            XmlTextWriter writer = null;

            try
            {
                XmlDocument doc = new XmlDocument();
                doc.LoadXml(source);

                writer = new XmlTextWriter(new StringWriter(sb));
                writer.Formatting = Formatting.Indented;

                doc.WriteTo(writer);
            }
            finally
            {
                if (writer != null) writer.Close();
            }

            return sb.ToString();
        }

        #endregion
    }
}