package com.zy.acs.manager.core.service;

import com.alibaba.fastjson.JSON;
import com.zy.acs.common.enums.AgvDirectionType;
import com.zy.acs.framework.common.Cools;
import com.zy.acs.manager.core.constant.MapDataConstant;
import com.zy.acs.manager.core.domain.DirectionDto;
import com.zy.acs.manager.core.domain.SortCodeDto;
import com.zy.acs.manager.core.domain.UnlockPathTask;
import com.zy.acs.manager.core.domain.type.CodeDirectionType;
import com.zy.acs.manager.core.service.astart.*;
import com.zy.acs.manager.core.service.astart.domain.AStarNavigateNode;
import com.zy.acs.manager.core.service.astart.domain.DynamicNode;
import com.zy.acs.manager.core.service.floyd.FloydNavigateService;
import com.zy.acs.manager.manager.entity.Code;
import com.zy.acs.manager.manager.entity.Loc;
import com.zy.acs.manager.manager.entity.Segment;
import com.zy.acs.manager.manager.entity.Sta;
import com.zy.acs.manager.manager.enums.CodeSpinType;
import com.zy.acs.manager.manager.service.ActionService;
import com.zy.acs.manager.manager.service.CodeService;
import com.zy.acs.manager.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * Created by vincent on 2023/6/14
 */
@Slf4j
@Component("mapService")
public class MapService {

    private static final double EPS = 1e-7;
    private final static int[][] DIRECTIONS = {{0,1},{0,-1},{-1,0},{1,0}};

    @Value("${floyd.enable}")
    private Boolean floydEnable;
    @Autowired
    private CodeService codeService;
    @Autowired
    private FloydNavigateService floydNavigateService;
    @Autowired
    private MapDataDispatcher mapDataDispatcher;
    @Autowired
    private AStarNavigateService aStarNavigateService;
    @Autowired
    private ConfigService configService;
    @Autowired
    private ActionService actionService;
    @Autowired
    private LinkedBlockingQueue<UnlockPathTask> unlockTaskQueue;

    /**
     * 寻址 ===>> A Star
     */
    public synchronized List<String> checkoutPath(String agvNo, Code startCode, Code endCode
            , Boolean lock, List<String> blackList, Segment segment) {

        int[] startMapIdx = mapDataDispatcher.getCodeMatrixIdx(null, startCode.getData());
        int[] endMapIdx = mapDataDispatcher.getCodeMatrixIdx(null, endCode.getData());

        AStarNavigateNode startNode = new AStarNavigateNode(startMapIdx[0], startMapIdx[1], startCode.getData());
        AStarNavigateNode endNode = new AStarNavigateNode(endMapIdx[0], endMapIdx[1], endCode.getData());

//        long startTime = System.currentTimeMillis();
        AStarNavigateNode finishNode = aStarNavigateService.execute(agvNo, startNode, endNode, lock, blackList, segment);
//        System.out.println("A Star Spend time :" + (System.currentTimeMillis() - startTime));
        if (null == finishNode) {
            return new ArrayList<>();
        }

        ArrayList<AStarNavigateNode> navigateNodes = new ArrayList<>();

        while (finishNode != null) {
            navigateNodes.add(finishNode);
            finishNode = finishNode.getParent();
        }

        Collections.reverse(navigateNodes);

        List<String> navigatePath = navigateNodes.stream().map(AStarNavigateNode::getCodeData).collect(Collectors.toList());

        // max count of steps
        if (navigatePath.size() > MapDataConstant.MAX_STEPS_SINGLE) {
            navigatePath = navigatePath.subList(0, MapDataConstant.MAX_STEPS_SINGLE);
        }

        return navigatePath;
    }

