package com.zy.asrs.utils;

import com.zy.asrs.entity.BasDevpPosition;
import com.zy.asrs.entity.WrkMast;
import com.zy.core.enums.RouteCollectCountType;

import java.util.*;

public class SortTheExecutionOfTheCarUtil {
    //排序
    public static int[][] ReorderSteId(int[][] steList,int steNoStart){
        int[][] ints = new int[steList.length][2];
        int Difference = 0;
        for (int[] steNo : steList){
            if (steNo[0] == steNoStart){
                Difference = steNo[1] - 1;
                break;
            }
        }
        for (int[] steNo : steList){
            int i = steNo[1];
            if (i > Difference){
                steNo[1] = i - Difference;
            } else {
                steNo[1] = steList.length + i-Difference;
            }
            ints[steNo[0]-1] = steNo;
        }
        return ints;
    }

//    //获取最近并在当前位置前边的位置1000000===>10000==>0==>1000000
//    public static Integer LatelyAndLessThan(List<BasDevpPosition> devpPosition, long nowPosition,long perimeter){
//        Integer result = 0;
//        long Difference = perimeter;
//        for (BasDevpPosition positions : devpPosition){
//            Long position = positions.getPlcPosition();
//            if (position<=nowPosition){
//                if ((nowPosition-position) < Difference){
//                    Difference = nowPosition-position;
//                    result = positions.getDevNo();
//                }
//            } else {
//                if ((nowPosition-(position - perimeter)) < Difference){
//                    Difference = nowPosition-(position - perimeter);
//                    result = positions.getDevNo();
//                }
//            }
//        }
//        return result;
//    }
    //获取最近并在当前位置前边的位置 0==>1000===>1000000==>0
    public static Integer LatelyAndLessThan(List<BasDevpPosition> devpPosition, long nowPosition,long perimeter){
        Integer result = 0;
        long Difference = perimeter;
        for (BasDevpPosition positions : devpPosition){
            Long position = positions.getPlcPosition();
            if (position >= nowPosition){
                if ((position-nowPosition) < Difference){
                    Difference = position-nowPosition;
                    result = positions.getDevNo();
                }
            } else {
                if (perimeter - (nowPosition - position) < Difference){
                    Difference = perimeter - (nowPosition - position);
                    result = positions.getDevNo();
                }
            }
        }
        return result;
    }

//    //获取最近并在当前位置后边的位置 1000000===>10000==>0==>1000000
//    public static Integer LatelyAndLessThanWcs(List<BasDevpPosition> devpPosition, long nowPosition,long perimeter){
//        Integer result = 0;
//        Integer integer = LatelyAndLessThan(devpPosition, nowPosition,perimeter);
//        for (BasDevpPosition basDevpPosition:devpPosition){
//            if (basDevpPosition.getDevNo().equals(integer)){
//                if (basDevpPosition.getDevNo() == 101){
//                    result = 133;
//                }
//                break;
//            }
//            result = basDevpPosition.getDevNo();
//        }
//        return result;
//    }
    //获取最近并在当前位置后边的位置 0==>1000===>1000000==>0
    public static Integer LatelyAndLessThanWcs(List<BasDevpPosition> devpPosition, long nowPosition,long perimeter){
        Integer result = -1;
        Integer integer = LatelyAndLessThan(devpPosition, nowPosition,perimeter);
        for (BasDevpPosition basDevpPosition:devpPosition){
            if (basDevpPosition.getDevNo().equals(integer)){
                if (basDevpPosition.getDevNo() == 133){
                    result = 101;
                }
                break;
            }
            result = basDevpPosition.getDevNo();
        }
        return result;
    }
//    //获取最近并在当前位置前边的位置
//    public static Long LatelyAndLessThan(long[] devpPosition,long nowPosition){
//        long result = 0L;
//        long Difference = 1737000L;
//        for (long position : devpPosition){
//            if (position<=nowPosition){
//                if ((nowPosition-position) < Difference){
//                    Difference = nowPosition-position;
//                    result = position;
//                }
//            } else {
//                if ((nowPosition-(position - 1737000L)) < Difference){
//                    Difference = nowPosition-(position - 1737000L);
//                    result = position;
//                }
//            }
//        }
//        return result;
//    }

//    //获取最近并在当前位置后边的位置  1000000===>10000==>0==>1000000
//    public static Integer LatelyAndGreaterThan(List<List<Long>> sitePosition, long nowPosition ,long perimeter){
//        int result = 0;
//        long Difference = perimeter;
//        for (List<Long> rgvPositions: sitePosition){
//            Long position = rgvPositions.get(1);
//            if (position>nowPosition){
//                if ((position - nowPosition) < Difference){
//                    Difference = position - nowPosition;
//                    result = rgvPositions.get(0).intValue();
//                }
//            } else {
//                if ((perimeter - (nowPosition - position)) < Difference){
//                    Difference = perimeter - (nowPosition - position);
//                    result = rgvPositions.get(0).intValue();
//                }
//            }
//        }
//        return result;
//    }

