package com.zy.ai.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.zy.ai.domain.autotune.AutoTuneFlowTopologyItem;
import com.zy.ai.domain.autotune.AutoTuneStationRuntimeItem;
import com.zy.ai.service.FlowTopologySnapshotService;
import com.zy.asrs.entity.BasDevp;
import com.zy.asrs.entity.BasStation;
import com.zy.asrs.service.BasDevpService;
import com.zy.asrs.service.BasStationService;
import com.zy.common.utils.NavigateUtils;
import com.zy.core.model.StationObjModel;
import lombok.Data;
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.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;

@Service("flowTopologySnapshotService")
public class FlowTopologySnapshotServiceImpl implements FlowTopologySnapshotService {

    private static final String DIRECTION_OUT = "OUT";

    @Autowired
    private BasDevpService basDevpService;

    @Autowired
    private BasStationService basStationService;

    @Autowired
    private NavigateUtils navigateUtils;

    @Override
    public List<AutoTuneFlowTopologyItem> buildSnapshot(List<AutoTuneStationRuntimeItem> stationRuntimeSnapshot) {
        List<BasStation> outStations = loadOutStationList();
        Map<Integer, List<Integer>> adjacencyMap = loadSortedAdjacencyMap();
        List<AutoTuneFlowTopologyItem> itemList = new ArrayList<>();
        for (BasStation station : outStations) {
            if (station == null || station.getStationId() == null) {
                continue;
            }
            itemList.add(buildTopologyItem(station, adjacencyMap, stationRuntimeSnapshot));
        }
        return itemList;
    }

    public AutoTuneFlowTopologyItem buildTopologyItem(BasStation station,
                                                     Map<Integer, List<Integer>> adjacencyMap,
                                                     List<AutoTuneStationRuntimeItem> stationRuntimeSnapshot) {
        Integer targetStationId = station.getStationId();
        Integer bufferCapacity = station.getOutBufferCapacity();
        List<Integer> adjacentStationIds = sortedList(adjacencyMap == null ? null : adjacencyMap.get(targetStationId));
        List<Integer> flowStationIds = buildFlowStationIds(targetStationId, adjacentStationIds);
        List<AutoTuneStationRuntimeItem> flowRuntimeItems = filterRuntimeByStationIds(stationRuntimeSnapshot, flowStationIds);
        RuntimeCount runtimeCount = calculateRuntimeCount(flowRuntimeItems);

        AutoTuneFlowTopologyItem item = new AutoTuneFlowTopologyItem();
        item.setTargetStationId(targetStationId);
        item.setDirection(DIRECTION_OUT);
        item.setAdjacentStationIds(adjacentStationIds);
        // 当前只存在无向站点邻接图，不能把邻接事实冒充为上下游方向事实。
        item.setUpstreamStationIds(Collections.emptyList());
        item.setDownstreamStationIds(Collections.emptyList());
        item.setFlowStationIds(flowStationIds);
        item.setBufferCapacity(bufferCapacity);
        item.setOccupiedCount(runtimeCount.getOccupiedCount());
        item.setFreeCount(resolveFreeCount(bufferCapacity, runtimeCount.getOccupiedCount()));
        item.setNonAutoingCount(runtimeCount.getNonAutoingCount());
        item.setLoadingCount(runtimeCount.getLoadingCount());
        item.setTaskHoldingCount(runtimeCount.getTaskHoldingCount());
        return item;
    }

    public RuntimeCount calculateRuntimeCount(List<AutoTuneStationRuntimeItem> runtimeItems) {
        RuntimeCount count = new RuntimeCount();
        if (runtimeItems == null || runtimeItems.isEmpty()) {
            return count;
        }
        for (AutoTuneStationRuntimeItem runtimeItem : runtimeItems) {
            if (runtimeItem == null) {
                continue;
            }
            boolean autoing = Objects.equals(runtimeItem.getAutoing(), 1);
            boolean loading = Objects.equals(runtimeItem.getLoading(), 1);
            boolean taskHolding = runtimeItem.getTaskNo() != null && runtimeItem.getTaskNo() > 0;
            if (!autoing) {
                count.nonAutoingCount++;
            }
            if (loading) {
                count.loadingCount++;
            }
            if (taskHolding) {
                count.taskHoldingCount++;
            }
            if (loading || taskHolding) {
                count.occupiedCount++;
            }
        }
        return count;
    }

