using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.Extensions.DependencyModel;
using Microsoft.IdentityModel.Tokens;
using OfficeOpenXml.FormulaParsing.Excel.Functions.DateTime;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.Attributes;
using WIDESEA_Core.Helper;

namespace WIDESEA_Core.Utilities
{
    public class ModelValidate
    {
        /// <summary>
        /// 验证实体参数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="data"></param>
        /// <returns></returns>
        public static (bool, string, object?) ValidateModelData<T>(T data) where T : class, new()
        {
            Type modelType = typeof(T);
            if (data == null) return (false, "传入参数不可为null", data);
            ModelValidateAttribute? modelAttribute = modelType.GetCustomAttribute<ModelValidateAttribute>();
            if (modelAttribute == null) return (false, $"{modelType.Name}未定义【ModelValidateAttribute】特性", data);
            PropertyInfo[] propertyInfos = modelType.GetProperties();
            return SimpleValidate(propertyInfos, data);
        }
        public static (bool, string, object?) ValidateModelData(object data, Type type)
        {
            if (data == null) return (false, "传入参数不可为null", data);
            ModelValidateAttribute? modelAttribute = type.GetCustomAttribute<ModelValidateAttribute>();
            if (modelAttribute == null) return (false, $"{type.Name}未定义【ModelValidateAttribute】特性", data);
            PropertyInfo[] propertyInfos = type.GetProperties();
            return SimpleValidate(propertyInfos, data);
        }
        /// <summary>
        /// 验证实体参数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="data"></param>
        /// <returns></returns>
        public static (bool, string, object?) ValidateModelData<T>(List<T> datas) where T : class, new()
        {
            Type modelType = typeof(T);
            if (datas == null) return (false, "传入参数不可为null", datas);
            if (datas.Count == 0) return (false, "集合个数不可等于0", datas);
            foreach (T data in datas)
            {
                if (data == null) return (false, "传入参数不可为null", data);
                ModelValidateAttribute? modelAttribute = modelType.GetCustomAttribute<ModelValidateAttribute>();
                if (modelAttribute == null) return (false, $"{modelType.Name}未定义【ModelValidateAttribute】特性", data);
                PropertyInfo[] propertyInfos = modelType.GetProperties();
                (bool, string, object?) result = SimpleValidate(propertyInfos, data);
                if (!result.Item1) return result;
            }

            return (true, $"成功", datas);
        }

        //private static (bool, string, object?) CustomMethodValidate<T>(ModelValidateAttribute modelAttribute, T data) where T : class, new()
        //{
        //    try
        //    {
        //        if (modelAttribute.CustomValidateMethodTypeName == null) return (false, $"自定义验证方法需要提供方法所在类的类型对象", data);
        //        if (modelAttribute.CustomValidateMethodName == null) return (false, $"自定义验证方法需要提供方法名", data);

        //        string path = Path.Combine(AppContext.BaseDirectory, $"{modelAttribute.CustomValidateAssemblyName}.dll");
        //        Assembly assembly = Assembly.LoadFrom(path);

        //        Type t = assembly.GetType(modelAttribute.CustomValidateAssemblyName + "." + modelAttribute.CustomValidateMethodTypeName);
        //        object bbb = App.GetService(t);
        //        MethodInfo? methodInfo = t.GetMethod(modelAttribute.CustomValidateMethodName);
        //        var result = methodInfo.Invoke(bbb, new object[] { data });
        //        //MethodInfo? methodInfo = modelAttribute.CustomValidateMethodType.GetMethod(modelAttribute.CustomValidateMethodName);
        //        //if (methodInfo == null) return (false, $"未在该类型对象【{modelAttribute.CustomValidateMethodType.Name}】中找到该方法【{modelAttribute.CustomValidateMethodName}】", data);
        //        //methodInfo.GetGenericArguments()
        //        return (true, "成功", data);
        //    }
        //    catch(Exception ex)
        //    {
        //        throw new Exception();
        //    }

        //}

