using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using System;
using System.IO;

namespace Tiger.Model.Extensions
{
    /// <summary>
    ///
    /// </summary>
    public static class JsonExtension
    {
        /// <summary>
        ///
        /// </summary>
        /// <param name="isIgnoreNull"></param>
        /// <returns></returns>
        private static JsonSerializerSettings GetSetting(bool isIgnoreNull = false)
        {
            JsonSerializerSettings setting = new JsonSerializerSettings
            {
                ContractResolver = new DefaultContractResolver(),
                DateFormatHandling = DateFormatHandling.MicrosoftDateFormat,
                DateFormatString = "yyyy-MM-dd HH:mm:ss"
            };
            if (isIgnoreNull)
            {
                setting.NullValueHandling = NullValueHandling.Ignore;
            }
            return setting;
        }

        /// <summary>
        /// 将对象序列化成Json字符串
        /// </summary>
        /// <param name="value">需要序列化的对象</param>
        /// <param name="isIgnoreNull">是否忽略null值得属性</param>
        /// <returns></returns>
        public static string? ToJson(this object value, bool isIgnoreNull = false)
        {
            if (value == null)
            {
                return default;
            }
            return JsonConvert.SerializeObject(value, GetSetting(isIgnoreNull));
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="value"></param>
        /// <param name="type"></param>
        /// <param name="isIgnoreNull"></param>
        /// <returns></returns>
        public static string? ToJson(this object value, Type type, bool isIgnoreNull = false)
        {
            if (value == null)
            {
                return default;
            }
            return JsonConvert.SerializeObject(value, type, GetSetting(isIgnoreNull));
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="value"></param>
        /// <param name="formatting"></param>
        /// <param name="isIgnoreNull"></param>
        /// <returns></returns>
        public static string ToJson(this object value, Formatting formatting, bool isIgnoreNull = false)
        {
            if (value == null)
            {
                return default;
            }
            return JsonConvert.SerializeObject(value, formatting, GetSetting(isIgnoreNull));
        }

        /// <summary>
        /// 将Json字符串反序列化为对象
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <returns></returns>
        public static T? ToObject<T>(this string json, bool isIgnoreNull = false)
        {
            if (string.IsNullOrWhiteSpace(json))
            {
                return default;
            }
            return JsonConvert.DeserializeObject<T>(json, GetSetting(isIgnoreNull));
        }

        /// <summary>
        /// 将Json字符串反序列化为对象
        /// </summary>
        /// <param name="json">json字符串</param>
        /// <param name="type">对象类型</param>
        /// <returns></returns>
        public static object? ToObject(this string json, Type type)
        {
            if (string.IsNullOrWhiteSpace(json))
            {
                return default;
            }
            return JsonConvert.DeserializeObject(json, type);
        }

        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <param name="isIgnoreNull"></param>
        /// <returns></returns>
        public static T? ToObject<T>(this object obj, bool isIgnoreNull = false)
        {
            if (obj == null)
            {
                return default;
            }
            string json = obj.ToJson(isIgnoreNull);
            return json.ToObject<T>(isIgnoreNull);
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public static object? ToObject<T>(this object obj, Type type)
        {
            if (obj == null)
            {
                return default;
            }
            string json = obj.ToJson(type);
            return json.ToObject<T>();
        }

        /// <summary>
        /// Json对象反序列化
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="stream">字符流</param>
        /// <returns></returns>
        public static T? ToObject<T>(Stream stream)
        {
            if (stream == null)
            {
                return default;
            }
            var serializer = new JsonSerializer();
            serializer.NullValueHandling = NullValueHandling.Ignore;
            serializer.ObjectCreationHandling = ObjectCreationHandling.Replace;
            serializer.MissingMemberHandling = MissingMemberHandling.Ignore;
            serializer.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
            using (var sr = new StreamReader(stream))
            {
                using (var jsonTextReader = new JsonTextReader(sr))
                {
                    return serializer.Deserialize<T>(jsonTextReader);
                }
            }
        }

        /// <summary>
        /// Json对象反序列化
        /// </summary>
        /// <param name="stream">字符流</param>
        /// <param name="type">反序列化类型</param>
        /// <returns></returns>
        public static object? ToObject(Stream stream, Type type)
        {
            if (stream == null)
            {
                return default;
            }
            var serializer = new JsonSerializer();
            serializer.NullValueHandling = NullValueHandling.Ignore;
            serializer.ObjectCreationHandling = ObjectCreationHandling.Replace;
            serializer.MissingMemberHandling = MissingMemberHandling.Ignore;
            serializer.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;

            using (var sr = new StreamReader(stream))
            {
                using (var jsonTextReader = new JsonTextReader(sr))
                {
                    return serializer.Deserialize(jsonTextReader, type);
                }
            }
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static Stream? ToStream(this object value)
        {
            if (value == null)
            {
                return default;
            }
            var stream = new MemoryStream();
            using (var writer = new StreamWriter(stream))
            {
                using (JsonTextWriter jsonWriter = new JsonTextWriter(writer))
                {
                    var ser = new JsonSerializer();
                    ser.DateFormatHandling = DateFormatHandling.IsoDateFormat;
                    ser.Serialize(jsonWriter, value);
                    jsonWriter.Flush();
                }
            }

            return stream;
        }
    }
}