package com.zy.asrs.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.core.annotations.ManagerAuth;
import com.core.common.R;
import com.zy.asrs.domain.path.StationPathResolvedPolicy;
import com.zy.asrs.entity.BasMap;
import com.zy.asrs.entity.BasStation;
import com.zy.asrs.entity.BasStationPathProfile;
import com.zy.asrs.entity.BasStationPathRule;
import com.zy.asrs.service.BasMapService;
import com.zy.asrs.service.BasStationService;
import com.zy.asrs.service.BasStationPathProfileService;
import com.zy.asrs.service.BasStationPathRuleService;
import com.zy.asrs.service.StationPathPolicyService;
import com.zy.common.model.NavigateNode;
import com.zy.common.utils.NavigateUtils;
import com.zy.common.utils.RedisUtil;
import com.zy.common.web.BaseController;
import com.zy.core.enums.RedisKeyType;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

@RestController
@RequestMapping("/basStationPathPolicy")
public class BasStationPathPolicyController extends BaseController {

    @Autowired
    private BasStationPathProfileService basStationPathProfileService;
    @Autowired
    private BasStationPathRuleService basStationPathRuleService;
    @Autowired
    private ConfigService configService;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private StationPathPolicyService stationPathPolicyService;
    @Autowired
    private BasStationService basStationService;
    @Autowired
    private BasMapService basMapService;
    @Autowired
    private NavigateUtils navigateUtils;

    @RequestMapping("/data/auth")
    @ManagerAuth
    public R data() {
        Map<String, Object> data = new HashMap<>();
        data.put("profiles", basStationPathProfileService.list(new QueryWrapper<BasStationPathProfile>().orderByAsc("priority", "id")));
        data.put("rules", basStationPathRuleService.list(new QueryWrapper<BasStationPathRule>().orderByAsc("priority", "id")));
        data.put("scoreMode", getSystemConfig("stationPathScoreMode", "legacy"));
        data.put("defaultProfileCode", getSystemConfig("stationPathDefaultProfileCode", "default"));
        data.put("stations", buildStationSummaryList());
        data.put("levList", basMapService.getLevList());
        return R.ok(data);
    }