        private static (bool, string, object?) SimpleValidate<T>(PropertyInfo[] propertyInfos, T data) where T : class, new()
        {
            try
            {
                foreach (PropertyInfo propertyInfo in propertyInfos)
                {
                    PropertyValidateAttribute? propertyAttribute = propertyInfo.GetCustomAttribute<PropertyValidateAttribute>();
                    if (propertyAttribute == null) continue;

                    object? value = propertyInfo.GetValue(data, null);
                    // 提取描述（减少重复代码）
                    string propDesc = string.IsNullOrEmpty(propertyAttribute.Description) ? propertyInfo.Name : propertyAttribute.Description;

                    // 非空验证（保持不变）
                    if (propertyAttribute.NotNullAndEmpty)
                    {
                        if (value == null) return (false, $"{propDesc}不可为null", data);
                        if (string.IsNullOrEmpty(value.ToString())) return (false, $"{propDesc}不可为空字符串", data);
                    }

                    // 最小值验证（核心修改：兼容小数）
                    if (propertyAttribute.MinValue > int.MinValue)
                    {
                        if (value == null) return (false, $"{propDesc}不可为null", data);

                        // 关键：先将值转换为decimal（支持小数），避免直接转int报错
                        if (!decimal.TryParse(value.ToString(), out decimal valueDecimal))
                        {
                            return (false, $"{propDesc}的值【{value}】不是有效的数值格式（需为整数或小数）", data);
                        }

                        // 将int类型的MinValue转为decimal再比较（int可隐式转decimal）
                        decimal minValue = propertyAttribute.MinValue;
                        if (propertyAttribute.IsContainMinValue)
                        {
                            if (valueDecimal < minValue)
                                return (false, $"{propDesc}的值【{value}】不可小于【{minValue}】", data);
                        }
                        else
                        {
                            if (valueDecimal <= minValue)
                                return (false, $"{propDesc}的值【{value}】要大于【{minValue}】", data);
                        }
                    }

                    // 最大值验证（核心修改：兼容小数）
                    if (propertyAttribute.MaxValue < int.MaxValue)
                    {
                        if (value == null) return (false, $"{propDesc}不可为null", data);

                        // 同样先转decimal
                        if (!decimal.TryParse(value.ToString(), out decimal valueDecimal))
                        {
                            return (false, $"{propDesc}的值【{value}】不是有效的数值格式（需为整数或小数）", data);
                        }

                        // int转decimal比较
                        decimal maxValue = propertyAttribute.MaxValue;
                        if (propertyAttribute.IsContainMaxValue)
                        {
                            if (valueDecimal > maxValue)
                                return (false, $"{propDesc}的值【{value}】不可大于【{maxValue}】", data);
                        }
                        else
                        {
                            if (valueDecimal >= maxValue)
                                return (false, $"{propDesc}的值【{value}】要小于【{maxValue}】", data);
                        }
                    }

                    if (!string.IsNullOrEmpty(propertyAttribute.NotNullAndEmptyWithProperty))
                    {
                        PropertyInfo? property = propertyInfos.FirstOrDefault(x => x.Name == propertyAttribute.NotNullAndEmptyWithProperty);
                        if (property != null)
                        {
                            object? tempValue = property.GetValue(data);
                            if (tempValue != null && !string.IsNullOrEmpty(tempValue.ToString()))
                            {
                                Type[] types = propertyInfo.PropertyType.GenericTypeArguments;
                                if (types.Length == 1)
                                {
                                    string str = value.Serialize();
                                    if (str == "[]")
                                    {
                                        return (false, $"【{property.Name}】属性的值非空时【{propertyInfo.Name}】属性的值也不可为空", data);
                                    }
                                }
                                else if (types.Length == 0)
                                {
                                    if (value == null)
                                    {
                                        return (false, $"【{property.Name}】属性的值非空时【{propertyInfo.Name}】属性的值也不可为空", data);
                                    }
                                }

                            }
                        }
                        else
                        {
                            return (false, $"未找到【{propertyInfo.Name}】特性属性【{propertyAttribute.NotNullAndEmptyWithProperty}】", data);
                        }
                    }

                    if (propertyAttribute.NotNullAndEmptyWithPropertyAndValue != null && propertyAttribute.NotNullAndEmptyWithPropertyAndValue.Length == 2)
                    {
                        PropertyInfo? property = propertyInfos.FirstOrDefault(x => x.Name == propertyAttribute.NotNullAndEmptyWithPropertyAndValue[0]);
                        if (property != null)
                        {
                            object? tempValue = property.GetValue(data);
                            if (tempValue != null && !string.IsNullOrEmpty(tempValue.ToString()))
                            {
                                Type[] types = propertyInfo.PropertyType.GenericTypeArguments;
                                if (types.Length == 1)
                                {
                                    if (tempValue.ChangeType(property.PropertyType).ToString() == propertyAttribute.NotNullAndEmptyWithPropertyAndValue[1].ChangeType(property.PropertyType).ToString())
                                    {
                                        string str = value.Serialize();
                                        if (str == "[]")
                                        {
                                            return (false, $"【{property.Name}】属性的值为【{propertyAttribute.NotNullAndEmptyWithPropertyAndValue[1]}】时【{propertyInfo.Name}】属性的值不可为空", data);
                                        }
                                    }
                                       
                                }
                                else if (types.Length == 0)
                                {
                                    if (tempValue.ChangeType(property.PropertyType).ToString() == propertyAttribute.NotNullAndEmptyWithPropertyAndValue[1].ChangeType(property.PropertyType).ToString() && value == null && string.IsNullOrEmpty(value.ToString()))
                                    {
                                        return (false, $"【{property.Name}】属性的值为【{propertyAttribute.NotNullAndEmptyWithPropertyAndValue[1]}】时【{propertyInfo.Name}】属性的值不可为空", data);
                                    }
                                }

                            }
                        }
                        else
                        {
                            return (false, $"未找到属性【{propertyAttribute.NotNullAndEmptyWithProperty}】", data);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                return (false, $"数据验证异常,异常信息:{ex.Message}", data);
            }
            return (true, "验证成功", data);
        }
    }
}