    private List<BasStation> loadOutStationList() {
        if (basDevpService == null || basStationService == null) {
            return Collections.emptyList();
        }
        Set<Integer> stationIds = loadOutStationIds();
        if (stationIds.isEmpty()) {
            return Collections.emptyList();
        }
        QueryWrapper<BasStation> wrapper = new QueryWrapper<>();
        wrapper.in("station_id", stationIds);
        wrapper.orderByAsc("station_id");
        List<BasStation> stationList = basStationService.list(wrapper);
        return stationList == null ? Collections.emptyList() : stationList;
    }

    private Set<Integer> loadOutStationIds() {
        LinkedHashSet<Integer> stationIds = new LinkedHashSet<>();
        if (basDevpService == null) {
            return stationIds;
        }
        QueryWrapper<BasDevp> wrapper = new QueryWrapper<>();
        wrapper.eq("status", 1);
        wrapper.orderByAsc("devp_no");
        List<BasDevp> basDevpList = basDevpService.list(wrapper);
        for (BasDevp basDevp : safeList(basDevpList)) {
            List<StationObjModel> outStationList = safeList(basDevp == null ? null : basDevp.getOutStationList$());
            for (StationObjModel stationObjModel : outStationList) {
                if (stationObjModel != null && stationObjModel.getStationId() != null) {
                    stationIds.add(stationObjModel.getStationId());
                }
            }
        }
        return stationIds;
    }

    private Map<Integer, List<Integer>> loadSortedAdjacencyMap() {
        if (navigateUtils == null) {
            return Collections.emptyMap();
        }
        Map<Integer, Set<Integer>> graph = navigateUtils.loadUndirectedStationGraphSnapshot();
        if (graph == null || graph.isEmpty()) {
            return Collections.emptyMap();
        }
        return graph.entrySet().stream()
                .filter(entry -> entry.getKey() != null)
                .collect(Collectors.toMap(
                        Map.Entry::getKey,
                        entry -> sortedList(entry.getValue())
                ));
    }

    private List<Integer> buildFlowStationIds(Integer targetStationId,
                                             List<Integer> adjacentStationIds) {
        LinkedHashSet<Integer> stationIds = new LinkedHashSet<>();
        if (targetStationId != null) {
            stationIds.add(targetStationId);
        }
        stationIds.addAll(sortedList(adjacentStationIds));
        return new ArrayList<>(stationIds);
    }

    private List<AutoTuneStationRuntimeItem> filterRuntimeByStationIds(List<AutoTuneStationRuntimeItem> runtimeItems,
                                                                       List<Integer> stationIds) {
        if (runtimeItems == null || runtimeItems.isEmpty() || stationIds == null || stationIds.isEmpty()) {
            return Collections.emptyList();
        }
        Set<Integer> stationIdSet = new LinkedHashSet<>(stationIds);
        return runtimeItems.stream()
                .filter(item -> item != null && stationIdSet.contains(item.getStationId()))
                .collect(Collectors.toList());
    }

    private static List<Integer> sortedList(Iterable<Integer> values) {
        if (values == null) {
            return new ArrayList<>();
        }
        List<Integer> result = new ArrayList<>();
        for (Integer value : values) {
            if (value != null) {
                result.add(value);
            }
        }
        result.sort(Comparator.naturalOrder());
        return result;
    }

    private Integer resolveFreeCount(Integer bufferCapacity, int occupiedCount) {
        if (bufferCapacity == null) {
            return null;
        }
        return Math.max(0, Math.max(0, bufferCapacity) - occupiedCount);
    }

    private <T> List<T> safeList(List<T> value) {
        return value == null ? Collections.emptyList() : value;
    }

    @Data
    public static class RuntimeCount {
        private int occupiedCount;
        private int nonAutoingCount;
        private int loadingCount;
        private int taskHoldingCount;
    }
}