    /**
     * 寻址 ===>> Floyd
     */
    public synchronized List<String> validFeasibility(Code startCode, Code endCode) {
        if (!floydEnable) {
            return Arrays.asList("00000001", "00000002", "00000003", "00000004", "00000005", "00000006");
        }

        int startIdx = floydNavigateService.codeIdx(startCode.getId());
        int endIdx = floydNavigateService.codeIdx(endCode.getId());

        Double distance;
        try {
            distance = floydNavigateService.getFloydMatrix()[startIdx][endIdx];
        } catch (ArrayIndexOutOfBoundsException e) {
            floydNavigateService.generateMatrix();
            startIdx = floydNavigateService.codeIdx(startCode.getId());
            endIdx = floydNavigateService.codeIdx(endCode.getId());
            distance = floydNavigateService.getFloydMatrix()[startIdx][endIdx];
        }

        if (distance.equals(FloydNavigateService.INF)) {
            return null;
        }

        return floydNavigateService.calculatePath(startIdx, endIdx).stream().map(path -> {
            Long codeId = floydNavigateService.getCodeId(path);
            Code code = codeService.getCacheById(codeId);
            return code.getData();
        }).collect(Collectors.toList());
    }

    public static Double mapToNearest(Double angle) {
        if (null == angle) {
            return null;
        }
        angle = (angle + 360) % 360;
        double remainder = angle % 45;
        if (remainder < 22.5) {
            return angle - remainder;
        } else {
            return angle + (45 - remainder);
        }
    }

    // 角度计算
    public Double calculateDirection(Code startCode, Code endCode, int angleOffsetVal) {
        Double x0 = startCode.getX();
        Double y0 = startCode.getY();

        Double x1 = endCode.getX();
        Double y1 = endCode.getY();

        double deltaX = x1 - x0;
        double deltaY = y1 - y0;
        double angle = Math.atan2(deltaX, deltaY);
        angle = Math.toDegrees(angle) + angleOffsetVal;
        angle = (angle + 360) % 360; // 将角度转换为正值

        return angle;
    }

    // 坐标货架阈值 todo:luxiaotao
    public AgvDirectionType calculateAgvWorkDirectionByShelf(Loc loc, Code code) {
        Integer compDirect = loc.getCompDirect();
        AgvDirectionType agvDirectionType = null;
        if (compDirect == 0) {
            agvDirectionType = AgvDirectionType.RIGHT;
        }
        if (compDirect == 1) {
            agvDirectionType = AgvDirectionType.LEFT;
        }
        return agvDirectionType;
    }

    public Double getStaAngle(Sta sta, Double workDirection) {
        if (null == sta) {
            return null;
        }
        if (Cools.isEmpty(sta.getAngle())) {
            return workDirection;
        }
        return Double.parseDouble(sta.getAngle());
    }

    public Double calculateAgvWorkDirectionByStation(Double staWorkDirection, Double lastDirection) {
        return Math.abs(staWorkDirection - lastDirection) + 90.0D;
    }

    public double calculateDistance(double x1, double y1, double x2, double y2) {
        double deltaX = x2 - x1;
        double deltaY = y2 - y1;
        return Math.sqrt(deltaX * deltaX + deltaY * deltaY);
    }

    public void lockPath(Integer lev, List<String> pathList, String agvNo) {
        List<int[]> codeMatrixIdxList = mapDataDispatcher.getCodeMatrixIdxList(lev, pathList);
        mapDataDispatcher.modifyDynamicMatrix(lev, codeMatrixIdxList, agvNo);
    }

    public void unlockPath(String agvNo, String codeData) {
        if (Cools.isEmpty(agvNo, codeData)) {
            return;
        }
        try {
            unlockTaskQueue.offer(new UnlockPathTask(agvNo, codeData), 5, TimeUnit.SECONDS);

//            Integer lev = null;
//
//            String[][] codeMatrix = mapDataDispatcher.getCodeMatrix(null);
//            int[] codeMatrixIdx = mapDataDispatcher.getCodeMatrixIdx(lev, codeData);
//
//
//            DynamicNode[][] dynamicMatrix = mapDataDispatcher.getDynamicMatrix(lev);
//
//            DynamicNode dynamicNode = dynamicMatrix[codeMatrixIdx[0]][codeMatrixIdx[1]];
//
//
//            int serial = dynamicNode.getSerial();
//
//            List<int[]> resetCodeIdxList = new ArrayList<>();
//
//            for (int i = 0; i < dynamicMatrix.length; i++) {
//                for (int j = 0; j < dynamicMatrix[i].length; j++) {
//
////                    if (i == codeMatrixIdx[0] && j == codeMatrixIdx[1]) { continue; }
//
//                    DynamicNode node = dynamicMatrix[i][j];
//                    if (node.getVehicle().equals(agvNo)) {
//                        if (node.getSerial() < serial) {
//                            resetCodeIdxList.add(new int[] {i, j});
//                        }
//                    }
//                }
//            }
//
//            if (!Cools.isEmpty(resetCodeIdxList)) {
//
//                mapDataDispatcher.clearDynamicMatrixByCodeList(lev, resetCodeIdxList);
//            }

        } catch (InterruptedException e) {
            log.error("unlockTaskQueue", e);
        }
    }

