package com.zy.asrs.service.impl;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.zy.asrs.domain.path.StationPathProfileConfig;
import com.zy.asrs.domain.path.StationPathResolvedPolicy;
import com.zy.asrs.domain.path.StationPathRuleConfig;
import com.zy.asrs.entity.BasStationPathProfile;
import com.zy.asrs.entity.BasStationPathRule;
import com.zy.asrs.service.BasStationPathProfileService;
import com.zy.asrs.service.BasStationPathRuleService;
import com.zy.asrs.service.StationPathPolicyService;
import com.zy.common.utils.RedisUtil;
import com.zy.core.enums.RedisKeyType;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service("stationPathPolicyService")
@Slf4j
public class StationPathPolicyServiceImpl implements StationPathPolicyService {
    private static final long CACHE_TTL_MILLIS = 5_000L;

    @Autowired
    private BasStationPathProfileService basStationPathProfileService;
    @Autowired
    private BasStationPathRuleService basStationPathRuleService;
    @Autowired
    private RedisUtil redisUtil;

    private volatile CacheSnapshot cacheSnapshot = new CacheSnapshot();
    private volatile long cacheTime = 0L;

    @Override
    public StationPathResolvedPolicy resolvePolicy(Integer startStationId, Integer endStationId) {
        StationPathResolvedPolicy resolved = new StationPathResolvedPolicy();
        resolved.setScoreMode(getSystemConfig("stationPathScoreMode", "legacy"));
        resolved.setDefaultProfileCode(getSystemConfig("stationPathDefaultProfileCode", "default"));

        CacheSnapshot snapshot = getCacheSnapshot();
        BasStationPathRule matchedRule = matchRule(snapshot.ruleList, startStationId, endStationId);
        BasStationPathProfile matchedProfile = null;
        if (matchedRule != null && notBlank(matchedRule.getProfileCode())) {
            matchedProfile = snapshot.profileMap.get(matchedRule.getProfileCode());
        }
        if (matchedProfile == null && notBlank(resolved.getDefaultProfileCode())) {
            matchedProfile = snapshot.profileMap.get(resolved.getDefaultProfileCode());
        }
        if (matchedProfile == null) {
            matchedProfile = snapshot.profileMap.get("default");
        }
        if (matchedProfile == null && !snapshot.profileList.isEmpty()) {
            matchedProfile = snapshot.profileList.get(0);
        }

        resolved.setRuleEntity(matchedRule);
        resolved.setProfileEntity(matchedProfile);
        resolved.setProfileConfig(parseProfileConfig(matchedProfile == null ? null : matchedProfile.getConfigJson()));
        resolved.setRuleConfig(parseRuleConfig(matchedRule));
        return resolved;
    }

    @Override
    public void evictCache() {
        cacheSnapshot = new CacheSnapshot();
        cacheTime = 0L;
    }

    private CacheSnapshot getCacheSnapshot() {
        long now = System.currentTimeMillis();
        CacheSnapshot local = cacheSnapshot;
        if (local.loaded && now - cacheTime < CACHE_TTL_MILLIS) {
            return local;
        }
        synchronized (this) {
            local = cacheSnapshot;
            if (local.loaded && now - cacheTime < CACHE_TTL_MILLIS) {
                return local;
            }
            cacheSnapshot = loadSnapshot();
            cacheTime = System.currentTimeMillis();
            return cacheSnapshot;
        }
    }

    private CacheSnapshot loadSnapshot() {
        CacheSnapshot snapshot = new CacheSnapshot();
        try {
            List<BasStationPathProfile> profiles = basStationPathProfileService.list(new QueryWrapper<BasStationPathProfile>()
                    .eq("status", 1)
                    .orderByAsc("priority", "id"));
            if (profiles != null) {
                snapshot.profileList.addAll(profiles);
                for (BasStationPathProfile profile : profiles) {
                    if (profile != null && notBlank(profile.getProfileCode())) {
                        snapshot.profileMap.put(profile.getProfileCode(), profile);
                    }
                }
            }
        } catch (Exception e) {
            log.warn("加载站点路径模板失败，回退默认配置: {}", e.getMessage());
        }

        try {
            List<BasStationPathRule> rules = basStationPathRuleService.list(new QueryWrapper<BasStationPathRule>()
                    .eq("status", 1)
                    .orderByAsc("priority", "id"));
            if (rules != null) {
                snapshot.ruleList.addAll(rules);
            }
        } catch (Exception e) {
            log.warn("加载站点路径规则失败，忽略人工规则: {}", e.getMessage());
        }

        snapshot.loaded = true;
        return snapshot;
    }