    //获取最近并在当前位置后边的位置   0==>1000===>1000000==>0
    public static Integer LatelyAndGreaterThan(List<List<Long>> sitePosition, long nowPosition ,long perimeter){
        int result = -1;
        long Difference = perimeter;
        for (List<Long> rgvPositions: sitePosition){
            Long position = rgvPositions.get(1);
            if (position <= nowPosition){
                if ((nowPosition - position) < Difference){
                    Difference = nowPosition - position;
                    result = rgvPositions.get(0).intValue();
                }
            } else {
                if ((perimeter - (nowPosition - position)) < Difference){
                    Difference = perimeter - (nowPosition - position);
                    result = rgvPositions.get(0).intValue();
                }
            }
        }
        return result;
    }

    //id初始化
    public static List<BasDevpPosition> devpNoInit(List<BasDevpPosition> devpPosition){
        long i = 0;
        for (BasDevpPosition basDevpPosition : devpPosition){
            i++;
            basDevpPosition.setId(i);
        }
        return devpPosition;
    }


    //站点排序
    public static BasDevpPosition[] devpNoSort(List<BasDevpPosition> devpPosition1,Integer devpNo){
        List<BasDevpPosition> devpPosition = devpNoInit(devpPosition1);
        BasDevpPosition[] basDevpPositions = new BasDevpPosition[devpPosition.size()];
        long Difference = 0L;
        for (BasDevpPosition basDevpPosition : devpPosition){
            if (basDevpPosition.getDevNo().equals(devpNo)){
                Difference = basDevpPosition.getId() - 1L;
                break;
            }
        }
        for (BasDevpPosition basDevpPosition : devpPosition){
            long i = basDevpPosition.getId();
            if (i > Difference){
                basDevpPosition.setId(i - Difference);
            } else {
                basDevpPosition.setId(devpPosition.size() + i - Difference);
            }
            basDevpPositions[basDevpPosition.getId().intValue()-1] = basDevpPosition;
        }
        return basDevpPositions;
    }

    //逆序排列
    public static BasDevpPosition[] devpNoSortUN(BasDevpPosition[] devpPosition){
        BasDevpPosition[] basDevpPositions = new BasDevpPosition[devpPosition.length];
        for (BasDevpPosition basDevpPosition : devpPosition){
            basDevpPositions[devpPosition.length - basDevpPosition.getId().intValue()] = basDevpPosition;
        }
        return basDevpPositions;
    }

    //逆序排列
    public static boolean devpNoSortbj(BasDevpPosition[] devpPosition,Integer souDevpNo,Integer endDevpNo){
        int sou = 0;
        int end = 0;
        for (int i = 0;i<devpPosition.length;i++){
            if (devpPosition[i].getDevNo().equals(souDevpNo)){
                sou = i;
            }
            if (devpPosition[i].getDevNo().equals(endDevpNo)){
                end = i;
            }
        }

        return sou>end;
    }

    //提取站点集合
    public static List<Integer> WrkMastExtractSites(List<WrkMast> wrkMastList){
        List<Integer> siteList = new ArrayList<>();
        for (WrkMast wrkMast : wrkMastList){
            if (!siteList.contains(wrkMast.getSourceStaNo())){
                siteList.add(wrkMast.getSourceStaNo());
            }
        }
        return siteList;
    }
    //提取站点集合
    public static List<Integer> BasDevpPositionExtractSites(List<BasDevpPosition> basDevpPositions){
        List<Integer> siteList = new ArrayList<>();
        for (BasDevpPosition basDevpPosition : basDevpPositions){
            if (!siteList.contains(basDevpPosition.getDevNo())){
                siteList.add(basDevpPosition.getDevNo());
            }
        }
        return siteList;
    }

    //提取站点集合X2
    public static List<Integer> ExtractSitesComplex(List<Integer> siteList){
        siteList.addAll(siteList);
        return siteList;
    }

    //集合转数组
    public static int[] SetToArrayConversion(List<Integer> siteList){
        int[] nums = new int[siteList.size()];
        for (int i = 0;i<siteList.size();i++){
            nums[i] = siteList.get(i);
        }
        return nums;
    }

