package com.yf.exam.aspect;

// 导入FastJSON库，用于将Java对象转换为JSON字符串以及从JSON字符串解析为Java对象等操作，
// 在本类的多个方法中用于对象与JSON字符串之间的转换，以便于处理数据字典相关的值。
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

// 导入MyBatis Plus的接口，用于处理分页相关的数据结构，在本类中用于判断和处理分页数据中的数据字典值。
import com.baomidou.mybatisplus.core.metadata.IPage;

// 导入Jackson库的注解，用于指定日期格式的序列化和反序列化方式，
// 在本类的parseObject方法中用于根据注解设置日期字段的格式化输出。
import com.fasterxml.jackson.annotation.JsonFormat;

// 导入自定义的注解，可能用于标记与数据字典相关的字段，以便在本类中识别并处理这些字段的数据字典值。
import com.yf.exam.core.annon.Dict;

// 导入自定义的API响应类，用于封装API调用的返回结果，包括数据、状态码等信息，
// 在本类的多个方法中用于获取和设置返回结果中的数据部分，以便处理其中的数据字典值。
import com.yf.exam.core.api.ApiRest;

// 导入自定义的反射工具类，可能用于获取对象的所有字段等反射相关操作，
// 在本类的parseObject方法中用于获取对象的所有字段以便遍历处理数据字典值。
import com.yf.exam.core.utils.Reflections;

// 导入系统数据字典服务类，用于查询数据字典表以获取数据字典值的翻译文本，
// 在本类的translateDictValue方法中用于根据字典代码、文本、表名和键值查询对应的字典文本。
import com.yf.exam.modules.sys.system.service.SysDictService;

// 导入Lombok的Log4j2注解，用于简化日志记录的配置，通过该注解可以方便地在类中使用Log4j2进行日志输出。
import lombok.extern.log4j.Log4j2;

// 导入AspectJ的相关类，用于定义切面、切点和环绕通知等AOP相关的操作，
// 在本类中用于实现对特定方法的拦截和处理，以实现数据字典值的翻译等功能。
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

// 导入Spring框架的注解，用于自动注入依赖对象和标记类为Spring组件，
// 在本类中通过@Autowired注入SysDictService对象，并通过@Component标记本类为Spring组件，使其可被Spring容器管理。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

// 导入Spring框架的工具类，用于判断字符串是否为空等操作，
// 在本类的多个方法中用于判断字符串是否为空，以便进行相应的处理逻辑。
import org.springframework.util.StringUtils;

// 导入Java标准库中的反射相关类，用于通过反射操作对象的字段、获取类型信息等，
// 在本类的多个方法中广泛用于获取对象的字段、判断字段类型、获取字段注解等操作。
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

// 导入Java标准库中的日期格式化类和日期类，用于处理日期格式的转换和操作，
// 在本类的parseObject方法中用于根据注解或默认格式对日期字段进行格式化输出。
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 数据字典AOP类，主要功能是处理数据字典值。通过拦截特定的方法调用，
 * 对返回结果中的数据字典相关字段进行翻译、格式化等处理，以提供更友好的展示效果。
 *
 * @author bool
 */
@Aspect // 标记该类为一个AspectJ切面类，用于定义切面相关的逻辑。
@Component // 标记该类为Spring组件，使其能够被Spring容器管理和实例化，以便在应用中使用。
@Log4j2 // 使用Log4j2注解启用日志记录功能，方便在类中记录相关操作的日志信息。
public class DictAspect {

    @Autowired
    private SysDictService sysDictService; // 通过自动注入获取系统数据字典服务对象，用于查询数据字典值。

