package com.zy.asrs.utils;

import com.zy.core.enums.RouteCollectCountType;

import java.util.ArrayList;
import java.util.List;

import static java.util.stream.Collectors.toList;

/**
 * Created by Monkey D. Luffy on 2023/7/18
 */
public class RouteUtils {

    //问题2  周俊杰
    public static final List<Integer> MERGE_STA_NO_One = new ArrayList<Integer>() {{
        add(113);add(119);
    }};

    public static final List<Integer> MERGE_STA_NO_TWO = new ArrayList<Integer>() {{
//        add(116);add(117);
    }};

    public static final List<Integer> MERGE_STA_NO_THREE = new ArrayList<Integer>() {{
//        add(116);add(117);
    }};

    public static final List<Integer> MERGE_STA_NO_FOUR = new ArrayList<Integer>() {{
//        add(116);add(117);
    }};

//    正序
    public static final List<Integer> TRACK_POSITION_POSITIVE_SEQUENCE = new ArrayList<Integer>() {{
        add(161);add(157);add(153);add(149);add(124);add(119);add(113);add(999);;add(112);add(107);add(106);add(101);add(100);
    }};
//    反序
    public static final List<Integer> TRACK_POSITION_REVERSE_SEQUENCE = new ArrayList<Integer>() {{
        add(100);add(101);add(106);add(107);add(112);add(999);add(113);add(119);add(124);add(149);add(153);add(157);add(161);
    }};

    public static String zerofill(String msg, Integer count){
        if (msg.length() == count){
            return msg;
        } else if (msg.length() > count){
            return msg.substring(0, 16);
        } else {
            StringBuilder msgBuilder = new StringBuilder(msg);
            for (int i = 0; i<count-msg.length(); i++){
                msgBuilder.insert(0,"0");
            }
            return msgBuilder.toString();
        }
    }
    /*
     * 获取干涉最远站点
     * */
    public static Integer RouteIndexFarMas(int rgvNo,Integer staNo){
        List<Integer> staFall = new ArrayList<>();
        if (MERGE_STA_NO_One.contains(staNo)){
            staFall = MERGE_STA_NO_One;
        }else if (MERGE_STA_NO_TWO.contains(staNo)){
            staFall = MERGE_STA_NO_TWO;
        }else if (MERGE_STA_NO_THREE.contains(staNo)){
            staFall = MERGE_STA_NO_THREE;
        }else if (MERGE_STA_NO_FOUR.contains(staNo)){
            staFall = MERGE_STA_NO_FOUR;
        }else {
            return staNo;
        }

        int indexNo = 0;
        if (rgvNo==1){
            indexNo=staFall.size()-1;
        }
        return staFall.get(indexNo);
    }


    // 获取当前小车未行走的路线集合
    public static List<Integer> getRoute(Integer groupStart,Integer groupEnd){
        boolean sign = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(groupStart) < TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(groupEnd);
        List<Integer> result = new ArrayList<>();
        List<Integer> groupRoute = new ArrayList<>();
        if (sign){
            groupRoute = TRACK_POSITION_POSITIVE_SEQUENCE;
        }else {
            groupRoute = TRACK_POSITION_REVERSE_SEQUENCE;
        }
        if (groupRoute.contains(groupStart) && groupRoute.contains(groupEnd)) {
            sign = false;
            for (Integer route : groupRoute) {
                if (route.equals(groupStart)){
                    sign=true;
                }
                if (route.equals(groupEnd)){
                    result.add(route);
                    break;
                }
                if (sign){
                    result.add(route);
                }
            }
        }else {
            return null;
        }
        return result;
    }

    /*
    * 获取最远站点
    * */
    public static Integer RouteIndexFarMas(Integer a,Integer b,Integer c,Integer d){
        int ia = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(a);
        int ib = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(b);
        int ic = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(c);
        int id = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(d);
        if (id==0){
            if (ia>ib){
                if (ia>ic){
                    return a;
                }else {
                    return c;
                }
            }else {
                if (ib>ic){
                    return b;
                }else {
                    return c;
                }
            }
        }else {
            if (ia<ib){
                if (ia<ic){
                    return a;
                }else {
                    return c;
                }
            }else {
                if (ib<ic){
                    return b;
                }else {
                    return c;
                }
            }
        }
    }

    public static Integer[] RouteIndexFarArr(Integer a,Integer b,Integer c,Integer d){
        int ia = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(a);
        int ib = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(b);
        int ic = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(c);
        int id = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(d);
        return new Integer[]{ia,ib,ic,id};
    }

    /*
     * a  小车当前位置
     * b  小车任务开始位置
     * c  小车任务结束位置
     * d  小车初始位置
     * 获取最大路径差值
     * */
    public static List<Integer>  RouteMapCurrentFar(Integer a,Integer b,Integer c,Integer d){
        Integer farStn = RouteIndexFarMas(a, b, c, d);
        return getRouteIntersection(TRACK_POSITION_POSITIVE_SEQUENCE,getRoute(farStn, d), RouteCollectCountType.DIFFERENCESET);
    }

