using NaiBa.Util.Helper;
using Newtonsoft.Json;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;

namespace NaiBa.Util.Extension
{
	public static partial class Extensions
	{
		#region 转换为long
		/// <summary>
		/// 将object转换为long，若转换失败，则返回0。不抛出异常。  
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static long ParseToLong(this object obj)
		{
			if (obj == null)
				return 0L;

			try
			{
				string str = obj.ParseToString();
				if (string.IsNullOrEmpty(str))
				{
					return 0;
				}
				return long.Parse(str);
			}
			catch
			{
				return 0L;
			}
		}

		public static long? ParseToNullableLong(this object obj)
		{
			if (obj == null)
				return null;

			try
			{
				string str = obj.ParseToString();
				if (string.IsNullOrEmpty(str))
				{
					return null;
				}
				return long.Parse(str);
			}
			catch
			{
				return null;
			}
		}

		/// <summary>
		/// 将object转换为long，若转换失败，则返回指定值。不抛出异常。  
		/// </summary>
		/// <param name="str"></param>
		/// <param name="defaultValue"></param>
		/// <returns></returns>
		public static long ParseToLong(this string str, long defaultValue)
		{
			if (str == null)
				return defaultValue;

			try
			{
				return long.Parse(str);
			}
			catch
			{
				return defaultValue;
			}
		}
		#endregion

		#region 转换为int
		/// <summary>
		/// 将object转换为int，若转换失败，则返回0。不抛出异常。  
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static int ParseToInt(this object str)
		{
			if (str == null)
				return 0;

			try
			{
				return Convert.ToInt32(str);
			}
			catch
			{
				return 0;
			}
		}

		public static int? ParseToNullableInt(this object str)
		{
			// 1. 快速判断：如果为 null 或 DBNull，直接返回
			if (str == null || str == DBNull.Value)
				return null;

			// 2. 尝试直接转换类型（处理 int, short, long 等）
			if (str is int intVal)
				return intVal;
			if (str is long longVal && longVal >= int.MinValue && longVal <= int.MaxValue)
				return (int)longVal;

			// 3. 针对字符串进行处理（支持空格、空字符串）
			if (str is string strVal)
			{
				// 如果字符串为 null 或空白，视为 null
				if (string.IsNullOrWhiteSpace(strVal))
					return null;

				if (int.TryParse(strVal, NumberStyles.Integer, CultureInfo.InvariantCulture, out int result))
					return result;

				return null;
			}

			// 4. 其他类型（如 bool, DateTime）统一返回 null，保持严格
			try
			{
				return Convert.ToInt32(str);
			}
			catch
			{
				return null;
			}
			return null;
		}

		public static int DecimalPointParseToInt(this object str)
		{
			try
			{
				string temp = str.ParseToString();
				int i = temp.IndexOf('.');
				if (i > 0)
				{
					temp = temp.Substring(0, i);
				}
				return Convert.ToInt32(temp);
			}
			catch
			{
				return 0;
			}
		}

		/// <summary>
		/// 将object转换为int，若转换失败，则返回指定值。不抛出异常。 
		/// null返回默认值
		/// </summary>
		/// <param name="str"></param>
		/// <param name="defaultValue"></param>
		/// <returns></returns>
		public static int ParseToInt(this object str, int defaultValue)
		{
			if (str == null)
			{
				return defaultValue;
			}
			try
			{
				return Convert.ToInt32(str);
			}
			catch
			{
				return defaultValue;
			}
		}
		#endregion

		#region 转换为short
		/// <summary>
		/// 将object转换为short，若转换失败，则返回0。不抛出异常。  
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static short ParseToShort(this object obj)
		{
			try
			{
				return short.Parse(obj.ToString());
			}
			catch
			{
				return 0;
			}
		}

		/// <summary>
		/// 将object转换为short，若转换失败，则返回指定值。不抛出异常。  
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static short ParseToShort(this object str, short defaultValue)
		{
			try
			{
				return short.Parse(str.ToString());
			}
			catch
			{
				return defaultValue;
			}
		}
		#endregion

		#region 转换为demical
		/// <summary>
		/// 将object转换为demical，若转换失败，则返回指定值。不抛出异常。  
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static decimal ParseToDecimal(this object str, decimal defaultValue)
		{
			try
			{
				if (str is DBNull) { return defaultValue; }
				return decimal.Parse(str.ToString());
			}
			catch
			{
				return defaultValue;
			}
		}