    //获取任务密集区
    public static List<Integer> ObtainDenseAreasSite(List<Integer> siteList,List<Integer> devpList){

        List<Integer> siteLists = ExtractSitesComplex(devpList);
        int[] nums = SetToArrayConversion(siteLists);

        List<Integer> champion = new ArrayList<>();
        for (int rangeArea = 1; rangeArea<=devpList.size();rangeArea++){
            List<List<Integer>> subsets = getConsecutiveSubsets(nums, rangeArea);
            if (subsets != null){
                int temporaryMaxCount = 0;
                List<Integer> championTemporary = new ArrayList<>();
                int championCount = 0;

                for (List<Integer> one : subsets){
                    int intersectionSize = getIntersectionSize(siteList, one);
                    if (intersectionSize == temporaryMaxCount){
                        championCount++;
                        championTemporary = one;
                    } else if (intersectionSize > temporaryMaxCount){
                        championCount = 1 ;
                        temporaryMaxCount = intersectionSize;
                        championTemporary = one;
                    }
                }
                if (championCount == 1){
                    champion = championTemporary;
                    break;
                }
                continue;
            }
            break;
        }

        return champion;
    }

    public static Integer ObtainDenseAreasFirstPlace(List<Integer> siteList,List<Integer> devpList){
        List<Integer> integers = ObtainDenseAreasSite(siteList, devpList);
        if (integers==null){
            return null;
        }
        return integers.get(0);
    }

//    public static void main(String[] args) {
////        int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//        List<Integer> siteList = new ArrayList<Integer>() {{
//            add(1);add(2);add(3);add(4);add(5);add(6);add(7);add(8);add(9);add(10);
//        }};
//        List<Integer> siteLists = ExtractSitesComplex(siteList);
//        int[] nums = SetToArrayConversion(siteLists);
//        int subsetSize = 5;  // 可以通过用户输入或者其他方式控制
//        List<List<Integer>> subsets = getConsecutiveSubsets(nums, subsetSize);
//        if (subsets != null){
//            for (List<Integer> subset : subsets) {
//                System.out.println(subset);
//            }
//        } else {
//            System.out.println("子集大小必须大于0且小于等于数组长度");
//        }
//    }

    public static List<List<Integer>> getConsecutiveSubsets(int[] nums, int size) {
        List<List<Integer>> result = new ArrayList<>();

        // 确保子集的大小合法
        if (size > nums.length || size <= 0) {
//            throw new IllegalArgumentException("子集大小必须大于0且小于等于数组长度");
            return null;
        }

        // 通过滑动窗口法生成相邻的子集
        for (int i = 0; i <= nums.length - size; i++) {
            List<Integer> subset = new ArrayList<>();
            for (int j = 0; j < size; j++) {
                subset.add(nums[i + j]);
            }
            if (!result.contains(subset)){
                result.add(subset);
            }
        }

        return result;
    }

    public static int getIntersectionSize(List<Integer> listA, List<Integer> listB) {
        // 使用集合来存储交集元素，避免重复
        Set<Integer> intersection = new HashSet<>(listA);

        // 保留集合A和集合B中的共同元素
        intersection.retainAll(listB);

        // 返回交集的大小
        return intersection.size();
    }

//    public static void main(String[] args) {
//        int[][] ints = new int[][]{{1,1},{3,3},{2,2},{4,4},{5,5},{6,6},{7,7},{8,8},{9,9},{10,10}};
//
//        int[][] reorderSteId = ReorderSteId(ints, 2);
//        for (int[] ste : reorderSteId){
//            System.out.println(Arrays.toString(ste));
//        }
//
//        long[] longs = new long[]{1L,1000L,200000L,1100000L,1600000L};
//        long l = LatelyAndLessThan(longs, 1100000L);
//        System.out.println("l:"+l);
//    }


//    public static void main(String[] args) {
//        int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//        List<List<Integer>> subsets = getSubsets(nums);
//
//        for (List<Integer> subset : subsets) {
//            System.out.println(subset);
//        }
//    }
//
//    public static List<List<Integer>> getSubsets(int[] nums) {
//        List<List<Integer>> result = new ArrayList<>();
//        generateSubsets(0, nums, new ArrayList<>(), result);
//        return result;
//    }
//
//    private static void generateSubsets(int index, int[] nums, List<Integer> current, List<List<Integer>> result) {
//        if (index == nums.length) {
//            result.add(new ArrayList<>(current));
//            return;
//        }
//
//        // 不包含当前元素的子集
//        generateSubsets(index + 1, nums, current, result);
//
//        // 包含当前元素的子集
//        current.add(nums[index]);
//        generateSubsets(index + 1, nums, current, result);
//
//        // 回溯
//        current.remove(current.size() - 1);
//    }

