package com.vincent.rsf.openApi.utils;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.vincent.rsf.openApi.entity.app.ApiFunction;
import com.vincent.rsf.openApi.entity.app.ApiMap;
import com.vincent.rsf.openApi.entity.app.App;
import com.vincent.rsf.openApi.service.ApiMapService;
import com.vincent.rsf.openApi.service.ApiFunctionService;
import com.vincent.rsf.openApi.service.AppService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.tika.utils.StringUtils;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 接口字段动态映射工具类
 * 支持从数据库加载映射配置，并提供字段转换功能
 *
 * @author vincent
 * @since 2026-01-04
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class ParamsMapUtils {

    private final AppService appService;
    private final ApiFunctionService functionService;
    private final ApiMapService mapService;

    // 缓存到内存
    public static List<App> APPS = new ArrayList<>();
    public static List<ApiFunction> FUNCTIONS = new ArrayList<>();
    public static List<ApiMap> ATTRIBUTE_MAPS = new ArrayList<>();

    /**
     * 应用完全启动后自动加载配置
     * 使用 ApplicationReadyEvent 确保 Spring 容器完全初始化
     */
    @EventListener(ApplicationReadyEvent.class)
    public void init() {
        log.info("=============== 开始加载接口映射配置 ===============");
        try {
            appService.refreshCache();
            functionService.refreshCache();
            mapService.refreshCache();

            log.info("接口映射配置加载完成 - 应用数:{}, 功能数:{}, 映射规则数:{}",
                    APPS.size(), FUNCTIONS.size(), ATTRIBUTE_MAPS.size());
        } catch (Exception e) {
            log.error("接口映射配置加载失败", e);
        }
    }

    /**
     * 手动刷新所有缓存
     */
    public void refreshAll() {
        log.info("手动刷新所有映射缓存...");
        appService.refreshCache();
        functionService.refreshCache();
        mapService.refreshCache();
    }

    /**
     * 执行字段映射转换
     *
     * @param appId 应用ID
     * @param funcId 功能ID
     * @param params 原始参数
     * @return 转换后的参数
     */
    public static JSONObject apiMaps(String appId, String funcId, JSONObject params) {
        if (params == null || params.isEmpty()) {
            return params;
        }

        // 1、获取映射表
        List<ApiMap> maps = ATTRIBUTE_MAPS.stream()
                .filter(map -> map.getAppId().equals(appId) && map.getFuncId().equals(funcId))
                .toList();

        if (maps.isEmpty()) {
            log.debug("未找到映射配置 - appId:{}, funcId:{}", appId, funcId);
            return params;
        }

        // 2、构建映射规则Map
        Map<String, String> mappingRules = new HashMap<>();
        for (ApiMap map : maps) {
            String sourceAttribute = map.getSourceAttribute();
            String targetAttribute = map.getTargetAttribute();
            if (!StringUtils.isBlank(sourceAttribute) && !StringUtils.isBlank(targetAttribute)) {
                mappingRules.put(sourceAttribute, targetAttribute);
            }
        }

        // 3、递归替换所有层级的属性名称
        JSONObject result = replaceKeysRecursive(params, mappingRules);

        return result;
    }

    /**
     * 递归替换JSON所有层级的属性名称
     * 支持嵌套对象和数组的深度遍历
     *
     * @param json 原始JSON对象
     * @param mappingRules 映射规则 (源字段名 -> 目标字段名)
     * @return 替换后的JSON对象
     */
    public static JSONObject replaceKeysRecursive(JSONObject json, Map<String, String> mappingRules) {
        if (json == null || json.isEmpty()) {
            return json;
        }

        JSONObject result = new JSONObject();

        for (String key : json.keySet()) {
            Object value = json.get(key);

            // 确定新的键名（如果有映射规则则使用映射后的名称）
            String newKey = mappingRules.getOrDefault(key, key);

            if (value instanceof JSONObject) {
                // 递归处理嵌套对象
                JSONObject nestedResult = replaceKeysRecursive((JSONObject) value, mappingRules);
                result.put(newKey, nestedResult);
                log.debug("替换对象字段: {} -> {}", key, newKey);

            } else if (value instanceof JSONArray) {
                // 递归处理数组
                JSONArray arrayResult = replaceKeysInArray((JSONArray) value, mappingRules);
                result.put(newKey, arrayResult);
                log.debug("替换数组字段: {} -> {}", key, newKey);

            } else {
                // 普通值直接赋值
                Object convertedValue = convertValue(value, newKey);
                result.put(newKey, convertedValue);
                if (!key.equals(newKey)) {
                    log.debug("替换字段: {} -> {} (值: {})", key, newKey, convertedValue);
                }
            }
        }

        return result;
    }

    /**
     * 递归处理JSON数组中的所有元素
     *
     * @param array 原始JSON数组
     * @param mappingRules 映射规则
     * @return 处理后的JSON数组
     */
    private static JSONArray replaceKeysInArray(JSONArray array, Map<String, String> mappingRules) {
        if (array == null || array.isEmpty()) {
            return array;
        }

        JSONArray result = new JSONArray();

        for (int i = 0; i < array.size(); i++) {
            Object element = array.get(i);

            if (element instanceof JSONObject) {
                // 数组元素是对象，递归处理
                JSONObject replacedObject = replaceKeysRecursive((JSONObject) element, mappingRules);
                result.add(replacedObject);

            } else if (element instanceof JSONArray) {
                // 数组元素是数组，递归处理
                JSONArray replacedArray = replaceKeysInArray((JSONArray) element, mappingRules);
                result.add(replacedArray);

            } else {
                // 基本类型，直接添加
                result.add(element);
            }
        }

        return result;
    }

    /**
     * 通用的JSON属性名替换方法（对外提供）
     * 可以直接传入映射规则进行替换
     *
     * @param json 原始JSON对象
     * @param mappingRules 映射规则 Map<源字段名, 目标字段名>
     * @return 替换后的JSON对象
     */
    public static JSONObject replaceJsonKeys(JSONObject json, Map<String, String> mappingRules) {
        return replaceKeysRecursive(json, mappingRules);
    }

    /**
     * 通用的JSON数组属性名替换方法（对外提供）
     *
     * @param array 原始JSON数组
     * @param mappingRules 映射规则 Map<源字段名, 目标字段名>
     * @return 替换后的JSON数组
     */
    public static JSONArray replaceJsonArrayKeys(JSONArray array, Map<String, String> mappingRules) {
        return replaceKeysInArray(array, mappingRules);
    }


    /**
     * 值类型转换（可扩展）
     *
     * @param value 原始值
     * @param targetField 目标字段名
     * @return 转换后的值
     */
    private static Object convertValue(Object value, String targetField) {
        if (value == null) {
            return null;
        }

        // 这里可以根据需要添加更多类型转换逻辑
        // 例如：日期格式转换、数字精度转换等

        // 示例：如果字段名包含amount、price等，转换为BigDecimal
        String lowerField = targetField.toLowerCase();
        if ((lowerField.contains("amount") || lowerField.contains("price")
                || lowerField.contains("qty")) && value instanceof String) {
            try {
                return new BigDecimal(value.toString());
            } catch (Exception e) {
                log.warn("数字转换失败: {} -> {}", value, targetField);
                return value;
            }
        }

        return value;
    }

    /**
     * 获取应用信息
     *
     * @param appId 应用ID
     * @return 应用信息
     */
    public static App getApp(String appId) {
        return APPS.stream()
                .filter(app -> app.getId().equals(appId))
                .findFirst()
                .orElse(null);
    }

    /**
     * 获取功能信息
     *
     * @param funcId 功能ID
     * @return 功能信息
     */
    public static ApiFunction getFunction(String funcId) {
        return FUNCTIONS.stream()
                .filter(func -> func.getId().equals(funcId))
                .findFirst()
                .orElse(null);
    }
}