		/// <summary>
		/// 将object转换为demical，若转换失败，则返回0。不抛出异常。  
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static decimal ParseToDecimal(this object str)
		{
			try
			{
				if (str is DBNull) { return 0; }
				return decimal.Parse(str.ToString());
			}
			catch
			{
				return 0;
			}
		}
		public static decimal? ParseToNullableDecimal(this object str)
		{
			try
			{
				return decimal.Parse(str.ToString());
			}
			catch
			{
				return null;
			}
		}
		#endregion

		#region 转化为bool
		/// <summary>
		/// 将object转换为bool，若转换失败，则返回false。不抛出异常。  
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static bool ParseToBool(this object str)
		{
			try
			{
				if (str is null)
					return false;
				return bool.Parse(str.ToString());
			}
			catch
			{
				return false;
			}
		}

		/// <summary>
		/// 将object转换为bool，若转换失败，则返回指定值。不抛出异常。  
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static bool ParseToBool(this object str, bool result)
		{
			try
			{
				return bool.Parse(str.ToString());
			}
			catch
			{
				return result;
			}
		}
		#endregion

		#region 转换为float
		/// <summary>
		/// 将object转换为float，若转换失败，则返回0。不抛出异常。  
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static float ParseToFloat(this object str)
		{
			try
			{
				return float.Parse(str.ToString());
			}
			catch
			{
				return 0;
			}
		}

		/// <summary>
		/// 将object转换为float，若转换失败，则返回指定值。不抛出异常。  
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static float ParseToFloat(this object str, float result)
		{
			try
			{
				return float.Parse(str.ToString());
			}
			catch
			{
				return result;
			}
		}
		#endregion

		#region 转换为Guid
		/// <summary>
		/// 将string转换为Guid，若转换失败，则返回Guid.Empty。不抛出异常。  
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static Guid ParseToGuid(this string str)
		{
			try
			{
				return new Guid(str);
			}
			catch
			{
				return Guid.Empty;
			}
		}
		#endregion

		#region 转换为DateTime

		public static DateTime? ParseToDateTimeNullable(this string str)
		{
			try
			{
				if (string.IsNullOrWhiteSpace(str))
				{
					return null;
				}

				try
				{
					return DateTime.Parse(str);
				}
				catch
				{
				}

				if (str.Contains("年") && str.Contains("月") && str.Contains("日") && !str.Contains("周"))
					str = str.Replace("年", "-").Replace("月", "-").Replace("日", "").Replace("时", ":").Replace("分", ":").Replace("秒", "").Trim(' ', ':');
				if (str.Contains("-") || str.Contains("/"))
				{
					return DateTime.Parse(str);
				}
				else
				{
					int length = str.Length;
					switch (length)
					{
						case 4:
							return DateTime.ParseExact(str, "yyyy", System.Globalization.CultureInfo.CurrentCulture);
						case 6:
							return DateTime.ParseExact(str, "yyyyMM", System.Globalization.CultureInfo.CurrentCulture);
						case 8:
							return DateTime.ParseExact(str, "yyyyMMdd", System.Globalization.CultureInfo.CurrentCulture);
						case 10:
							return DateTime.ParseExact(str, "yyyyMMddHH", System.Globalization.CultureInfo.CurrentCulture);
						case 12:
							return DateTime.ParseExact(str, "yyyyMMddHHmm", System.Globalization.CultureInfo.CurrentCulture);
						case 14:
							return DateTime.ParseExact(str, "yyyyMMddHHmmss", System.Globalization.CultureInfo.CurrentCulture);
						default:
							return DateTime.ParseExact(str, "yyyyMMddHHmmss", System.Globalization.CultureInfo.CurrentCulture);
					}
				}
			}
			catch
			{
				return null;
			}
		}

