using System.Reflection;

namespace DS.Module.Core.Extensions;

/// <summary>
/// 对象拓展方法
/// </summary>
public static class ObjectExtensions
{
    /// <summary>
    /// 验证指定值的断言<paramref name="assertion"/>是否为真，如果不为真，抛出指定消息<paramref name="message"/>的指定类型<typeparamref name="TException"/>异常
    /// </summary>
    /// <typeparam name="TException">异常类型</typeparam>
    /// <param name="assertion">要验证的断言。</param>
    /// <param name="message">异常消息。</param>
    private static void Require<TException>(bool assertion, string message)
        where TException : Exception
    {
        if (assertion)
        {
            return;
        }

        if (string.IsNullOrEmpty(message))
        {
            throw new ArgumentNullException(nameof(message));
        }

        TException exception = (TException)Activator.CreateInstance(typeof(TException), message);
        throw exception;
    }

    /// <summary>
    /// 验证指定值的断言表达式是否为真，不为值抛出<see cref="Exception"/>异常
    /// </summary>
    /// <param name="value"></param>
    /// <param name="assertionFunc">要验证的断言表达式</param>
    /// <param name="message">异常消息</param>
    public static void Required<T>(this T value, Func<T, bool> assertionFunc, string message)
    {
        if (assertionFunc == null)
        {
            throw new ArgumentNullException(nameof(assertionFunc));
        }

        Require<Exception>(assertionFunc(value), message);
    }

    /// <summary>
    /// 验证指定值的断言表达式是否为真，不为真抛出<typeparamref name="TException"/>异常
    /// </summary>
    /// <typeparam name="T">要判断的值的类型</typeparam>
    /// <typeparam name="TException">抛出的异常类型</typeparam>
    /// <param name="value">要判断的值</param>
    /// <param name="assertionFunc">要验证的断言表达式</param>
    /// <param name="message">异常消息</param>
    public static void Required<T, TException>(this T value, Func<T, bool> assertionFunc, string message)
        where TException : Exception
    {
        if (assertionFunc == null)
        {
            throw new ArgumentNullException(nameof(assertionFunc));
        }

        Require<TException>(assertionFunc(value), message);
    }

    /// <summary>
    /// 检查参数不能为空引用，否则抛出<see cref="ArgumentNullException"/>异常。
    /// </summary>
    /// <param name="value"></param>
    /// <param name="paramName">参数名称</param>
    /// <exception cref="ArgumentNullException"></exception>
    public static void NotNull<T>(this T value, string paramName)
    {
        Require<ArgumentNullException>(value != null, $"参数“{paramName}”不能为空引用。");
    }

    /// <summary>
    /// 检查字符串不能为空引用或空字符串，否则抛出<see cref="ArgumentNullException"/>异常或<see cref="ArgumentException"/>异常。
    /// </summary>
    /// <param name="value"></param>
    /// <param name="paramName">参数名称。</param>
    /// <exception cref="ArgumentNullException"></exception>
    /// <exception cref="ArgumentException"></exception>
    public static void NotNullOrEmpty(this string value, string paramName)
    {
        Require<ArgumentException>(!string.IsNullOrEmpty(value), $"参数“{paramName}”不能为空引用或空字符串。");
    }

    /// <summary>
    /// 检查Guid值不能为Guid.Empty，否则抛出<see cref="ArgumentException"/>异常。
    /// </summary>
    /// <param name="value"></param>
    /// <param name="paramName">参数名称。</param>
    /// <exception cref="ArgumentException"></exception>
    public static void NotEmpty(this Guid value, string paramName)
    {
        Require<ArgumentException>(value != Guid.Empty, $"参数“{paramName}”的值不能为Guid.Empty");
    }

    /// <summary>
    /// 检查集合不能为空引用或空集合，否则抛出<see cref="ArgumentNullException"/>异常或<see cref="ArgumentException"/>异常。
    /// </summary>
    /// <typeparam name="T">集合项的类型。</typeparam>
    /// <param name="collection"></param>
    /// <param name="paramName">参数名称。</param>
    /// <exception cref="ArgumentNullException"></exception>
    /// <exception cref="ArgumentException"></exception>
    public static void NotNullOrEmpty<T>(this IEnumerable<T> collection, string paramName)
    {
        NotNull(collection, paramName);
        Require<ArgumentException>(collection.Any(), $"参数“{paramName}”不能为空引用或空集合。");
    }

    /// <summary>
    ///  检查集合不能为空委托，否则抛出<see cref="ArgumentNullException"/>异常或<see cref="ArgumentException"/>异常。
    /// </summary>
    /// <typeparam name="TSource">委托类型</typeparam>
    /// <typeparam name="TResult">委托类型</typeparam>
    /// <param name="func">委托</param>
    /// <param name="paramName">参数名称。</param>
    public static void NotNull<TSource, TResult>(this Func<TSource, TResult> func, string paramName)
    {
        NotNull(func, paramName);
        Require<ArgumentException>(func.IsNotNull(), $"参数“{paramName}”不能为空委托。");
    }

    /// <summary>
    /// 把对象类型转换为指定类型
    /// </summary>
    /// <param name="value">要转换的值</param>
    /// <param name="type">要转换的类型</param>
    /// <returns></returns>
    public static object AsTo(this object value, Type type)
    {
        if (value == null || value is DBNull)
        {
            return null;
        }

        //如果是Nullable类型
        if (type.IsNullableType())
        {
            type = type.GetUnNullableType();
        }

        //枚举类型
        if (type.IsEnum)
        {
            return Enum.Parse(type, value.ToString());
        }

        //if (type == typeof(Enum))
        //{
        //    return Enum.Parse(type, value.ToString());
        //}
        if (type == typeof(Guid))
        {
            Guid.TryParse(value.ToString(), out var newGuid);
            return newGuid;
        }

        if (value?.GetType() == typeof(Guid))
        {
            return value.ToString();
        }

        return Convert.ChangeType(value, type);
    }

    /// <summary>
    /// 把对象类型转换为指定类型
    /// </summary>
    /// <typeparam name="T">动态类型</typeparam>
    /// <param name="value">要转换对象</param>
    /// <returns>转化后的指定类型的对象</returns>
    public static T AsTo<T>(this object value)
    {
        return (T)AsTo(value, typeof(T));
    }

    /// <summary>
    /// 类型转换
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="obj"></param>
    /// <returns></returns>
    public static T As<T>(this object obj) where T : class
    {
        return (T)obj;
    }

    /// <summary>
    /// 是否为Null
    /// </summary>
    /// <param name="value">判断的值</param>
    /// <returns>true为null,false不为null</returns>
    public static bool IsNull(this object value)
    {
        return value == null ? true : false;
    }

    public static bool IsNotNull(this object value)
    {
        return !value.IsNull();
    }

    /// <summary>
    /// 判断特性相应是否存在
    /// </summary>
    /// <typeparam name="T">动态类型要判断的特性</typeparam>
    /// <param name="memberInfo"></param>
    /// <param name="inherit"></param>
    /// <returns>如果存在还在返回true，否则返回false</returns>
    public static bool HasAttribute<T>(this MemberInfo memberInfo, bool inherit = true) where T : Attribute
    {
        return memberInfo.IsDefined(typeof(T), inherit);
    }
    
    /// <summary>
    /// 将object转换为char类型信息。
    /// </summary>
    /// <param name="o">object。</param>
    /// <param name="t">默认值。</param>
    /// <returns>char。</returns>
    public static char ToChar(this object o, char t = default(char))
    {
        char info;
        if (!char.TryParse(o.ToString(string.Empty), out info))
        {
            info = t;
        }
        return info;
    }
}