    @RequestMapping("/save/auth")
    @ManagerAuth
    public R save(@RequestBody JSONObject payload) {
        JSONArray profiles = payload.getJSONArray("profiles");
        JSONArray rules = payload.getJSONArray("rules");

        upsertSystemConfig("站点路径评分模式", "stationPathScoreMode", defaultIfBlank(payload.getString("scoreMode"), "legacy"), "String");
        upsertSystemConfig("站点路径默认模板编码", "stationPathDefaultProfileCode", defaultIfBlank(payload.getString("defaultProfileCode"), "default"), "String");

        basStationPathProfileService.remove(new QueryWrapper<>());
        basStationPathRuleService.remove(new QueryWrapper<>());

        List<BasStationPathProfile> profileList = new ArrayList<>();
        if (profiles != null) {
            for (int i = 0; i < profiles.size(); i++) {
                JSONObject item = profiles.getJSONObject(i);
                if (item == null) {
                    continue;
                }
                if (isBlank(item.getString("profileCode"))) {
                    continue;
                }
                BasStationPathProfile profile = new BasStationPathProfile();
                profile.setProfileCode(item.getString("profileCode"));
                profile.setProfileName(defaultIfBlank(item.getString("profileName"), item.getString("profileCode")));
                profile.setPriority(item.getInteger("priority") == null ? 100 : item.getInteger("priority"));
                profile.setStatus(item.getShort("status") == null ? (short) 1 : item.getShort("status"));
                profile.setMemo(item.getString("memo"));
                Object configObj = item.get("config");
                if (configObj != null) {
                    profile.setConfigJson(JSON.toJSONString(configObj));
                } else {
                    profile.setConfigJson(item.getString("configJson"));
                }
                profileList.add(profile);
            }
        }
        if (!profileList.isEmpty()) {
            basStationPathProfileService.saveBatch(profileList);
        }

        List<BasStationPathRule> ruleList = new ArrayList<>();
        if (rules != null) {
            for (int i = 0; i < rules.size(); i++) {
                JSONObject item = rules.getJSONObject(i);
                if (item == null) {
                    continue;
                }
                if (isBlank(item.getString("ruleCode"))) {
                    continue;
                }
                BasStationPathRule rule = new BasStationPathRule();
                rule.setRuleCode(item.getString("ruleCode"));
                rule.setRuleName(defaultIfBlank(item.getString("ruleName"), item.getString("ruleCode")));
                rule.setPriority(item.getInteger("priority") == null ? 100 : item.getInteger("priority"));
                rule.setStatus(item.getShort("status") == null ? (short) 1 : item.getShort("status"));
                rule.setSceneType(item.getString("sceneType"));
                rule.setStartStationId(item.getInteger("startStationId"));
                rule.setEndStationId(item.getInteger("endStationId"));
                rule.setProfileCode(item.getString("profileCode"));
                rule.setMemo(item.getString("memo"));
                rule.setHardJson(toJson(item.get("hard"), item.getString("hardJson")));
                rule.setWaypointJson(toJson(item.get("waypoint"), item.getString("waypointJson")));
                rule.setSoftJson(toJson(item.get("soft"), item.getString("softJson")));
                rule.setFallbackJson(toJson(item.get("fallback"), item.getString("fallbackJson")));
                ruleList.add(rule);
            }
        }
        if (!ruleList.isEmpty()) {
            basStationPathRuleService.saveBatch(ruleList);
        }

        refreshSystemConfigCache();
        stationPathPolicyService.evictCache();
        return R.ok();
    }

    @RequestMapping("/resolve/auth")
    @ManagerAuth
    public R resolve(@RequestParam Integer startStationId, @RequestParam Integer endStationId) {
        StationPathResolvedPolicy resolved = stationPathPolicyService.resolvePolicy(startStationId, endStationId);
        return R.ok(resolved);
    }

    @RequestMapping("/preview/auth")
    @ManagerAuth
    public R preview(@RequestParam Integer startStationId,
                     @RequestParam Integer endStationId,
                     @RequestParam(required = false, defaultValue = "false") Boolean includeMapData) {
        StationPathResolvedPolicy resolved = stationPathPolicyService.resolvePolicy(startStationId, endStationId);
        List<NavigateNode> nodes = navigateUtils.calcByStationId(startStationId, endStationId);
        List<Integer> stationIdList = new ArrayList<>();
        List<Map<String, Object>> nodeList = new ArrayList<>();
        Set<Integer> seen = new HashSet<>();
        for (NavigateNode node : nodes) {
            JSONObject value = parseNodeValue(node == null ? null : node.getNodeValue());
            Integer stationId = value == null ? null : value.getInteger("stationId");
            if (stationId != null && seen.add(stationId)) {
                stationIdList.add(stationId);
            }
            Map<String, Object> item = new HashMap<>();
            item.put("stationId", stationId);
            item.put("x", node == null ? null : node.getX());
            item.put("y", node == null ? null : node.getY());
            item.put("direction", node == null ? null : node.getDirection());
            item.put("isInflectionPoint", node != null && Boolean.TRUE.equals(node.getIsInflectionPoint()));
            item.put("isLiftTransferPoint", node != null && Boolean.TRUE.equals(node.getIsLiftTransferPoint()));
            nodeList.add(item);
        }

        BasStation startStation = basStationService.getById(startStationId);
        Integer lev = startStation == null ? null : startStation.getStationLev();
        BasMap basMap = Boolean.TRUE.equals(includeMapData) && lev != null
                ? basMapService.getOne(new QueryWrapper<BasMap>().eq("lev", lev))
                : null;

        Map<String, Object> result = new HashMap<>();
        result.put("resolvedPolicy", resolved);
        result.put("pathStationIds", stationIdList);
        result.put("pathNodes", nodeList);
        result.put("pathLength", stationIdList.size());
        result.put("turnCount", countTurnCount(nodeList));
        result.put("liftTransferCount", countLiftTransferCount(nodeList));
        result.put("lev", lev);
        result.put("mapData", basMap == null ? null : basMap.getData());
        result.put("previewTime", new Date());
        return R.ok(result);
    }

