package com.zy.asrs.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.core.exception.CoolException;
import com.zy.asrs.service.RuntimeConfigService;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

@Service("runtimeConfigService")
public class RuntimeConfigServiceImpl implements RuntimeConfigService {

    private static final LinkedHashMap<String, RuntimeConfigRule> RUNTIME_CONFIG_RULE_MAP = buildRuntimeConfigRuleMap();

    @Autowired
    private ConfigService configService;

    @Override
    @Transactional
    public Map<String, Object> updateRuntimeConfig(Map<String, Object> configMap) {
        if (configMap == null || configMap.isEmpty()) {
            throw new CoolException("参数不能为空");
        }

        LinkedHashMap<String, String> normalizedMap = new LinkedHashMap<>();
        for (Map.Entry<String, Object> entry : configMap.entrySet()) {
            String code = entry.getKey();
            RuntimeConfigRule rule = RUNTIME_CONFIG_RULE_MAP.get(code);
            if (rule == null) {
                throw new CoolException("不支持的运行参数: " + code);
            }

            Config config = getConfig(code);
            if (config == null) {
                throw new CoolException("运行参数不存在: " + code);
            }
            if (!Short.valueOf((short) 1).equals(config.getStatus())) {
                throw new CoolException("运行参数已禁用: " + code);
            }

            normalizedMap.put(code, rule.normalize(code, entry.getValue()));
        }

        LinkedHashMap<String, String> changedMap = saveChangedConfig(normalizedMap);
        if (!changedMap.isEmpty()) {
            configService.refreshSystemConfigCache();
        }

        LinkedHashMap<String, Object> result = new LinkedHashMap<>();
        result.put("changed", changedMap);
        result.put("current", buildRuntimeConfigSnapshot(normalizedMap.keySet()));
        return result;
    }

    private LinkedHashMap<String, String> saveChangedConfig(LinkedHashMap<String, String> normalizedMap) {
        LinkedHashMap<String, String> changedMap = new LinkedHashMap<>();
        for (Map.Entry<String, String> entry : normalizedMap.entrySet()) {
            Config config = getConfig(entry.getKey());
            if (config == null) {
                throw new CoolException("运行参数不存在: " + entry.getKey());
            }
            if (Objects.equals(config.getValue(), entry.getValue())) {
                continue;
            }
            config.setValue(entry.getValue());
            if (!configService.updateById(config)) {
                throw new CoolException("保存失败: " + entry.getKey());
            }
            changedMap.put(entry.getKey(), entry.getValue());
        }
        return changedMap;
    }

    private LinkedHashMap<String, String> buildRuntimeConfigSnapshot(Set<String> codeSet) {
        LinkedHashMap<String, String> result = new LinkedHashMap<>();
        for (String code : codeSet) {
            Config config = getConfig(code);
            if (config != null) {
                result.put(code, config.getValue());
            }
        }
        return result;
    }

    private Config getConfig(String code) {
        return configService.getOne(new QueryWrapper<Config>().eq("code", code).last("limit 1"));
    }

    private static LinkedHashMap<String, RuntimeConfigRule> buildRuntimeConfigRuleMap() {
        LinkedHashMap<String, RuntimeConfigRule> ruleMap = new LinkedHashMap<>();
        putIntRule(ruleMap, "conveyorStationTaskLimit", 1, 1000);
        putIntRule(ruleMap, "stationCommandSendLength", 1, 200);
        putRatioRule(ruleMap, "stationCommandSegmentAdvanceRatio");
        putIntRule(ruleMap, "stationCommandConfigRefreshSeconds", 5, 300);
        putIntRule(ruleMap, "stationV5SegmentExecutorPoolSize", 16, 512);
        putIntRule(ruleMap, "stationV5SegmentExecutorQueueCapacity", 64, 4096);
        putIntRule(ruleMap, "crnOutBatchRunningLimit", 0, 1000);
        putBooleanRule(ruleMap, "crnOutRequireStationOutEnable");
        putIntRule(ruleMap, "deviceCommandAutoRollbackLimit", 1, 100);
        putBooleanRule(ruleMap, "checkDeepLocOutTaskBlockReport");
        return ruleMap;
    }

    private static void putIntRule(LinkedHashMap<String, RuntimeConfigRule> ruleMap,
                                   String code,
                                   int min,
                                   int max) {
        ruleMap.put(code, new RuntimeConfigRule(RuntimeConfigValueType.INT, min, max));
    }

    private static void putRatioRule(LinkedHashMap<String, RuntimeConfigRule> ruleMap, String code) {
        ruleMap.put(code, new RuntimeConfigRule(RuntimeConfigValueType.RATIO, 0, 100));
    }

    private static void putBooleanRule(LinkedHashMap<String, RuntimeConfigRule> ruleMap, String code) {
        ruleMap.put(code, new RuntimeConfigRule(RuntimeConfigValueType.BOOLEAN, 0, 0));
    }

    private enum RuntimeConfigValueType {
        INT,
        RATIO,
        BOOLEAN
    }

    private static class RuntimeConfigRule {

        private final RuntimeConfigValueType valueType;
        private final int min;
        private final int max;

        private RuntimeConfigRule(RuntimeConfigValueType valueType, int min, int max) {
            this.valueType = valueType;
            this.min = min;
            this.max = max;
        }

        private String normalize(String code, Object rawValue) {
            if (rawValue == null) {
                throw new CoolException(code + " 参数不能为空");
            }
            String value = String.valueOf(rawValue).trim();
            if (value.isEmpty()) {
                throw new CoolException(code + " 参数不能为空");
            }
            if (RuntimeConfigValueType.BOOLEAN.equals(valueType)) {
                return normalizeBoolean(code, value);
            }
            if (RuntimeConfigValueType.RATIO.equals(valueType)) {
                return normalizeRatio(code, value);
            }
            return normalizeInt(code, value);
        }

        private String normalizeBoolean(String code, String value) {
            if ("Y".equalsIgnoreCase(value) || "true".equalsIgnoreCase(value) || "1".equals(value)) {
                return "Y";
            }
            if ("N".equalsIgnoreCase(value) || "false".equalsIgnoreCase(value) || "0".equals(value)) {
                return "N";
            }
            throw new CoolException(code + " 仅支持 Y/N、true/false 或 1/0");
        }

        private String normalizeRatio(String code, String value) {
            String text = value;
            boolean percentText = text.endsWith("%");
            if (percentText) {
                text = text.substring(0, text.length() - 1).trim();
            }
            double parsed;
            try {
                parsed = Double.parseDouble(text);
            } catch (Exception e) {
                throw new CoolException(code + " 必须为 0~1 比例或 0~100 百分比");
            }
            if (parsed < 0d || parsed > 100d) {
                throw new CoolException(code + " 必须为 0~1 比例或 0~100 百分比");
            }
            if (percentText || parsed > 1d) {
                parsed = parsed / 100d;
            }
            return stripTrailingZero(parsed);
        }

        private String normalizeInt(String code, String value) {
            int parsed;
            try {
                parsed = Integer.parseInt(value);
            } catch (Exception e) {
                throw new CoolException(code + " 必须为整数");
            }
            if (parsed < min || parsed > max) {
                throw new CoolException(code + " 必须在 " + min + "~" + max + " 范围内");
            }
            return String.valueOf(parsed);
        }

        private String stripTrailingZero(double value) {
            String text = java.math.BigDecimal.valueOf(value).stripTrailingZeros().toPlainString();
            return "-0".equals(text) ? "0" : text;
        }
    }
}