    public List<String> getWaveScopeByCodeList(Integer lev, List<String> codeList, Double radiusLen) {
        if (Cools.isEmpty(codeList)) {
            return new ArrayList<>();
        }
        if (Cools.isEmpty(radiusLen) || radiusLen == 0D) {
            return codeList;
        }
        radiusLen = Math.abs(radiusLen);

        List<NavigateNode> nodeList = new ArrayList<>();
        for (String code : codeList) {

            nodeList.addAll(this.getWaveScopeByCode(lev, code, radiusLen));
        }

        return nodeList.stream().map(NavigateNode::getCodeData).distinct().collect(Collectors.toList());
    }

    // v1 BFS ------------------------------------------------------------------------------
    public List<NavigateNode> getWaveScopeByCode(Integer lev, String code, Double radiusLen) {
        double radiusLenSquared = Math.pow(radiusLen, 2);

        String[][] codeMatrix = mapDataDispatcher.getCodeMatrix(lev);
        Double[][][] cdaMatrix = mapDataDispatcher.getCdaMatrix(lev);

        int[] codeMatrixIdx = mapDataDispatcher.getCodeMatrixIdx(lev, code);
        NavigateNode originNode = new NavigateNode(codeMatrixIdx[0], codeMatrixIdx[1], code);

        List<NavigateNode> includeList = new ArrayList<>();
        Set<NavigateNode> existNodes = new HashSet<>();

        includeList.add(originNode);
        existNodes.add(originNode);

        this.spreadWaveNode(originNode, originNode, codeMatrix, cdaMatrix, radiusLenSquared, includeList, existNodes);

        return includeList;
    }

    public void spreadWaveNode(NavigateNode originNode, NavigateNode currNode
            , String[][] codeMatrix, Double[][][] cdaMatrix, Double radiusLenSquared
            , List<NavigateNode> includeList, Set<NavigateNode> existNodes) {
        int x = currNode.getX();
        int y = currNode.getY();

        this.extendNeighborNodes(originNode, new NavigateNode(x, y + 1), codeMatrix, cdaMatrix, radiusLenSquared, includeList, existNodes);
        this.extendNeighborNodes(originNode, new NavigateNode(x, y - 1), codeMatrix, cdaMatrix, radiusLenSquared, includeList, existNodes);
        this.extendNeighborNodes(originNode, new NavigateNode(x - 1, y), codeMatrix, cdaMatrix, radiusLenSquared, includeList, existNodes);
        this.extendNeighborNodes(originNode, new NavigateNode(x + 1, y), codeMatrix, cdaMatrix, radiusLenSquared, includeList, existNodes);
    }

    public void extendNeighborNodes(NavigateNode originNode, NavigateNode nextNode
            , String[][] codeMatrix, Double[][][] cdaMatrix, Double radiusLenSquared
            , List<NavigateNode> includeList, Set<NavigateNode> existNodes) {

        int x = nextNode.getX();
        int y = nextNode.getY();

        if (x < 0 || x >= codeMatrix.length
                || y < 0 || y >= codeMatrix[0].length) {
            return;
        }

        if (existNodes.contains(nextNode)) {
            return;
        }

        existNodes.add(nextNode);

        Double[] o1Cda = cdaMatrix[originNode.getX()][originNode.getY()];
        Double[] o2Cda = cdaMatrix[x][y];
        if (Math.pow(o1Cda[0] - o2Cda[0], 2) + Math.pow(o1Cda[1] - o2Cda[1], 2) <= radiusLenSquared) {
            nextNode.setCodeData(codeMatrix[x][y]);

            if (!nextNode.getCodeData().equals(CodeNodeType.NONE.val)) {
                includeList.add(nextNode);
            }

            this.spreadWaveNode(originNode, nextNode, codeMatrix, cdaMatrix, radiusLenSquared, includeList, existNodes);
        }

    }