    @RequestMapping("/expandSoftPath/auth")
    @ManagerAuth
    public R expandSoftPath(@RequestBody JSONObject payload) {
        Integer startStationId = payload.getInteger("startStationId");
        Integer endStationId = payload.getInteger("endStationId");
        if (startStationId == null || endStationId == null) {
            return R.error("起点和终点不能为空");
        }

        List<Integer> routePoints = new ArrayList<>();
        routePoints.add(startStationId);
        routePoints.addAll(parseStationIdArray(payload.getJSONArray("keyStations")));
        routePoints.add(endStationId);

        List<Integer> fullPathStationIds = new ArrayList<>();
        for (int i = 0; i < routePoints.size() - 1; i++) {
            Integer segmentStart = routePoints.get(i);
            Integer segmentEnd = routePoints.get(i + 1);
            if (segmentStart == null || segmentEnd == null) {
                continue;
            }
            if (segmentStart.equals(segmentEnd)) {
                if (fullPathStationIds.isEmpty()) {
                    fullPathStationIds.add(segmentStart);
                }
                continue;
            }
            List<NavigateNode> segmentNodes = navigateUtils.calcByStationId(segmentStart, segmentEnd);
            List<Integer> segmentStationIds = extractStationIds(segmentNodes);
            if (segmentStationIds.isEmpty()) {
                return R.error("未找到 " + segmentStart + " 到 " + segmentEnd + " 的可行路径");
            }
            appendSegmentPath(fullPathStationIds, segmentStationIds);
        }

        Map<String, Object> result = new HashMap<>();
        result.put("startStationId", startStationId);
        result.put("endStationId", endStationId);
        result.put("keyStations", routePoints.size() <= 2 ? new ArrayList<>() : routePoints.subList(1, routePoints.size() - 1));
        result.put("pathStationIds", fullPathStationIds);
        result.put("pathLength", fullPathStationIds.size());
        result.put("segmentCount", Math.max(routePoints.size() - 1, 0));
        result.put("previewTime", new Date());
        return R.ok(result);
    }

    private List<Map<String, Object>> buildStationSummaryList() {
        List<Map<String, Object>> result = new ArrayList<>();
        List<BasStation> stationList = basStationService.list(new QueryWrapper<BasStation>()
                .eq("status", 1)
                .orderByAsc("station_lev", "station_id"));
        for (BasStation station : stationList) {
            if (station == null || station.getStationId() == null) {
                continue;
            }
            Map<String, Object> item = new HashMap<>();
            item.put("stationId", station.getStationId());
            item.put("stationLev", station.getStationLev());
            item.put("stationAlias", station.getStationAlias());
            result.add(item);
        }
        return result;
    }

    private void upsertSystemConfig(String name, String code, String value, String selectType) {
        String finalValue = value == null ? "" : value.trim();
        Config config = configService.getOne(new QueryWrapper<Config>().eq("code", code));
        if (config == null) {
            config = new Config(name, code, finalValue, (short) 1, (short) 1);
            config.setSelectType(selectType);
            configService.save(config);
        } else {
            config.setName(name);
            config.setValue(finalValue);
            config.setType((short) 1);
            config.setStatus((short) 1);
            config.setSelectType(selectType);
            configService.updateById(config);
        }
    }