    /*  好东西，做记录
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int subsetSize = 3;  // 可以通过用户输入或者其他方式控制
        List<List<Integer>> subsets = getConsecutiveSubsets(nums, subsetSize);

        for (List<Integer> subset : subsets) {
            System.out.println(subset);
        }
    }

    public static List<List<Integer>> getConsecutiveSubsets(int[] nums, int size) {
        List<List<Integer>> result = new ArrayList<>();

        // 确保子集的大小合法
        if (size > nums.length || size <= 0) {
            throw new IllegalArgumentException("子集大小必须大于0且小于等于数组长度");
        }

        // 通过滑动窗口法生成相邻的子集
        for (int i = 0; i <= nums.length - size; i++) {
            List<Integer> subset = new ArrayList<>();
            for (int j = 0; j < size; j++) {
                subset.add(nums[i + j]);
            }
            result.add(subset);
        }

        return result;
    }
    * */


//    public static void main(String[] args) {
//        // 示例列表A和列表B
//        List<Integer> listA = new ArrayList<>();
//        List<Integer> listB = new ArrayList<>();
//
//        // 初始化列表A
//        listA.add(1);
//        listA.add(2);
//        listA.add(3);
//        listA.add(4);
//        listA.add(5);
//
//        // 初始化列表B
//        listB.add(3);
//        listB.add(4);
//        listB.add(5);
//        listB.add(6);
//        listB.add(7);
//
//        // 计算交集数量
//        int intersectionSize = getIntersectionSize(listA, listB);
//        System.out.println("交集的数量是: " + intersectionSize);
//    }


    //获取最近并在当前位置前边的位置 0==>1000===>1000000==>0
    public static Double LatelyAndLessThan(long devPosition,long rgvPosition,long perimeter){
        long Difference = perimeter;
        if (devPosition >= rgvPosition){
//            if ((devPosition-rgvPosition) < Difference){
                Difference = devPosition-rgvPosition;
//            }
        } else {
//            if (perimeter - (rgvPosition - devPosition) < Difference){
                Difference = perimeter - (rgvPosition - devPosition);
//            }
        }
        return Double.valueOf(Difference);
    }

    public static int calculateShortestDistanceDistance(List<Integer> data, int a, int b) {
        Result result = calculateShortestDistance(data, a, b);
        return result.distance;
    }

    public static List<Integer> calculateShortestDistancePassedData(List<Integer> data, int a, int b) {
        Result result = calculateShortestDistance(data, a, b);
        return result.passedData;
    }

//    public static String calculateShortestDistanceDirection(List<Integer> data, int a, int b) {
//        Result result = calculateShortestDistance(data, a, b);
//        return result.direction;
//    }

    public static boolean calculateShortestDistanceDirection(List<Integer> data, int a, int b) {
        Result result = calculateShortestDistance(data, a, b);
        return result.direction.equals("向前走（顺时针）");
    }


    public static void main(String[] args) {
        List<Integer> data = new ArrayList<>();
        // 用 List<Integer> 初始化数据
        for (int i = 1; i <= 9; i++) {
            data.add(i);
        }

        int a = 3; // 起点
        int b = 3; // 终点

        Result result = calculateShortestDistance(data, a, b);
        System.out.println("最近的距离是: " + result.distance);
        System.out.println("经过的数据: " + result.passedData);
        System.out.println("方向: " + result.direction);
    }

    public static Result calculateShortestDistance(List<Integer> data, int a, int b) {
        int length = data.size();
        int indexA = data.indexOf(a);
        int indexB = data.indexOf(b);

        if (indexA == -1 || indexB == -1) {
            throw new IllegalArgumentException("列表中未找到指定的元素");
        }

        // 顺时针方向的距离及经过的数据
        List<Integer> clockwiseData = new ArrayList<>();
        int clockwiseDistance = (indexB - indexA + length) % length;
        for (int i = 0; i <= clockwiseDistance; i++) {
            clockwiseData.add(data.get((indexA + i) % length));
        }

        // 逆时针方向的距离及经过的数据
        List<Integer> counterClockwiseData = new ArrayList<>();
        int counterClockwiseDistance = (indexA - indexB + length) % length;
        for (int i = 0; i <= counterClockwiseDistance; i++) {
            counterClockwiseData.add(data.get((indexA - i + length) % length));
        }

        // 比较距离并返回结果
        if (clockwiseDistance <= counterClockwiseDistance) {
            return new Result(clockwiseDistance, clockwiseData, "向前走（顺时针）");
        } else {
            return new Result(counterClockwiseDistance, counterClockwiseData, "向后走（逆时针）");
        }
    }

    // 用于返回结果的类
    static class Result {
        public int distance;
        public List<Integer> passedData;
        public String direction;

        public Result(int distance, List<Integer> passedData, String direction) {
            this.distance = distance;
            this.passedData = passedData;
            this.direction = direction;
        }
    }

}