    public static List<Integer>  RouteMapCurrentFar(Integer farStn,Integer d){
        return getRouteIntersection(TRACK_POSITION_POSITIVE_SEQUENCE,getRoute(farStn, d), RouteCollectCountType.DIFFERENCESET);
    }

    /*
    * 另一台小车最远位置
    * */
    public static Integer RouteMapOtherFarStnNo(List<Integer> routeDIFF,Integer d){
        int id = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(d);
        if (id==0){
            return routeDIFF.get(0);
        }else {
            int size = routeDIFF.size();
            return routeDIFF.get(size-1);
        }
    }

    //是否有交集
    public static boolean getRouteBoolean(List<Integer> groupCurrent,List<Integer> groupOther){
        for (Integer positionCurrent : groupCurrent){
            for (Integer positionOther : groupOther){
                if (positionCurrent.equals(positionOther)){
                    return true;
                }
            }
        }
        return false;
    }

    //集合运算
    public static List<Integer> getRouteIntersection(List<Integer> groupCurrent, List<Integer> groupOther, RouteCollectCountType routeCollectCountType){
        switch (routeCollectCountType){
            case INTERSECTION:
                //交集
                return groupCurrent.stream().filter(item -> groupOther.contains(item)).collect(toList());
            case DIFFERENCESET:
                //差集
                return groupCurrent.stream().filter(item -> !groupOther.contains(item)).collect(toList());
            case UNION:
                //并集
                groupCurrent.addAll(groupOther);
                return groupCurrent;
            case DEDUPLICATIONUNION:
                //去重并集
                groupCurrent.addAll(groupOther);
                return groupCurrent.stream().distinct().collect(toList());
            default:
                return null;
        }
    }

    /*
    * a  小车当前位置
    * b  小车任务开始位置
    * c  小车任务结束位置
    * sign  另一个小车空闲标记
    * */
    public static boolean RouteAutoBoolean(Integer a,Integer b,Integer c,Integer aa,Integer bb,Integer cc,boolean idleOther){
        List<Integer> routeCurrent = getRouteIntersection(getRoute(a, c), getRoute(b, c), RouteCollectCountType.DEDUPLICATIONUNION);//并集
        List<Integer> routeOther = getRouteIntersection(getRoute(aa, cc), getRoute(bb, cc), RouteCollectCountType.DEDUPLICATIONUNION);//
        return !getRouteBoolean(routeCurrent, routeOther);  //是否有交集
    }

    public static List<Integer> RouteAutoBoolean(Integer a,Integer b,Integer c){
        return getRouteIntersection(getRoute(a, c), getRoute(b, c), RouteCollectCountType.DEDUPLICATIONUNION);
    }

    public static Short CrnStaEnd(Integer endSta,Integer souSta) {
        switch (endSta) {
            case 100:
                if (souSta == 118){
                    return (short)119;
                }
                return (short)149;
            case 102:
            case 111:
                return 149;
            default:
                return endSta.shortValue();
        }
    }



    public static void main(String[] arge){
        List<Integer> routeCurrent = getRoute(100, 124);  //获取当前小车路径
        List<Integer> routeOther = getRoute(149, 161);  //获取其它小车路径
        System.out.println("当前小车路径:\t"+routeCurrent);
        System.out.println("其它小车路径:\t"+routeOther);

        boolean routeBoolean = getRouteBoolean(routeCurrent, routeOther);  //是否有交集
        System.out.println("是否有交集:\t"+routeBoolean);

        List<Integer> routeIntersection = getRouteIntersection(routeCurrent, routeOther, RouteCollectCountType.INTERSECTION);//交集
        System.out.println("路径交集：\t"+routeIntersection);

        List<Integer> routeIntersection1 = getRouteIntersection(routeCurrent, routeOther, RouteCollectCountType.DIFFERENCESET);//差集
        System.out.println("路径差集：\t"+routeIntersection1);

        List<Integer> routeIntersection2 = getRouteIntersection(routeCurrent, routeOther, RouteCollectCountType.UNION);//并集
        System.out.println("路径并集：\t"+routeIntersection2);

        List<Integer> routeIntersection3 = getRouteIntersection(routeCurrent, routeOther, RouteCollectCountType.DEDUPLICATIONUNION);//去重并集
        System.out.println("路径去重并集：\t"+routeIntersection3);

        /*
         * a  小车当前位置
         * b  小车任务开始位置
         * c  小车任务结束位置
         * sign  另一个小车空闲标记
         * */
        System.out.println("是否有交集：\t"+RouteAutoBoolean(100,101,124,149,161,153,true));   //是否有交集  true无交集  false有交集

        /*
         * a  小车当前位置
         * b  小车任务开始位置
         * c  小车任务结束位置
         * d  小车初始位置
         * 获取最大路径差值
         * */
        List<Integer> routeDIFF = RouteMapCurrentFar(100,101,124,149);
        System.out.println("当前路径最大集合：\t"+ routeDIFF);

        Integer routeFarOther= RouteMapOtherFarStnNo(routeDIFF,124);
        System.out.println("另一台小车最远站点：\t"+routeFarOther);


        Integer[] integers = RouteIndexFarArr(100,101,124,149);
        for (Integer integer:integers){
            System.out.println(integer);
        }
    }

}