    private void refreshSystemConfigCache() {
        HashMap<String, String> systemConfigMap = new HashMap<>();
        List<Config> configList = configService.list(new QueryWrapper<>());
        for (Config config : configList) {
            systemConfigMap.put(config.getCode(), config.getValue());
        }
        redisUtil.set(RedisKeyType.SYSTEM_CONFIG_MAP.key, systemConfigMap);
    }

    private String getSystemConfig(String code, String defaultValue) {
        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;
                }
            }
        }
        return defaultValue;
    }

    private List<Integer> parseStationIdArray(JSONArray array) {
        List<Integer> result = new ArrayList<>();
        if (array == null || array.isEmpty()) {
            return result;
        }
        Set<Integer> seen = new HashSet<>();
        for (int i = 0; i < array.size(); i++) {
            Integer stationId = toInteger(array.get(i));
            if (stationId != null && seen.add(stationId)) {
                result.add(stationId);
            }
        }
        return result;
    }

    private List<Integer> extractStationIds(List<NavigateNode> nodes) {
        List<Integer> stationIdList = new ArrayList<>();
        Set<Integer> seen = new HashSet<>();
        for (NavigateNode node : nodes) {
            JSONObject value = parseNodeValue(node == null ? null : node.getNodeValue());
            Integer stationId = value == null ? null : value.getInteger("stationId");
            if (stationId != null && seen.add(stationId)) {
                stationIdList.add(stationId);
            }
        }
        return stationIdList;
    }

    private void appendSegmentPath(List<Integer> fullPathStationIds, List<Integer> segmentStationIds) {
        if (segmentStationIds == null || segmentStationIds.isEmpty()) {
            return;
        }
        for (Integer stationId : segmentStationIds) {
            if (stationId == null) {
                continue;
            }
            if (fullPathStationIds.isEmpty() || !stationId.equals(fullPathStationIds.get(fullPathStationIds.size() - 1))) {
                fullPathStationIds.add(stationId);
            }
        }
    }

    private String toJson(Object obj, String fallbackText) {
        if (obj != null) {
            return JSON.toJSONString(obj);
        }
        return fallbackText;
    }

    private JSONObject parseNodeValue(String text) {
        if (isBlank(text)) {
            return null;
        }
        try {
            return JSON.parseObject(text);
        } catch (Exception ignore) {
            return null;
        }
    }

    private int countTurnCount(List<Map<String, Object>> nodeList) {
        if (nodeList == null || nodeList.size() < 3) {
            return 0;
        }
        int count = 0;
        for (int i = 1; i < nodeList.size() - 1; i++) {
            Map<String, Object> prev = nodeList.get(i - 1);
            Map<String, Object> next = nodeList.get(i + 1);
            Integer prevX = toInteger(prev.get("x"));
            Integer prevY = toInteger(prev.get("y"));
            Integer nextX = toInteger(next.get("x"));
            Integer nextY = toInteger(next.get("y"));
            if (prevX == null || prevY == null || nextX == null || nextY == null) {
                continue;
            }
            if (!prevX.equals(nextX) && !prevY.equals(nextY)) {
                count++;
            }
        }
        return count;
    }

    private int countLiftTransferCount(List<Map<String, Object>> nodeList) {
        int count = 0;
        for (Map<String, Object> item : nodeList) {
            if (Boolean.TRUE.equals(item.get("isLiftTransferPoint"))) {
                count++;
            }
        }
        return count;
    }

    private Integer toInteger(Object value) {
        if (value == null) {
            return null;
        }
        if (value instanceof Integer) {
            return (Integer) value;
        }
        try {
            return Integer.parseInt(String.valueOf(value));
        } catch (Exception ignore) {
            return null;
        }
    }

    private String defaultIfBlank(String text, String defaultValue) {
        return isBlank(text) ? defaultValue : text.trim();
    }

    private boolean isBlank(String text) {
        return text == null || text.trim().isEmpty();
    }
}