		/// <summary>
		/// 将string转换为DateTime，若转换失败，则返回日期最小值。不抛出异常。  
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static DateTime ParseToDateTime(this string str)
		{
			try
			{
				if (string.IsNullOrWhiteSpace(str))
				{
					return DateTime.MinValue;
				}
				if (str.Contains("-") || str.Contains("/"))
				{
					return DateTime.Parse(str);
				}
				else
				{
					int length = str.Length;
					switch (length)
					{
						case 4:
							return DateTime.ParseExact(str, "yyyy", System.Globalization.CultureInfo.CurrentCulture);
						case 6:
							return DateTime.ParseExact(str, "yyyyMM", System.Globalization.CultureInfo.CurrentCulture);
						case 8:
							return DateTime.ParseExact(str, "yyyyMMdd", System.Globalization.CultureInfo.CurrentCulture);
						case 10:
							return DateTime.ParseExact(str, "yyyyMMddHH", System.Globalization.CultureInfo.CurrentCulture);
						case 12:
							return DateTime.ParseExact(str, "yyyyMMddHHmm", System.Globalization.CultureInfo.CurrentCulture);
						case 14:
							return DateTime.ParseExact(str, "yyyyMMddHHmmss", System.Globalization.CultureInfo.CurrentCulture);
						default:
							return DateTime.ParseExact(str, "yyyyMMddHHmmss", System.Globalization.CultureInfo.CurrentCulture);
					}
				}
			}
			catch
			{
				return DateTime.MinValue;
			}
		}

		/// <summary>
		/// 将string转换为DateTime，若转换失败，则返回默认值。  
		/// </summary>
		/// <param name="str"></param>
		/// <param name="defaultValue"></param>
		/// <returns></returns>
		public static DateTime ParseToDateTime(this string str, DateTime? defaultValue)
		{
			try
			{
				if (string.IsNullOrWhiteSpace(str))
				{
					return defaultValue.GetValueOrDefault();
				}
				if (str.Contains("-") || str.Contains("/"))
				{
					return DateTime.Parse(str);
				}
				else
				{
					int length = str.Length;
					switch (length)
					{
						case 4:
							return DateTime.ParseExact(str, "yyyy", System.Globalization.CultureInfo.CurrentCulture);
						case 6:
							return DateTime.ParseExact(str, "yyyyMM", System.Globalization.CultureInfo.CurrentCulture);
						case 8:
							return DateTime.ParseExact(str, "yyyyMMdd", System.Globalization.CultureInfo.CurrentCulture);
						case 10:
							return DateTime.ParseExact(str, "yyyyMMddHH", System.Globalization.CultureInfo.CurrentCulture);
						case 12:
							return DateTime.ParseExact(str, "yyyyMMddHHmm", System.Globalization.CultureInfo.CurrentCulture);
						case 14:
							return DateTime.ParseExact(str, "yyyyMMddHHmmss", System.Globalization.CultureInfo.CurrentCulture);
						default:
							return DateTime.ParseExact(str, "yyyyMMddHHmmss", System.Globalization.CultureInfo.CurrentCulture);
					}
				}
			}
			catch
			{
				return defaultValue.GetValueOrDefault();
			}
		}
		#endregion

		#region 转换为string
		/// <summary>
		/// 将object转换为string，若转换失败，则返回""。不抛出异常。  
		/// </summary>
		/// <param name="str"></param>
		/// <returns></returns>
		public static string ParseToString(this object obj)
		{
			try
			{
				if (obj == null)
				{
					return string.Empty;
				}
				else
				{
					if (obj is DateTime)
						return (obj as DateTime?).Value.ToString("yyyy-MM-dd HH:mm:ss");
					return obj.ToString();
				}
			}
			catch
			{
				return string.Empty;
			}
		}

		public static string ParseToNullableString(this object obj)
		{
			try
			{
				if (obj == null)
				{
					return null;
				}
				else
				{
					if (obj is DateTime)
						return (obj as DateTime?).Value.ToString("yyyy-MM-dd HH:mm:ss");
					return obj.ToString();
				}
			}
			catch
			{
				return null;
			}
		}

		public static string ParseToStrings<T>(this object obj, string split = ",")
		{
			try
			{
				var list = obj as IEnumerable<T>;
				if (list != null)
				{
					return string.Join(split, list);
				}
				else
				{
					return obj.ToString();
				}
			}
			catch
			{
				return string.Empty;
			}
		}
		#endregion

		#region 转换为double
		/// <summary>
		/// 将object转换为double，若转换失败，则返回0。不抛出异常。  
		/// </summary>
		/// <param name="obj"></param>
		/// <returns></returns>
		public static double ParseToDouble(this object obj)
		{
			try
			{
				return double.Parse(obj.ToString());
			}
			catch
			{
				return 0;
			}
		}