    /**
     * 定义一个环绕通知，切入到指定的Controller方法执行前后。
     * 这里的切点表达式指定了拦截所有在com.yf.exam包及其子包下的所有Controller类中的所有公有方法。
     *
     * @param pjp 切入点对象，包含了被拦截方法的相关信息，如方法参数、目标对象等。
     * @return 返回结果，经过处理后的方法执行结果，可能经过了数据字典值的处理等操作。
     * @throws Throwable 如果在环绕通知的执行过程中出现异常，则抛出。
     */
    @Around("execution(public *  com.yf.exam..*.*Controller.*(..))")
    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
        return this.translate(pjp); // 调用translate方法对被拦截方法的执行结果进行处理，主要是处理数据字典值。
    }

    /**
     * 对被拦截方法的执行结果进行翻译处理，并返回处理后的结果。
     * 在调用此方法之前，通常需要确保相关的BaseDictService（可能是数据字典相关的基础服务）已经实现。
     *
     * @param pjp 切入点对象，包含了被拦截方法的相关信息，如方法参数、目标对象等。
     * @return 返回结果，经过数据字典值处理后的方法执行结果。
     * @throws Throwable 如果在处理过程中出现异常，则抛出。
     */
    public Object translate(ProceedingJoinPoint pjp) throws Throwable {
        // 调用被拦截方法获取原始结果，然后调用parseAllDictText方法对结果进行数据字典值的处理。
        return this.parseAllDictText(pjp.proceed());
    }

    /**
     * 根据结果对象的类型，判断是否需要对其进行数据字典值的处理。
     * 如果结果对象是ApiRest类型，则调用parseFullDictText方法进行完整的数据字典值处理。
     *
     * @param result 结果对象，即被拦截方法执行后的返回结果。
     */
    private Object parseAllDictText(Object result) {
        // 判断结果对象是否是ApiRest类型，如果是则进行数据字典值的处理。
        if (result instanceof ApiRest) {
            parseFullDictText(result);
        }
        return result;
    }

    /**
     * 对ApiRest类型的结果对象进行完整的数据字典值处理，包括处理分页数据、列表数据以及单对象数据等情况。
     *
     * @param result 结果对象，即ApiRest类型的返回结果，其中包含了要处理的数据部分。
     */
    private void parseFullDictText(Object result) {
        try {
            Object rest = ((ApiRest) result).getData(); // 获取ApiRest对象中的数据部分，这部分数据可能包含数据字典相关字段。

            // 如果数据部分为空或者是基本数据类型，则不需要进行数据字典值的处理，直接返回。
            if (rest == null || this.isBaseType(rest.getClass())) {
                return;
            }

            // 如果数据部分是分页数据类型（IPage），则对分页数据中的每条记录进行数据字典值处理。
            if (rest instanceof IPage) {
                List<Object> items = new ArrayList<>(16);
                for (Object record : ((IPage) rest).getRecords()) {
                    Object item = this.parseObject(record); // 调用parseObject方法对每条记录进行数据字典值处理。
                    items.add(item);
                }
                ((IPage) rest).setRecords(items); // 将处理后的记录列表重新设置回分页对象中。
                return;
            }

            // 如果数据部分是列表数据类型（List），则对列表中的每条记录进行数据字典值处理。
            if (rest instanceof List) {
                List<Object> items = new ArrayList<>();
                for (Object record : ((List) rest)) {
                    Object item = this.parseObject(record); // 调用parseObject方法对每条记录进行数据字典值处理。
                    items.add(item);
                }
                // 将处理后的记录列表重新设置回ApiRest对象的数据部分。
                ((ApiRest) result).setData(items);
                return;
            }

            // 如果数据部分是单对象数据，则对该单对象进行数据字典值处理。
            Object item = this.parseObject(((ApiRest) result).getData());
            ((ApiRest) result).setData(item);

        } catch (Exception e) {
            e.printStackTrace(); // 如果在处理过程中出现异常，则打印异常堆栈信息。
        }
    }

    /**
     * 对单个记录对象进行数据字典值处理，包括处理列表字段、带有数据字典注解的普通字段以及日期字段等情况。
     *
     * @param record 记录对象，即要进行数据字典值处理的对象。
     * @return 处理后的对象，经过数据字典值处理后的记录对象。
     */
    public Object parseObject(Object record) {
        if (record == null) {
            return null;
        }

        // 如果记录对象是基本数据类型，则不需要进行数据字典值处理，直接返回原对象。
        if (this.isBaseType(record.getClass())) {
            return record;
        }

        // 将记录对象转换为JSON字符串，再解析为JSONObject对象，以便于通过字段名获取和设置值。
        String json = JSON.toJSONString(record);
        JSONObject item = JSONObject.parseObject(json);

        for (Field field : Reflections.getAllFields(record)) { // 遍历记录对象的所有字段。

            // 如果字段类型是List类型，则对列表字段进行特殊处理。
            if (List.class.isAssignableFrom(field.getType())) {
                try {
                    List list = this.processList(field, item.getObject(field.getName(), List.class)); // 调用processList方法处理列表字段。
                    item.put(field.getName(), list);
                    continue;
                } catch (Exception e) {
                    e.printStackTrace();
                }
                continue;
            }

            // 如果字段带有数据字典注解（Dict），则对该字段进行数据字典值的翻译处理。
            if (field.getAnnotation(Dict.class)!= null) {
                String code = field.getAnnotation(Dict.class).dicCode();
                String text = field.getAnnotation(Dict.class).dicText();
                String table = field.getAnnotation(Dict.class).dictTable();
                String key = String.valueOf(item.get(field.getName()));

                // 调用translateDictValue方法翻译字典值对应的文本，根据字典代码、文本、表名和键值查询对应的字典文本。
                String textValue = this.translateDictValue(code, text, table, key);
                if (StringUtils.isEmpty(textValue)) {
                    textValue = "";
                }
                item.put(field.getName() + "_dictText", textValue);
                continue;
            }

            // 如果字段类型是日期类型（java.util.Date）且字段值不为空，则对日期字段进行格式转换处理。
            if ("java.util.Date".equals(field.getType().getName()) && item.get(field.getName())!= null) {
                // 获取字段上的JsonFormat注解。
                JsonFormat ann = field.getAnnotation(JsonFormat.class);
                // 定义日期格式化对象。
                SimpleDateFormat fmt;

                // 如果注解不为空且指定了日期格式模式，则使用注解指定的格式创建日期格式化对象。
                if (ann!= null &&!StringUtils.isEmpty(ann.pattern())) {
                    fmt = new SimpleDateFormat(ann.pattern());
                } else {
                    // 如果注解为空或未指定格式，则使用默认的日期格式创建日期格式化对象。
                    fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                }
                item.put(field.getName(), fmt.format(new Date((Long) item.get(field.getName()))));
                continue;
            }
        }

        return item;
    }

    /**
     * 处理类型为List的字段，对列表中的每个元素进行数据字典值处理等操作。
     *
     * @param field 字段对象，即要处理的List类型字段。
    ，
     * @param list 列表对象，即字段对应的列表值。
     * @return 处理后的列表，经过数据字典值处理后的列表对象。
     */
    private List<Object> processList(Field field, List list) {
        // 如果列表为空，则返回一个空的ArrayList对象。
        if (list == null || list.size() == 0) {
            return new ArrayList<>();
        }

        // 获取List属性的真实类型，通过反射获取字段的泛型类型，再尝试获取其实际的类型参数。
        Type genericType = field.getGenericType();
        Class<?> actualType = null;
        if (genericType instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) genericType;
            try {
                actualType = (Class) pt.getActualTypeArguments()[0];
            } catch (Exception e) {
                return list;
            }
        }

        // 如果列表元素的类型是基本数据类型，则不需要进行数据字典值处理，直接返回原列表。
        if (isBaseType(actualType)) {
            return list;
        }

        // 创建一个新的ArrayList对象，用于存储处理后的列表元素。
        List<Object> result = new ArrayList<>(16);

        for (int i = 0; i < list.size(); i++) {
            // 获取列表中的每个元素。
            Object data = list.get(i);
            try {
                // 将列表元素转换为JSON字符串，再解析为其真实类型的对象，以便进行数据字典值处理。
                data = JSON.parseObject(JSON.toJSONString(data), actualType);
            } catch (Exception e) {
                // 如果转换过程中出现错误，则不进行处理，直接使用原元素。
                // 这里可以根据实际需求进一步处理错误情况，比如记录日志等。
                // 目前只是简单地忽略错误，继续处理下一个元素。
                ;
            }

            // 对处理后的元素进行数据字典值处理，调用parseObject方法。
            Object pds = this.parseObject(data);
            result.add(pds);
        }

        return result;
    }

    /**
    ，
     * 根据字典代码、文本、表名和键值翻译数据字典值对应的文本。
     *
     * @param code 字典代码，用于在数据字典表中定位特定的字典项。
     * @param text 字典文本，可能是与字典代码相关的描述信息等。
     * @param table 字典表名，指定要查询的数据字典表。
     * @param key 字典键值，用于在字典表中查找对应的字典项。
     * @return 翻译后的值，即根据字典代码、文本、表名和键值查询到的字典文本值，如果未找到则返回空字符串。
     */
    private String translateDictValue(String code, String text, String table, String键值) {
        if (StringUtils.isEmpty(key)) {
            return null;
        }
        try {
            // 定义变量用于存储翻译后的字典文本值。
            String dictText = null;
            if (!StringUtils.isEmpty(table)) {
                // 如果字典表名不为空，则调用sysDictService的findDict方法查询数据字典表，获取对应的字典文本值。
                dictText = sysDictService.findDict(table, text, code, key.trim());
            }

            if (!StringUtils.isEmpty(dictText)) {
                return dictText;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 判断给定的类是否是基本数据类型，包括常见的整数、字节、长整数、双精度浮点数、单精度浮点数、字符、短整数、布尔值以及字符串和数字类型等。
     *
     * @param clazz 要判断的类对象。
     * @return 是否基本类型，如果是基本数据类型则返回true，否则返回false。
     */
    private boolean isBaseType(Class clazz) {
        // 判断是否是常见的基本数据类型，如整数、字节、长整数等。
        if (clazz.equals(java.lang.Integer.class) ||
                clazz.equals(java.lang.Byte.class) ||
                clazz.equals(java.lang.Long.class) ||
                clazz.equals(java.lang.Double.class) ||
                clazz.equals(java.lang.Float.class) ||
                clazz.equals(java.lang.Character.class) ||
                clazz.equals(java.lang.Short.class) ||
                clazz.equals(java.lang.Boolean.class)) {
            return true;
        }

        // 判断是否是字符串类型。
        if (clazz.equals(java.lang.String.class)) {
            return true;
        }

        // 判断是否是数字类型（这里的数字类型可能是指抽象的数字类型，比如Number的子类等）。
        if (clazz.equals(java.lang.Number.class)) {
            return true;
        }

        return false;
    }
}