package org.example.Entity.Attributes;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class AttributeUtils {
    private static final Logger log = LoggerFactory.getLogger(AttributeUtils.class);

    /**
     * 模拟C#的Attribute.GetCustomAttribute方法
     * 从方法或类上获取自定义属性实例
     */
    @SuppressWarnings("unchecked")
//    public static <T extends Attribute> T getAttribute(Method method, Class<T> attributeClass) {
//        // 1. 先从方法的参数上查找（如果有标注）
//        List<T> attributes = findAttributes(method.getDeclaringClass(), attributeClass);
//        if (!attributes.isEmpty()) {
//            return attributes.get(0);
//        }
//        // 2. 从方法本身查找
//        attributes = findAttributes(method, attributeClass);
//        return attributes.isEmpty() ? null : attributes.get(0);
//    }
    public static RequestCheckAttribute getAttribute(Method method) {
        // 1. 检查方法上是否有@RequestCheck注解
        if (method.isAnnotationPresent(RequestCheck.class)) {
            RequestCheck annotation = method.getAnnotation(RequestCheck.class);
            return convertAnnotationToAttribute(annotation);
        }
        // 2. 若方法无注解，检查类上的注解
        Class<?> clazz = method.getDeclaringClass();
        if (clazz.isAnnotationPresent(RequestCheck.class)) {
            RequestCheck annotation = clazz.getAnnotation(RequestCheck.class);
            return convertAnnotationToAttribute(annotation);
        }
        // 3. 若都无注解，返回null（或默认默认配置）
        return null;
    }

    // 将注解转换为RequestCheckAttribute实例
    private static RequestCheckAttribute convertAnnotationToAttribute(RequestCheck annotation) {
        RequestCheckAttribute attribute = new RequestCheckAttribute();
        attribute.CheckLogin = annotation.CheckLogin();
        attribute.CheckParams = annotation.CheckParams();
        attribute.Log = annotation.Log();
        attribute.Verify = annotation.Verify();
        attribute.Cache = annotation.Cache();
        attribute.ExpirationPeriod = annotation.ExpirationPeriod();
        attribute.Name = annotation.Name();
        attribute.Desp = annotation.Desp();
        return attribute;
    }

    public static <T extends Attribute> T getCustomAttribute(Class<?> type, Class<T> attributeClass) {
        List<T> attributes = findAttributes(type, attributeClass);
        return attributes.isEmpty() ? null : attributes.get(0);
    }

    /**
     * 从目标对象（类/方法）中查找自定义属性实例
     */
    private static <T extends Attribute> List<T> findAttributes(Object target, Class<T> attributeClass) {
        List<T> result = new ArrayList<>();
        try {
            // 实际项目中可改为：从类的特定字段或注解中解析属性
            // 这里模拟通过反射获取预定义的属性实例
            if (target instanceof Class<?>) {
                Class<?> clazz = (Class<?>) target;
                // 查找类中定义的属性实例（例如通过特定命名规范的字段）
                Field[] fields = clazz.getDeclaredFields();
                for (Field field : fields) {
                    log.debug(String.valueOf("扫描字段：" + field.getName() + "，类型：" + field.getType().getSimpleName()));
                    if (attributeClass.isAssignableFrom(field.getType())) {
                        field.setAccessible(true);
                        Object value = field.get(null); // 假设是静态字段
                        if (value != null) {
                            result.add((T) value);
                            log.debug(String.valueOf("找到匹配属性：" + field.getName()));
                        }
                    }
                }
            } else if (target instanceof Method) {
                Method method = (Method) target;
                // 查找方法上的属性实例（例如通过方法参数或注解）
                // 这里简化处理，实际可根据需要扩展
            }
        } catch (Exception e) {
            log.error("Exception caught", e);
        }
        return result;
    }
}