    // v2 BFS ------------------------------------------------------------------------------
//    public List<NavigateNode> getWaveScopeByCode0(Integer lev, String code, Double radiusLen) {
//        String[][] codeMatrix = mapDataDispatcher.getCodeMatrix(lev);
//
//        int[] codeMatrixIdx = mapDataDispatcher.getCodeMatrixIdx(lev, code);
//        NavigateNode originNode = new NavigateNode(codeMatrixIdx[0], codeMatrixIdx[1], code);
//
//        List<NavigateNode> includeList = new ArrayList<>();
//        Set<NavigateNode> visited = new HashSet<>(); // Track visited nodes to avoid re-processing
//        Queue<NavigateNode> queue = new LinkedList<>();
//
//        includeList.add(originNode);
//        visited.add(originNode);
//        queue.offer(originNode);
//
//        while (!queue.isEmpty()) {
//            NavigateNode currNode = queue.poll();
//            this.spreadWaveNode0(originNode, currNode, codeMatrix, radiusLen, includeList, visited, queue);
//        }
//
//        return includeList;
//    }
//
//    public void spreadWaveNode0(NavigateNode originNode, NavigateNode currNode,
//                               String[][] codeMatrix, Double radiusLen,
//                               List<NavigateNode> includeList, Set<NavigateNode> visited, Queue<NavigateNode> queue) {
//
//        int x = currNode.getX();
//        int y = currNode.getY();
//
//        // Expand neighbors in all four directions (up, down, left, right)
//        this.extendNeighborNodes0(originNode, new NavigateNode(x, y + 1), codeMatrix, radiusLen, includeList, visited, queue);
//        this.extendNeighborNodes0(originNode, new NavigateNode(x, y - 1), codeMatrix, radiusLen, includeList, visited, queue);
//        this.extendNeighborNodes0(originNode, new NavigateNode(x - 1, y), codeMatrix, radiusLen, includeList, visited, queue);
//        this.extendNeighborNodes0(originNode, new NavigateNode(x + 1, y), codeMatrix, radiusLen, includeList, visited, queue);
//    }
//
//    public void extendNeighborNodes0(NavigateNode originNode, NavigateNode nextNode,
//                                    String[][] codeMatrix, Double radiusLen,
//                                    List<NavigateNode> includeList, Set<NavigateNode> visited, Queue<NavigateNode> queue) {
//        int x = nextNode.getX();
//        int y = nextNode.getY();
//
//        // Check if the node is out of bounds
//        if (x < 0 || x >= codeMatrix.length || y < 0 || y >= codeMatrix[0].length) {
//            return;
//        }
//
//        // If the node has already been visited, skip it
//        if (visited.contains(nextNode)) {
//            return;
//        }
//
//        visited.add(nextNode);
//
//        String nextNodeCodeData = codeMatrix[x][y];
//
//        // If it's a NONE node, we still need to check its surroundings
//        if (nextNodeCodeData.equals(CodeNodeType.NONE.val)) {
//            this.spreadWaveNode0(originNode, nextNode, codeMatrix, radiusLen, includeList, visited, queue);
//        } else {
//            Integer lev = MapDataDispatcher.MAP_DEFAULT_LEV;
//            String[][] cdaMatrix = mapDataDispatcher.getCdaMatrix(lev);
//
//            // Check if the distance between nodes is within the radius length
//            List<Double> o1Cda = MapDataUtils.parseCdaNode(cdaMatrix[originNode.getX()][originNode.getY()]);
//            List<Double> o2Cda = MapDataUtils.parseCdaNode(cdaMatrix[nextNode.getX()][nextNode.getY()]);
//
//            // Calculate Euclidean distance between the nodes
//            if (Math.pow(o1Cda.get(0) - o2Cda.get(0), 2) + Math.pow(o1Cda.get(1) - o2Cda.get(1), 2) <= Math.pow(radiusLen, 2)) {
//                nextNode.setCodeData(nextNodeCodeData);
//                includeList.add(nextNode);
//
//                // Add the node to the queue to expand its neighbors
//                queue.offer(nextNode);
//            }
//        }
//    }


