package com.zy.asrs.wcs.core.utils;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zy.asrs.framework.common.Cools;
import com.zy.asrs.framework.common.SpringUtils;
import com.zy.asrs.framework.exception.CoolException;
import com.zy.asrs.wcs.core.entity.Task;
import com.zy.asrs.wcs.core.entity.TaskSerialNo;
import com.zy.asrs.wcs.core.service.TaskSerialNoService;
import com.zy.asrs.wcs.core.service.TaskService;
import com.zy.asrs.wcs.rcs.cache.SlaveConnection;
import com.zy.asrs.wcs.rcs.entity.Device;
import com.zy.asrs.wcs.rcs.entity.DeviceType;
import com.zy.asrs.wcs.rcs.model.enums.SlaveType;
import com.zy.asrs.wcs.rcs.model.protocol.ShuttleProtocol;
import com.zy.asrs.wcs.rcs.service.DeviceService;
import com.zy.asrs.wcs.rcs.service.DeviceTypeService;
import com.zy.asrs.wcs.rcs.thread.ShuttleThread;

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

public class Utils {

    public static final String _LINK = "-";

    /**
     * 通过库位号获取 排
     */
    public static int getRow(String locNo) {
        if (!Cools.isEmpty(locNo)) {
            String[] split = locNo.split(_LINK);
            return Integer.parseInt(split[0]);
        }
        throw new RuntimeException("库位解析异常");
    }

    /**
     * 通过库位号获取 列
     */
    public static int getBay(String locNo) {
        if (!Cools.isEmpty(locNo)) {
            String[] split = locNo.split(_LINK);
            return Integer.parseInt(split[1]);
        }
        throw new RuntimeException("库位解析异常");
    }

    /**
     * 通过库位号获取 层
     */
    public static int getLev(String locNo) {
        if (!Cools.isEmpty(locNo)) {
            String[] split = locNo.split(_LINK);
            return Integer.parseInt(split[2]);
        }
        throw new RuntimeException("库位解析异常");
    }

    public static String getLocNo(Number row, Number bay, Number lev) {
        return row + _LINK + bay + _LINK + lev;
//        return zerofill(String.valueOf(row), 2) + zerofill(String.valueOf(bay), 3) + zerofill(String.valueOf(lev), 2);
    }

    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();
        }
    }

    //获取除白名单外的指定楼层全部穿梭车xy坐标点
    public static List<int[]> getShuttlePoints(Integer whiteShuttle, Integer lev) {
//        SlaveProperties slaveProperties = SpringUtils.getBean(SlaveProperties.class);
        ArrayList<int[]> list = new ArrayList<>();
//        for (ShuttleSlave slave : slaveProperties.getShuttle()) {
//            if (slave.getId().intValue() == whiteShuttle) {
//                continue;//跳过白名单
//            }
//
//            //获取穿梭车所在节点位置
//            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, slave.getId());
//            if (shuttleThread == null) {
//                continue;
//            }
//            ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
//            if (shuttleProtocol == null) {
//                continue;
//            }
//
//            if (shuttleProtocol.getCurrentLocNo() == null) {
//                continue;
//            }
//
//            if (lev != Utils.getLev(shuttleProtocol.getCurrentLocNo())) {
//                continue;//楼层不同
//            }
//
//            int[] xyPosition = NavigatePositionConvert.positionToXY(shuttleProtocol.getCurrentLocNo());//通过库位号获取xy坐标
//            list.add(xyPosition);
//        }
        return list;
    }

    public static boolean hasShuttleInLoc(String locNo, Long deviceId) {
        DeviceTypeService deviceTypeService = SpringUtils.getBean(DeviceTypeService.class);
        DeviceService deviceService = SpringUtils.getBean(DeviceService.class);

        DeviceType deviceType = deviceTypeService.getOne(new LambdaQueryWrapper<DeviceType>()
                .eq(DeviceType::getFlag, String.valueOf(SlaveType.Shuttle))
                .eq(DeviceType::getStatus, 1));
        if (deviceType == null) {
            return false;
        }

        List<Device> list = deviceService.list(new LambdaQueryWrapper<Device>()
                .eq(Device::getDeviceType, deviceType.getId())
                .eq(Device::getStatus, 1));

        for (Device device : list) {
            if (deviceId.equals(device.getId())) {
                continue;
            }

            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, device.getId().intValue());
            if (shuttleThread == null) {
                continue;
            }

            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                continue;
            }

            if (shuttleProtocol.getCurrentLocNo().equals(locNo)) {
                return true;
            }
        }

        return false;
    }

    /**
     * 生成工作号
     * @return taskNo(工作号)
     */
    public static int getTaskNo(String flag) {
        TaskSerialNoService taskSerialNoService = SpringUtils.getBean(TaskSerialNoService.class);
        TaskService taskService = SpringUtils.getBean(TaskService.class);
        TaskSerialNo taskSerialNo = taskSerialNoService.getOne(new LambdaQueryWrapper<TaskSerialNo>()
                .eq(TaskSerialNo::getFlag, flag)
                .eq(TaskSerialNo::getStatus, 1));
        if (Cools.isEmpty(taskSerialNo)) {
            throw new CoolException("数据异常，请联系管理员");
        }

        int taskNo = taskSerialNo.getTaskNo();
        int sNo = taskSerialNo.getStartNo();
        int eNo = taskSerialNo.getTargetNo();
        taskNo = taskNo >= eNo ? sNo : taskNo + 1;
        while (true) {
            Task task = taskService.getOne(new LambdaQueryWrapper<Task>()
                    .eq(Task::getTaskNo, taskNo));
            if (null != task) {
                taskNo = taskNo >= eNo ? sNo : taskNo + 1;
            } else {
                break;
            }
        }
        // 修改序号记录
        if (taskNo > 0){
            taskSerialNo.setTaskNo(taskNo);
            taskSerialNoService.updateById(taskSerialNo);
            return taskNo;
        }
        throw new CoolException("工作号生成失败");
    }

}