		/// <summary>
		/// 将object转换为double，若转换失败，则返回指定值。不抛出异常。  
		/// </summary>
		/// <param name="str"></param>
		/// <param name="defaultValue"></param>
		/// <returns></returns>
		public static double ParseToDouble(this object str, double defaultValue)
		{
			try
			{
				return double.Parse(str.ToString());
			}
			catch
			{
				return defaultValue;
			}
		}
		#endregion

		#region 字符串转指定类型Array    
		public static T[] SplitToArray<T>(this string value, string split = ",")
		{
			if (string.IsNullOrEmpty(value))
			{
				return default(T[]);
			}
			var arr = value.Split(new string[] { split }, StringSplitOptions.RemoveEmptyEntries).CastSuper<T>().ToArray();
			return arr;
		}

		public static T[] SplitToArray<T>(this string value, string[] split)
		{
			if (string.IsNullOrEmpty(value))
			{
				return default(T[]);
			}
			var arr = value.Split(split, StringSplitOptions.RemoveEmptyEntries).CastSuper<T>().ToArray();
			return arr;
		}
		#endregion

		#region 字符串转指定类型List    
		public static List<T> SplitToList<T>(this string value, string split = ",")
		{
			if (string.IsNullOrEmpty(value))
			{
				return new List<T>();
			}
			var list = value.Split(new string[] { split }, StringSplitOptions.RemoveEmptyEntries).CastSuper<T>().ToList();
			return list;
		}

		public static List<T> SplitToList<T>(this string value, string[] split)
		{
			if (string.IsNullOrEmpty(value))
			{
				return new List<T>();
			}
			var list = value.Split(split, StringSplitOptions.RemoveEmptyEntries).CastSuper<T>().ToList();
			return list;
		}
		#endregion

		#region 强制转换类型
		/// <summary>
		/// 强制转换类型
		/// </summary>
		/// <typeparam name="TResult"></typeparam>
		/// <param name="source"></param>
		/// <returns></returns>
		public static IEnumerable<TResult> CastSuper<TResult>(this IEnumerable source)
		{
			foreach (object item in source)
			{
				yield return (TResult)Convert.ChangeType(item, typeof(TResult));
			}
		}
		#endregion

		#region Object转换为Json
		public static string ParseToJson(this object obj)
		{
			return JsonConvert.SerializeObject(obj);
		}
		#endregion

		#region Json转为Object
		public static T ParseToObject<T>(this string json)
		{
			if (string.IsNullOrEmpty(json))
			{
				return Activator.CreateInstance<T>();
			}
			return JsonConvert.DeserializeObject<T>(json);
		}
		#endregion

		#region 深拷贝（克隆出一个新对象，拷贝对象里面的数据和子对象）
		public static T DeepClone<T>(this T o)
		{
			return o.ParseToJson().ParseToObject<T>();
			// 这种方式在用 Obfuscator 的时候有问题
			//using (MemoryStream stream = new MemoryStream())
			//{
			//    BinaryFormatter formatter = new BinaryFormatter();
			//    formatter.Serialize(stream, o);
			//    stream.Position = 0;
			//    return (T)formatter.Deserialize(stream);
			//}
		}
		#endregion

		#region 浅拷贝（拷贝对象里面的数据[property and field]，但不拷贝对象里面的子对象）
		public static void ShadowClone<T1, T2>(this T1 source, ref T2 destination)
		{
			var sourceMembers = ReflectionHelper.GetMembers(source.GetType());
			var destinationMembers = ReflectionHelper.GetMembers(destination.GetType());

			// Copy data from source to destination
			foreach (var sourceMember in sourceMembers)
			{
				if (!ReflectionHelper.CanRead(sourceMember))
				{
					continue;
				}
				var destinationMember = destinationMembers.FirstOrDefault(x => x.Name.ToLower() == sourceMember.Name.ToLower());
				if (destinationMember == null || !ReflectionHelper.CanWrite(destinationMember))
				{
					continue;
				}
				ReflectionHelper.SetObjectValue(ref destination, destinationMember, ReflectionHelper.GetMemberValue(source, sourceMember));
			}
		}
		#endregion
	}
}