    public Boolean isTurnCorner(String codeData) {
        if (Cools.isEmpty(codeData)) {
            return false;
        }

        int[][] turnMatrix = mapDataDispatcher.getTurnMatrix(null);

        int[] codeMatrixIdx = mapDataDispatcher.getCodeMatrixIdx(null, codeData);
        int turnMatrixNode = turnMatrix[codeMatrixIdx[0]][codeMatrixIdx[1]];

        return turnMatrixNode == TurnNodeType.TURN.val;
    }

    public CodeSpinType spinDirection(Code code) {
        if (Cools.isEmpty(code)) {
            return CodeSpinType.NA;
        }
        return CodeSpinType.of(code.getSpin());
    }

    public static void main(String[] args) {
        List<DirectionDto> directionDtoList = DirectionDto.initCodeDirections();
        System.out.println(JSON.toJSONString(directionDtoList));
    }

    public CodeSpinType calcSpinDirection(Code code, Double currDir, Double nextDir) {
        if (Cools.isEmpty(code, currDir, nextDir)) {
            return CodeSpinType.NA;
        }
        List<Double> disableAngleList = new ArrayList<>();
        List<DirectionDto> directionDtoList = DirectionDto.initCodeDirections();
        for (DirectionDto dto : directionDtoList) {
            if (null != dto.getEnabled() && !dto.getEnabled()) {
                disableAngleList.add(dto.getAngle());
            }
        }

        if (Cools.isEmpty(disableAngleList)) {
            return CodeSpinType.NA;
        }

        double curr = norm360(currDir);
        double next = norm360(nextDir);

        // 如果几乎相等，认为不需要旋转
        if (almostEqual(curr, next)) {
            return CodeSpinType.NA;
        }

        double cwDelta = cwDelta(curr, next);     // (0, 360)
        double ccwDelta = 360.0 - cwDelta;  // (0, 360)

        boolean cwBlocked = false;
        boolean ccwBlocked = false;

        for (Double disableAngle : disableAngleList) {
            if (disableAngle == null) continue;
            double disable = norm360(disableAngle);

            if (isOnArcCW(curr, next, disable)) {
                cwBlocked = true;
            }
            if (isOnArcCCW(curr, next, disable)) {
                ccwBlocked = true;
            }
        }

        if (cwBlocked && !ccwBlocked) {
            return CodeSpinType.CCW;
        }
        if (!cwBlocked && ccwBlocked) {
            return CodeSpinType.CW;
        }

        return CodeSpinType.NA;
    }

    private static double norm360(double a) {
        double x = a % 360.0;
        if (x < 0) x += 360.0;
        // 360 归一化为 0
        if (almostEqual(x, 360.0)) return 0.0;
        return x;
    }

    private static boolean almostEqual(double a, double b) {
        return Math.abs(a - b) <= EPS;
    }

    /**
     * 顺时针距离：从 start 到 end，沿 CW 方向走多少度，范围 (0, 360]，这里不会返回 0（除非你 curr==next 已提前处理）
     */
    private static double cwDelta(double start, double end) {
        double d = end - start;
        if (d < 0) d += 360.0;
        if (almostEqual(d, 0.0)) return 0.0;
        return d;
    }

    /**
     * 判断 angle 是否落在从 start -> end 的顺时针弧段上（不含端点）。
     * 即：沿 CW 从 start 走 cwDelta(start,end) 的路径上是否“经过”angle。
     */
    private static boolean isOnArcCW(double start, double end, double angle) {
        double total = cwDelta(start, end);
        // 弧长为 0 表示无旋转（已提前处理），这里直接 false
        if (almostEqual(total, 0.0)) return false;

        double a = cwDelta(start, angle);
        // 不包含端点：a 在 (0, total) 之间才算经过
        return a > EPS && a < total - EPS;
    }

    /**
     * 判断 angle 是否落在从 start -> end 的逆时针弧段上（不含端点）。
     * 逆时针等价于：顺时针从 end -> start 的弧段。
     */
    private static boolean isOnArcCCW(double start, double end, double angle) {
        // 逆时针 start->end == 顺时针 end->start
        return isOnArcCW(end, start, angle);
    }