    private BasStationPathRule matchRule(List<BasStationPathRule> ruleList, Integer startStationId, Integer endStationId) {
        if (ruleList == null || ruleList.isEmpty()) {
            return null;
        }

        List<BasStationPathRule> candidates = new ArrayList<>();
        for (BasStationPathRule rule : ruleList) {
            if (rule == null) {
                continue;
            }
            if (!matchNullable(rule.getStartStationId(), startStationId)) {
                continue;
            }
            if (!matchNullable(rule.getEndStationId(), endStationId)) {
                continue;
            }
            candidates.add(rule);
        }
        if (candidates.isEmpty()) {
            return null;
        }

        candidates.sort(Comparator
                .comparingInt(this::specificity).reversed()
                .thenComparingInt(rule -> safeInt(rule.getPriority(), 100))
                .thenComparingLong(rule -> rule.getId() == null ? Long.MAX_VALUE : rule.getId()));
        return candidates.get(0);
    }

    private boolean matchNullable(Integer expected, Integer actual) {
        return expected == null || expected.equals(actual);
    }

    private int specificity(BasStationPathRule rule) {
        int score = 0;
        if (rule.getStartStationId() != null) {
            score += 1;
        }
        if (rule.getEndStationId() != null) {
            score += 1;
        }
        return score;
    }

    private StationPathProfileConfig parseProfileConfig(String configJson) {
        StationPathProfileConfig config = StationPathProfileConfig.defaultConfig();
        if (!notBlank(configJson)) {
            return config;
        }
        try {
            StationPathProfileConfig parsed = JSON.parseObject(configJson, StationPathProfileConfig.class);
            config.mergeFrom(parsed);
        } catch (Exception e) {
            log.warn("解析站点路径模板配置失败，使用默认值: {}", e.getMessage());
        }
        return config;
    }

    private StationPathRuleConfig parseRuleConfig(BasStationPathRule rule) {
        StationPathRuleConfig config = new StationPathRuleConfig();
        if (rule == null) {
            return config;
        }

        try {
            if (notBlank(rule.getHardJson())) {
                StationPathRuleConfig.HardConstraint hard = JSON.parseObject(rule.getHardJson(), StationPathRuleConfig.HardConstraint.class);
                if (hard != null) {
                    config.setHard(hard);
                }
            }
        } catch (Exception e) {
            log.warn("解析硬约束配置失败, ruleCode={}", rule.getRuleCode());
        }
        try {
            if (notBlank(rule.getWaypointJson())) {
                StationPathRuleConfig.WaypointConstraint waypoint = JSON.parseObject(rule.getWaypointJson(), StationPathRuleConfig.WaypointConstraint.class);
                if (waypoint != null) {
                    config.setWaypoint(waypoint);
                }
            }
        } catch (Exception e) {
            log.warn("解析途经点配置失败, ruleCode={}", rule.getRuleCode());
        }
        try {
            if (notBlank(rule.getSoftJson())) {
                StationPathRuleConfig.SoftPreference soft = JSON.parseObject(rule.getSoftJson(), StationPathRuleConfig.SoftPreference.class);
                if (soft != null) {
                    config.setSoft(soft);
                }
            }
        } catch (Exception e) {
            log.warn("解析软偏好配置失败, ruleCode={}", rule.getRuleCode());
        }
        try {
            if (notBlank(rule.getFallbackJson())) {
                StationPathRuleConfig.FallbackPolicy fallback = JSON.parseObject(rule.getFallbackJson(), StationPathRuleConfig.FallbackPolicy.class);
                if (fallback != null) {
                    config.setFallback(fallback);
                }
            }
        } catch (Exception e) {
            log.warn("解析规则降级配置失败, ruleCode={}", rule.getRuleCode());
        }
        return config;
    }

    private String getSystemConfig(String code, String defaultValue) {
        try {
            Object mapObj = redisUtil.get(RedisKeyType.SYSTEM_CONFIG_MAP.key);
            if (mapObj instanceof Map) {
                Object value = ((Map<?, ?>) mapObj).get(code);
                if (value != null) {
                    String text = String.valueOf(value).trim();
                    if (!text.isEmpty()) {
                        return text;
                    }
                }
            }
        } catch (Exception ignore) {
        }
        return defaultValue;
    }

    private boolean notBlank(String value) {
        return value != null && !value.trim().isEmpty();
    }

    private int safeInt(Integer value, int defaultValue) {
        return value == null ? defaultValue : value;
    }

    private static class CacheSnapshot {
        private boolean loaded = false;
        private final List<BasStationPathProfile> profileList = new ArrayList<>();
        private final List<BasStationPathRule> ruleList = new ArrayList<>();
        private final Map<String, BasStationPathProfile> profileMap = new HashMap<>();
    }
}