    /**
     * That vehicle is walking if the dynamic node count > 1
     */
    @SuppressWarnings("all")
    public boolean isWalkingByVehicle(Integer lev, String vehicle) {
        if (Cools.isEmpty(vehicle)) {
            return false;
        }

        lev = Optional.ofNullable(lev).orElse(MapDataDispatcher.MAP_DEFAULT_LEV);
        DynamicNode[][] dynamicMatrix = mapDataDispatcher.getDynamicMatrix(lev);

        int count = 0;
        for (int i = 0; i < dynamicMatrix.length; i++) {
            for (int j = 0; j < dynamicMatrix[i].length; j++) {
                if (vehicle.equals(dynamicMatrix[i][j].getVehicle())) {
                    count++;
                    if (count > 1) {
                        return true;
                    }
                }
            }
        }

        return false;
    }

    public List<String> queryCodeListFromDynamicNode(Integer lev, String nodeType) {
        if (Cools.isEmpty(nodeType)) {
            return new ArrayList<>();
        }
        lev = Optional.ofNullable(lev).orElse(MapDataDispatcher.MAP_DEFAULT_LEV);

        DynamicNode[][] dynamicMatrix = mapDataDispatcher.getDynamicMatrix(lev);
        String[][] codeMatrix = mapDataDispatcher.getCodeMatrix(lev);

        // concurrent
        ConcurrentLinkedQueue<SortCodeDto> codeList = new ConcurrentLinkedQueue<>();
        IntStream.range(0, codeMatrix.length).parallel().forEach(i -> {
            for (int j = 0; j < codeMatrix[i].length; j++) {
                DynamicNode dynamicNode = dynamicMatrix[i][j];
                if (nodeType.equals(dynamicNode.getVehicle())) {
                    codeList.add(new SortCodeDto(codeMatrix[i][j], dynamicNode.getSerial()));
                }
            }
        });

        // synchronize
//        List<SortCodeDto> codeList = new ArrayList<>();
//        for (int i = 0; i < codeMatrix.length; i++) {
//            for (int j = 0; j < codeMatrix[i].length; j++) {
//                DynamicNode dynamicNode = dynamicMatrix[i][j];
//                if (nodeType.equals(dynamicNode.getVehicle())) {
//                    codeList.add(new SortCodeDto(codeMatrix[i][j], dynamicNode.getSerial()));
//                }
//            }
//        }

        return codeList.stream()
                .sorted(Comparator.comparingInt(SortCodeDto::getSerial))
                .map(SortCodeDto::getCode)
                .collect(Collectors.toList());
    }

    public Map<String, List<String>> queryCodeListFromDynamicNode(Integer lev, Set<String> vehicles) {
        if (Cools.isEmpty(vehicles)) {
            return new HashMap<>();
        }
        lev = Optional.ofNullable(lev).orElse(MapDataDispatcher.MAP_DEFAULT_LEV);

        DynamicNode[][] dynamicMatrix = mapDataDispatcher.getDynamicMatrix(lev);
        String[][] codeMatrix = mapDataDispatcher.getCodeMatrix(lev);

        Map<String, List<SortCodeDto>> map = new HashMap<>(vehicles.size());

        for (int i = 0; i < codeMatrix.length; i++) {
            for (int j = 0; j < codeMatrix[i].length; j++) {
                DynamicNode dynamicNode = dynamicMatrix[i][j];
                String vehicle = dynamicNode.getVehicle();

                if (vehicles.contains(vehicle)) {
                    int serial = dynamicNode.getSerial();
                    map.computeIfAbsent(vehicle, k -> new ArrayList<>()).add(new SortCodeDto(codeMatrix[i][j], serial));
                }
            }
        }

        Map<String, List<String>> result = new HashMap<>(vehicles.size());
        for (Map.Entry<String, List<SortCodeDto>> entry : map.entrySet()) {
            List<String> codeDataList = entry.getValue().stream()
                    .sorted(Comparator.comparingInt(SortCodeDto::getSerial))
                    .map(SortCodeDto::getCode)
                    .collect(Collectors.toList());
            result.put(entry.getKey(), codeDataList);
        }

        return result;
    }

}