package com.wms.controller;

import com.alibaba.fastjson2.JSON;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.wms.constants.enums.*;
import com.wms.entity.app.*;
import com.wms.entity.app.wcs.*;
import com.wms.entity.page.PageDomain;
import com.wms.mapper.StockMapper;
import com.wms.mapper.TaskMapper;
import com.wms.entity.page.TableRequest;
import com.wms.entity.page.TableResponse;
import com.wms.entity.table.*;
import com.wms.constants.WmsConstants;
import com.wms.utils.storage.LocationUtils;
import com.wms.service.*;
import com.wms.utils.HttpUtils;
import com.wms.mapper.LocationMapper;
import com.wms.utils.StringUtils;
import com.wms.utils.WmsUtils;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.bind.annotation.*;

import java.util.*;

/**
 * WMS任务控制类
 *
 * @author 梁州
 * @date  2023/2/14
 */
@Controller
@CrossOrigin
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
@RequestMapping(value = "/wms/task")
public class TaskController extends BaseController {
    /**
     * 任务服务
     */
    private final TaskService taskService;
    /**
     * 任务 Mapper
     */
    private final TaskMapper taskMapper;
    /**
     * 库存 Mapper
     */
    private final StockMapper stockMapper;
    /**
     * 库存服务
     */
    private final StockService stockService;
    /**
     * 库位操作类
     */
    private final LocationUtils locationUtils;

    /**
     * 零件
     */
    private final PartInfoService partInfoService;
    /**
     * 库位服务
     */
    private final LocationService locationService;
    /**
     * 任务记录服务
     */
    private final TaskRecordService taskRecordService;
    /**
     * 站台服务
     */
    private final StandService standService;
    /**
     * 载具服务
     */
    private final VehicleService vehicleService;
    /**
     * 请求头部信息
     */
    private final HttpServletRequest servletRequest;

    /**
     * 订单入库 Mapper
     */
    private final com.wms.mapper.AppOrderInMapper appOrderInMapper;
    /**
     * 库位 Mapper
     */
    private final LocationMapper locationMapper;
    /**
     * 创建入库任务（人工入库）
     *
     * @param taskInRequestEntityList 入库任务
     * @return 结果
     */
    @PostMapping("/sendGoodsInTask")
    @ResponseBody
    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
    public String receiveGoodsInTask(@RequestBody List<TaskInRequestEntity> taskInRequestEntityList) {
        logger.info("接收到入库任务：{}，ip地址：{}", JSON.toJSONString(taskInRequestEntityList), HttpUtils.getIpAddr(servletRequest));
        // 创建响应信息
        ResponseEntity rsp = new ResponseEntity();
        try {
            // 根据ip获得站台信息
            List<Stand> stands = standService.selStands(new Stand(2, HttpUtils.getIpAddr(servletRequest), 0));
            if (stands.size() < 1) {// 请求的地址不是站台电脑
                logger.error("请用站台电脑下发任务");
                // 返回错误
                rsp.setCode(ResponseCode.ERROR.getCode());
                rsp.setMessage("请用站台电脑下发任务");
                return JSON.toJSONString(rsp);
            }
            // 同一次请求为同一载具任务，为同一任务组
            String taskGroupId = WmsUtils.generateUUIDString();
            // 下一个库位
            Location nextLocation = new Location();
            // 当前载具
            String currentVehicleNo = taskInRequestEntityList.get(0).getVehicleNo();
            // 入库设备号
            int currentSelEquip = 0;
            // 查询当前载具库存信息
            Vehicle vehicleQuery = new Vehicle();
            vehicleQuery.setVehicleId(currentVehicleNo);
            List<Vehicle> existVehicles = vehicleService.selVehicles(vehicleQuery);
            if (existVehicles.size() > 0 && Objects.equals(existVehicles.get(0).getVehicleStatus(), VehicleStatus.ON.getCode())) {
                logger.error("载具{}已经在库存中，请勿重复入库！", currentVehicleNo);
                // 返回错误
                rsp.setCode(ResponseCode.ERROR.getCode());
                rsp.setMessage("该托盘已经在库存中，请勿重复入库！");
                return JSON.toJSONString(rsp);
            }
            Task taskQuery = new Task();
            taskQuery.setVehicleNo(currentVehicleNo);
            List<Task> sameVehicleTasks = taskService.selTasks(taskQuery);
            if (sameVehicleTasks.size() > 0) {
                logger.error("载具{}存在其他任务，请勿重复入库！", currentVehicleNo);
                // 返回错误
                rsp.setCode(ResponseCode.ERROR.getCode());
                rsp.setMessage("该载具存在其他任务，请勿重复入库！");
                return JSON.toJSONString(rsp);
            }
            if (existVehicles.size() > 0) {
                nextLocation = locationService.selLocations(new Location(existVehicles.get(0).getCurrentLocation())).get(0);
            }
            for (TaskInRequestEntity taskInRequestEntity : taskInRequestEntityList) {// 循环生成入库任务
                // 生成任务
                Task task_new = new Task();
                // 保存必要的物料信息
                task_new.setTaskId(WmsUtils.generateId("RK"));
                // 设置发送给WCS的任务信息
                task_new.setTaskType(TaskType.IN.getCode());
                task_new.setTaskStatus(WmsTaskStatus.NEW.getCode());
                task_new.setTaskGroup(taskGroupId);
                // 查找库位时过滤掉不可用堆垛机
                Stand standQuery1 = new Stand();
                standQuery1.setStandType(3);
                standQuery1.setIsLock(0);
                standQuery1.setStandStatus(0);
                List<Stand> availableEquips = standService.selStands(standQuery1);
                if (availableEquips.size() < 1) {// 没有可用堆垛机，请稍后重试
                    logger.error("当前库无可用堆垛机，请稍后重试！");
                    // 返回错误
                    rsp.setCode(ResponseCode.ERROR.getCode());
                    rsp.setMessage("当前库无可用堆垛机，请稍后重试！");
                    return JSON.toJSONString(rsp);
                }
                // 找到占用库位数量最少的堆垛机
                int occupyLocationsNum = 1000000;
                for (Stand availableEquip : availableEquips) {
                    Location locationQuery1 = new Location();
                    locationQuery1.setEquipmentId(availableEquip.getEquipmentId());
                    locationQuery1.setLocationStatus(LocationStatus.OCCUPY.getCode());
                    List<Location> locations1 = locationService.selLocations(locationQuery1);
                    if (locations1.size() < occupyLocationsNum) {// 当前最小
                        occupyLocationsNum = locations1.size();
                        currentSelEquip = availableEquip.getEquipmentId();
                    }
                }
                //查找到对应的入库站台
                Stand standQuery2 = new Stand();
                standQuery2.setAllowIn(1);
                standQuery2.setAllowOut(0);
                standQuery2.setEquipmentId(currentSelEquip);
                standQuery2.setIsLock(0);
                standQuery2.setStandStatus(0);
                standQuery2.setStandType(1);
                List<Stand> availableStands = standService.selStands(standQuery2);
                if (availableStands.size() < 1) {
                    logger.error("当前堆垛机无可用入库站台，请稍后重试！");
                    // 返回错误
                    rsp.setCode(ResponseCode.ERROR.getCode());
                    rsp.setMessage("当前堆垛机无可用入库站台，请稍后重试！");
                    return JSON.toJSONString(rsp);
                }
                task_new.setOrigin(availableStands.get(0).getStandId());
                // 查找下一个可用库位
                if (StringUtils.isEmpty(nextLocation.getLocationId())) {
                    List<Location> nextLocations = locationService.selNextLocation(new Location(currentSelEquip));
                    if (nextLocations.size() < 1) {
                        logger.error("入库错误：没有可用储存位");
                        rsp.setCode(ResponseCode.ERROR.getCode());
                        rsp.setMessage("入库错误：没有可用储存位");
                        return JSON.toJSONString(rsp);
                    }
                    nextLocation = nextLocations.get(0);
                }
                nextLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
                nextLocation.setVehicleId(taskInRequestEntity.getVehicleNo());
                task_new.setDestination(nextLocation.getLocationId());
                task_new.setWeight(taskInRequestEntity.getWeight() == null ? 0 : taskInRequestEntity.getWeight());
                task_new.setVehicleNo(taskInRequestEntity.getVehicleNo());
                task_new.setCreateTime(new Date());
                task_new.setUserName(taskInRequestEntity.getUserName());
                task_new.setGoodsId(taskInRequestEntity.getGoodsId());
                if (!taskInRequestEntity.getGoodsId().equals(WmsConstants.EMPTY_STOCK_GOODS_ID)) {
                    // 查询物料信息后设定
                    PartInfo partInfo = partInfoService.selPartByPartNo(taskInRequestEntity.getGoodsId());
                    task_new.setGoodsName(partInfo.getItemDesc());
                    if (Double.parseDouble(partInfo.getSLED()) > 0) {
                        task_new.setProductionDate(taskInRequestEntity.getProductionDate());
                        task_new.setExpirationDate(WmsUtils.calculationMonth(taskInRequestEntity.getProductionDate(), (int) (12 * Double.parseDouble(partInfo.getSLED()))));
                    }
                }
                task_new.setOperateNum(taskInRequestEntity.getGoodsNum());
                task_new.setTotalNum(0);
                task_new.setTaskPriority(1);
                // 插入入库任务
                taskService.addTask(task_new);
            }
            // 锁定库位
            locationService.modifyLocation(nextLocation);
            // 添加载具/更新载具
            if (existVehicles.size() == 0) {
                Vehicle newVehicle = new Vehicle();
                newVehicle.setVehicleId(currentVehicleNo);
                newVehicle.setVehicleStatus(VehicleStatus.IN.getCode());// 入库中
                newVehicle.setCurrentLocation(nextLocation.getLocationId());
                if (Objects.equals(taskInRequestEntityList.get(0).getIsEmpty(), "0")) {
                    newVehicle.setIsEmpty(1);
                } else {
                    newVehicle.setIsEmpty(0);
                }
                vehicleService.addVehicle(newVehicle);
            } else {
                Vehicle oldVehicle = existVehicles.get(0);
                oldVehicle.setVehicleStatus(VehicleStatus.IN.getCode());//
                oldVehicle.setCurrentLocation(nextLocation.getLocationId());
                if (Objects.equals(taskInRequestEntityList.get(0).getIsEmpty(), "0")) {
                    oldVehicle.setIsEmpty(1);
                } else {
                    oldVehicle.setIsEmpty(0);
                }
                vehicleService.modifyVehicle(oldVehicle);
            }
            // 返回成功
            rsp.setCode(ResponseCode.OK.getCode());
            rsp.setMessage("创建入库任务成功");
            return JSON.toJSONString(rsp);
        } catch (Exception e) {
            // 回滚事务
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            logger.error("发生异常：{}", e.getMessage());
            // 返回其他异常
            rsp.setCode(ResponseCode.ERROR.getCode());
            rsp.setMessage(e.getMessage());
            return JSON.toJSONString(rsp);
        }
    }

    /**
     * 出库---根据零件号出库
     * @param taskOutRequest 请求
     * @return 结果
     */
    @PostMapping("/sendGoodsOutTask")
    @ResponseBody
    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
    public String receiveGoodsOutTask(@RequestBody TaskOutRequestEntity taskOutRequest) {
        logger.info("接收到出库请求：{}，ip地址：{}", JSON.toJSONString(taskOutRequest), HttpUtils.getIpAddr(servletRequest));
        // 创建响应信息
        ResponseEntity rsp = new ResponseEntity();
        StringBuilder returnMessage = new StringBuilder();
        try {
            // 根据ip获得站台信息
            List<Stand> stands = standService.selStands(new Stand(2, HttpUtils.getIpAddr(servletRequest), 0));
            if (stands.size() < 1) {// 请求的地址不是站台电脑
                logger.error("请用站台电脑下发任务");
                // 返回错误
                rsp.setCode(ResponseCode.ERROR.getCode());
                rsp.setMessage("请用站台电脑下发任务");
                return JSON.toJSONString(rsp);
            }
            // 判断物料编号和数量有没有输入
            if (taskOutRequest== null || StringUtils.isEmpty(taskOutRequest.getGoodsId()) || taskOutRequest.getNeedNum() == null || taskOutRequest.getNeedNum() == 0) {
                logger.error("物料号和数量必须输入，请确认！");
                // 返回错误
                rsp.setCode(ResponseCode.ERROR.getCode());
                rsp.setMessage("物料号和数量必须输入，请确认！");
                return JSON.toJSONString(rsp);
            }
            // 查找库存
            Stock stockQuery = new Stock();
            stockQuery.setGoodsId(taskOutRequest.getGoodsId());
            stockQuery.setVehicleId(taskOutRequest.getVehicleNo());
            stockQuery.setStockStatus(StockStatus.OK.getCode());
            List<Stock> needStocks = stockService.selStocks(stockQuery);
            if (needStocks.size() == 0) {// 没有库存
                logger.error("选择的库存不存在，无法出库！");
                // 返回错误
                rsp.setCode(ResponseCode.ERROR.getCode());
                rsp.setMessage("选择的库存不存在，无法出库！");
                return JSON.toJSONString(rsp);
            }
            int needNum = taskOutRequest.getNeedNum();
            Location currentLocation;
            for (Stock needStock : needStocks) {
                if (needNum > 0 && needStock.getRemainNum() > 0) {// 还有需求数量
                    Task tempTask = new Task();
                    tempTask.setTaskId(WmsUtils.generateId("CK"));
                    tempTask.setTaskType(TaskType.OUT.getCode());
                    tempTask.setTaskStatus(WmsTaskStatus.NEW.getCode());
                    tempTask.setTaskGroup(WmsUtils.generateUUIDString());
                    tempTask.setTaskPriority(1);
                    tempTask.setPickStand(stands.get(0).getStandId());
                    tempTask.setVehicleNo(needStock.getVehicleId());
                    tempTask.setUserName(taskOutRequest.getUserName());
                    tempTask.setGoodsId(needStock.getGoodsId());
                    tempTask.setGoodsName(needStock.getGoodsName());
                    tempTask.setCreateTime(new Date());
                    tempTask.setProductionDate(needStock.getProductionDate());
                    tempTask.setExpirationDate(needStock.getExpirationDate());
                    tempTask.setTotalNum(needStock.getRealNum());
                    tempTask.setOrigin(needStock.getLocationId());
                    //查找到对应的出库
                    currentLocation = locationService.selLocations(new Location(needStock.getLocationId())).get(0);
                    Stand standQuery2 = new Stand();
                    standQuery2.setAllowIn(0);
                    standQuery2.setAllowOut(1);
                    standQuery2.setEquipmentId(currentLocation.getEquipmentId());
                    standQuery2.setIsLock(0);
                    standQuery2.setStandStatus(0);
                    standQuery2.setStandType(1);
                    List<Stand> availableStands = standService.selStands(standQuery2);
                    if (availableStands.size() < 1) {
                        logger.error("当前库存的出库站台不可用！");
                        // 返回错误信息
                        returnMessage.append("当前库存所在载具").append(currentLocation.getVehicleId()).append("的出库站台不可用！\n");
                    }
                    tempTask.setDestination(availableStands.get(0).getStandId());
                    if (needNum <= needStock.getRemainNum()) {// 数量足够
                        tempTask.setOperateNum(needNum);
                        needNum = 0;
                        needStock.setRemainNum(needStock.getRemainNum() - needNum);
                    } else {
                        tempTask.setOperateNum(needStock.getRemainNum());
                        needNum -= needStock.getRemainNum();
                        needStock.setRemainNum(0);
                    }
                    // 添加任务
                    taskService.addTask(tempTask);
                    logger.info("添加任务成功，{}", JSON.toJSONString(tempTask));
                    // 更新库存
                    needStock.setStockStatus(StockStatus.OUT.getCode());
                    stockService.modifyStock(needStock);
                    logger.info("更新库存信息成功，{}", JSON.toJSONString(needStock));
                    // 更新载具信息
                    Vehicle currentVehicle = vehicleService.selVehicleById(needStock.getVehicleId());
                    if (currentVehicle == null) {
                        currentVehicle = new Vehicle();
                        currentVehicle.setVehicleId(needStock.getVehicleId());
                        currentVehicle.setIsEmpty(0);
                        currentVehicle.setCurrentLocation(needStock.getLocationId());
                        currentVehicle.setVehicleStatus(VehicleStatus.OUT.getCode());
                        vehicleService.addVehicle(currentVehicle);
                    } else {
                        currentVehicle.setVehicleStatus(VehicleStatus.OUT.getCode());
                        vehicleService.modifyVehicle(currentVehicle);
                    }
                    logger.info("更新载具信息，{}", JSON.toJSONString(currentVehicle));
                    // 将当前载具的其他库存也设置为相同状态
                    Stock stockQuery2 = new Stock();
                    stockQuery2.setVehicleId(needStock.getVehicleId());
                    List<Stock> sameVehicleStocks = stockService.selStocks(stockQuery2);
                    for (Stock sameVehicleStock : sameVehicleStocks) {
                        if (!Objects.equals(sameVehicleStock.getStockId(), needStock.getStockId())) {
                            sameVehicleStock.setStockStatus(StockStatus.OUT.getCode());
                            stockService.modifyStock(sameVehicleStock);
                        }
                    }
                    logger.info("更新载具中其他库存信息，{}", needStock.getVehicleId());
                }
            }
            if (needNum > 0) {// 库存不足的情况下
                returnMessage.append("当前可用数量不足，已将能够出库的库存出库。\n");
            }
            logger.info("下发出库任务成功");
            rsp.setCode(ResponseCode.OK.getCode());
            rsp.setMessage(String.valueOf(returnMessage));
            return JSON.toJSONString(rsp);
        } catch (Exception e) {
            // 回滚事务
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            logger.error("创建出库任务发生异常：{}", e.getMessage());
            // 返回其他异常
            rsp.setCode(ResponseCode.ERROR.getCode());
            rsp.setMessage(e.getMessage());
            return JSON.toJSONString(rsp);
        }
    }

    /**
     * 出库---根据料箱号出
     * @param taskOutRequest 请求
     * @return 结果
     */
    @PostMapping("/vehicleOut")
    @ResponseBody
    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
    public String selectVehicleOut(@RequestBody TaskOutRequestEntity taskOutRequest) {
        logger.info("接收到出箱请求：{}，ip地址：{}", JSON.toJSONString(taskOutRequest), HttpUtils.getIpAddr(servletRequest));
        // 创建响应信息
        ResponseEntity rsp = new ResponseEntity();
        try {
            // 根据ip获得站台信息
            List<Stand> stands = standService.selStands(new Stand(2, HttpUtils.getIpAddr(servletRequest), 0));
            if (stands.size() < 1) {// 请求的地址不是站台电脑
                logger.error("请用站台电脑下发任务");
                // 返回错误
                rsp.setCode(ResponseCode.ERROR.getCode());
                rsp.setMessage("请用站台电脑下发任务");
                return JSON.toJSONString(rsp);
            }
            // 判断物料编号和数量有没有输入
            if (taskOutRequest== null || StringUtils.isEmpty(taskOutRequest.getVehicleNo())) {
                logger.error("箱号必须输入，请确认！");
                // 返回错误
                rsp.setCode(ResponseCode.ERROR.getCode());
                rsp.setMessage("箱号必须输入，请确认！");
                return JSON.toJSONString(rsp);
            }
            Vehicle vehicle = vehicleService.selVehicleById(taskOutRequest.getVehicleNo());
            if (vehicle == null || !Objects.equals(vehicle.getVehicleStatus(), VehicleStatus.ON.getCode())) {
                logger.error("当前箱子不可用，请确认！");
                // 返回错误
                rsp.setCode(ResponseCode.ERROR.getCode());
                rsp.setMessage("当前箱子不可用，请确认！");
                return JSON.toJSONString(rsp);
            }
            int needNum = taskOutRequest.getNeedNum();
            // 生成任务
            Task tempTask = new Task();
            tempTask.setVehicleNo(taskOutRequest.getVehicleNo());
            tempTask.setTaskId(WmsUtils.generateId("RKCK"));
            tempTask.setTaskGroup(WmsUtils.generateUUIDString());
            tempTask.setTaskStatus(WmsTaskStatus.NEW.getCode());
            tempTask.setTaskType(TaskType.OUT.getCode());
            tempTask.setOperateNum(0);
            tempTask.setCreateTime(new Date());
            tempTask.setGoodsId(WmsConstants.EMPTY_STOCK_GOODS_ID);
            tempTask.setUserName(taskOutRequest.getUserName());
            tempTask.setPickStand(stands.get(0).getStandId());
            tempTask.setTaskPriority(1);
            tempTask.setWeight((double) 0);
            tempTask.setOrigin(vehicle.getCurrentLocation());
            //查找到对应的出库站台
            Location currentLocation = locationService.selLocations(new Location(vehicle.getCurrentLocation())).get(0);
            Stand standQuery2 = new Stand();
            standQuery2.setAllowIn(0);
            standQuery2.setAllowOut(1);
            standQuery2.setEquipmentId(currentLocation.getEquipmentId());
            standQuery2.setIsLock(0);
            standQuery2.setStandStatus(0);
            standQuery2.setStandType(1);
            List<Stand> availableStands = standService.selStands(standQuery2);
            if (availableStands.size() < 1) {
                logger.error("当前箱子的出库站台不可用！");
                // 返回错误
                rsp.setCode(ResponseCode.ERROR.getCode());
                rsp.setMessage("当前箱子的出库站台不可用！");
                return JSON.toJSONString(rsp);
            }
            tempTask.setDestination(availableStands.get(0).getStandId());
            taskService.addTask(tempTask);
            logger.info("下发出箱任务成功");
            // 更新料箱状态
            vehicle.setVehicleStatus(VehicleStatus.OUT.getCode());
            vehicleService.modifyVehicle(vehicle);
            logger.info("更新料箱状态成功");
            // 该箱子上的库存状态变更
            Stock stockQuery = new Stock();
            stockQuery.setVehicleId(taskOutRequest.getVehicleNo());
            List<Stock> stocks = stockService.selStocks(stockQuery);
            for (Stock tempStock : stocks) {
                if (needNum <= 0){
                    break;
                }
                tempStock.setStockStatus(StockStatus.OUT.getCode());
                needNum =  needNum - tempStock.getRealNum();
                stockService.modifyStock(tempStock);
            }
//            for (Stock tempStock : stocks){
//                if (!Objects.equals(tempStock.getStockStatus(), StockStatus.OUT.getCode())){
//                    //生成回库任务
//                    String vehicleNo = taskOutRequest.getVehicleNo(); // 载具号
//                    /* 查找一个空库位 */
//                    Location emptyLocation = new Location();
//                    emptyLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
//                    emptyLocation.setAreaId(1);
//                    List<Location> emptyLocations = locationMapper.selLocations(emptyLocation);
//                    if(emptyLocations == null) {
//                        rsp.setCode(ResponseCode.ERROR.getCode());
//                        rsp.setMessage("库位查找失败，网络连接异常，请稍后再试");
//                        return JSON.toJSONString(rsp);
//                    }
//                    if(emptyLocations.isEmpty()){
//                        rsp.setCode(ResponseCode.ERROR.getCode());
//                        rsp.setMessage("没有可用库位");
//                        return JSON.toJSONString(rsp);
//                    }
//                    Location emptyLocationItem = locationUtils.checkCanUse(emptyLocations);
//                    if(emptyLocationItem == null) {
//                        rsp.setCode(ResponseCode.ERROR.getCode());
//                        rsp.setMessage("没有可用库位或者库位存在干涉，请稍后再试");
//                        return JSON.toJSONString(rsp);
//                    }
//                    // 该空库位可用，生成一个入库任务，并将库存表更新库位
//                    // 更新库位表，占掉库位
//                    Location updateLocation = new Location();
//                    updateLocation.setLocationId(emptyLocationItem.getLocationId());
//                    updateLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
//                    updateLocation.setVehicleId(taskOutRequest.getVehicleNo());
//                    locationMapper.modifyLocation(updateLocation); // 占掉库位
//                    // ---- 更新库存中库位
//                    stockMapper.updateLocationIdWithBetchNo(taskOutRequest.getVehicleNo(), emptyLocationItem.getLocationId()); // 绑定载具和库位
//                    // 更新入库单
//                    appOrderInMapper.updateStatusWithVehicleNo(vehicleNo, OrderInStatusEnum.IN.getCode()); // 更新入库单为入库中
//                    // 添加入库任务
//                    Task task = new Task();
//                    task.setTaskId(UUID.randomUUID().toString());
//                    task.setTaskType(TaskType.IN.getCode());
//                    task.setTaskStatus(WmsTaskStatus.NEW.getCode());
//                    task.setTaskGroup(UUID.randomUUID().toString());
//                    task.setOrigin(tempTask.getDestination());
//                    task.setDestination(emptyLocationItem.getLocationId());
//                    task.setPickStand("");
//                    task.setWeight(0.0);
//                    task.setVehicleNo(taskOutRequest.getVehicleNo());
//                    task.setCreateTime(new Date());
//                    task.setUserName("wcs");
//                    task.setGoodsId(vehicleNo);
//                    task.setGoodsName("");
//                    task.setOperateNum(0);
//                    task.setTotalNum(0);
//                    task.setTaskPriority(1);
//                    int addTask = taskMapper.addTask(task);
//                    if(addTask > 0) {
//                        rsp.setCode(ResponseCode.ERROR.getCode());
//                        rsp.setMessage("存在入库任务，申请成功！");
//                        return JSON.toJSONString(rsp);
//                    }
//                    rsp.setCode(ResponseCode.ERROR.getCode());
//                    rsp.setMessage("添加入库任务失败，网络连接异常，请稍后再试");
//                    return JSON.toJSONString(rsp);
//                }
//            }
            logger.info("更新库存状态成功");
            logger.info("下发出库任务成功");
            rsp.setCode(ResponseCode.OK.getCode());
            rsp.setMessage("箱号" + taskOutRequest.getVehicleNo() + "生成出库任务成功");
            return JSON.toJSONString(rsp);
        } catch (Exception e) {
            // 回滚事务
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            logger.error("创建出库任务发生异常：{}", e.getMessage());
            // 返回其他异常
            rsp.setCode(ResponseCode.ERROR.getCode());
            rsp.setMessage(e.getMessage());
            return JSON.toJSONString(rsp);
        }
    }

    /**
     * 盘点出库
     *
     * @param request 请求
     * @return 结果
     */
    @PostMapping("/sendInventoryTask")
    @ResponseBody
    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
    public String sendInventoryTask(@RequestBody InventoryTask request) {
        // TODO 盘点优化
        logger.info("接收到盘库请求：{}，ip地址：{}", JSON.toJSONString(request), HttpUtils.getIpAddr(servletRequest));
        ResponseEntity rsp = new ResponseEntity();
        try {
            // 根据ip获得站台信息
            List<Stand> stands = standService.selStands(new Stand(2, HttpUtils.getIpAddr(servletRequest), 0));
            if (stands.size() < 1) {// 请求的地址不是站台电脑
                logger.error("请用站台电脑下发盘库任务");
                // 返回错误
                rsp.setCode(ResponseCode.ERROR.getCode());
                rsp.setMessage("请用站台电脑下发盘库任务");
                return JSON.toJSONString(rsp);
            }
            // 判断零件号是否输入
            if (StringUtils.isEmpty(request.getGoodsId())) {
                logger.error("未选择盘点零件");
                // 返回错误
                rsp.setCode(ResponseCode.ERROR.getCode());
                rsp.setMessage("请选择盘点零件");
                return JSON.toJSONString(rsp);
            }
            // 判断当前零件是否有其他任务
            Task taskQuery2 = new Task();
            taskQuery2.setGoodsId(request.getGoodsId());
            taskQuery2.setVehicleNo(request.getVehicleId());
            List<Task> sameGoodsTasks = taskService.selTasks(taskQuery2);
            if (sameGoodsTasks.size() > 0) {
                logger.error("当前零件存在其他任务");
                // 返回错误
                rsp.setCode(ResponseCode.ERROR.getCode());
                rsp.setMessage("当前零件存在其他任务，请勿执行盘点");
                return JSON.toJSONString(rsp);
            }
            // 判断库存中是否有此物料
            Stock stockQuery1 = new Stock();
            stockQuery1.setGoodsId(request.getGoodsId());
            stockQuery1.setVehicleId(request.getVehicleId());
            stockQuery1.setStockStatus(StockStatus.OK.getCode());
            List<Stock> detailStocks = stockService.selStocks(stockQuery1);
            List<Stock> summaryStocks = stockService.selStocksByGoodsId(stockQuery1);
            if (detailStocks.size() == 0) {// 当前零件无库存
                logger.error("当前零件无库存");
                // 返回错误
                rsp.setCode(ResponseCode.ERROR.getCode());
                rsp.setMessage("当前零件无库存");
                return JSON.toJSONString(rsp);
            }
            if (summaryStocks.size() == 0) {
                logger.error("当前零件无库存");
                // 返回错误
                rsp.setCode(ResponseCode.ERROR.getCode());
                rsp.setMessage("当前零件无库存");
                return JSON.toJSONString(rsp);
            }
            for (Stock tempDetailStock : detailStocks) {
                // 根据库存生成任务
                // 生成出库任务
                Task task = new Task();
                // 任务编号
                task.setTaskId(WmsUtils.generateId("PDCK"));
                //task.setTaskId(UUID);
                // 任务类型
                task.setTaskType(TaskType.INVENTORY.getCode());
                // 起点
                task.setOrigin(tempDetailStock.getLocationId());
                // 查找对应库位对应的站台
                Location locationQuery = new Location();
                locationQuery.setLocationId(tempDetailStock.getLocationId());
                Location currentLocation = locationService.selLocations(locationQuery).get(0);
                Stand standQuery = new Stand();
                standQuery.setEquipmentId(currentLocation.getEquipmentId());
                standQuery.setAllowIn(0);
                standQuery.setAllowOut(1);
                standQuery.setStandType(1);
                Stand targetStand = standService.selStands(standQuery).get(0);
                task.setDestination(targetStand.getStandId());
                task.setPickStand(stands.get(0).getStandId());
                // 重量
                // 查找零件数据，然后计算重量
                PartInfo partInfo = partInfoService.selPartByPartNo(tempDetailStock.getGoodsId());
                task.setWeight(partInfo.getPartWeight() * tempDetailStock.getRealNum());// 重量
                // 载具编号
                task.setVehicleNo(tempDetailStock.getVehicleId());
                // 尺寸
                task.setVehicleSize(1);
                task.setCreateTime(new Date());
                // 用户名
                task.setUserName(request.getUserName());
                task.setGoodsId(tempDetailStock.getGoodsId());
                task.setGoodsName(tempDetailStock.getGoodsName());
                task.setProductionDate(tempDetailStock.getProductionDate());
                task.setExpirationDate(tempDetailStock.getExpirationDate());
                task.setOperateNum(0);
                task.setTotalNum(tempDetailStock.getRealNum());
                task.setTaskPriority(2);

                tempDetailStock.setIsInventory(1);
                tempDetailStock.setInventoryTaskId(task.getTaskId());
                task.setTaskStatus(WmsTaskStatus.NEW.getCode());// 新建出库任务
                task.setTaskGroup(WmsUtils.generateUUIDString());// group
                taskService.addTask(task);
                // 将库存设定为盘点出库状态
                tempDetailStock.setStockStatus(StockStatus.OUT.getCode());
                stockService.modifyStock(tempDetailStock);
                // 将这个托盘上的其他库存都设定为盘点出库状态
                List<Stock> sameVehicleStock = stockService.selStocks(new Stock(tempDetailStock.getVehicleId()));
                for (Stock tempStock : sameVehicleStock) {
                    if (Objects.equals(tempStock.getStockId(), tempDetailStock.getStockId())) {
                        continue;
                    }
                    tempStock.setStockStatus(StockStatus.OUT.getCode());
                    stockService.modifyStock(tempStock);
                }
                // 将当前的载具设置为出库中
                Vehicle currentVehicle = vehicleService.selVehicleById(tempDetailStock.getVehicleId());
                currentVehicle.setVehicleStatus(VehicleStatus.OUT.getCode());
                vehicleService.modifyVehicle(currentVehicle);
            }

            logger.info("创建盘点任务成功，零件号：{}", request.getGoodsId());
            // 返回成功
            rsp.setCode(ResponseCode.OK.getCode());
            rsp.setMessage("创建盘库任务成功");
            rsp.setReturnData(summaryStocks.size() > 0 ? summaryStocks.get(0) : new Stock());
            return JSON.toJSONString(rsp);
        } catch (Exception e) {
            // 回滚事务
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            logger.error("创建盘库任务发生异常：{}", e.getMessage());
            // 返回其他异常
            rsp.setCode(ResponseCode.ERROR.getCode());
            rsp.setMessage(e.getMessage());
            return JSON.toJSONString(rsp);
        }
    }

    /**
     * 接收WCS发送的任务结果
     *
     * @param wmsReceiveTaskResultEntity 请求
     * @return 响应结果
     */
    @PostMapping("/sendTaskResult")
    @ResponseBody
    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
    public String receiveTaskResult(@RequestBody WmsReceiveTaskResultEntity wmsReceiveTaskResultEntity) {
        logger.info("接收到任务反馈：{}，ip地址：{}", wmsReceiveTaskResultEntity.toLoggerString(), HttpUtils.getIpAddr(servletRequest));
        // 创建响应信息
        ResponseEntity rsp = new ResponseEntity();
        try {
            // 获取任务号
            String taskId = wmsReceiveTaskResultEntity.getTaskId();
            Integer result = wmsReceiveTaskResultEntity.getTaskStatus();
            String vehicleNo = wmsReceiveTaskResultEntity.getVehicleNo();
            // 查找对应任务
            Task taskForQuery = new Task();
            taskForQuery.setTaskGroup(taskId);
            List<Task> tasks = taskService.selTasks(taskForQuery);
            if (tasks.size() < 1) {
                logger.error("任务号不正确");
                // 返回失败
                rsp.setCode(ResponseCode.ERROR.getCode());
                rsp.setMessage("任务号不正确");
                return JSON.toJSONString(rsp);
            }
            // 设定任务类型
            Integer taskType = tasks.get(0).getTaskType();
            if (result.compareTo(WcsTaskStatus.FINISH.getCode()) == 0) {// 任务完成
                // 回原库位
                if (taskType.compareTo(TaskType.IN.getCode()) == 0) {// 入库任务
                    logger.info("入库任务完成，开始处理");
                    // 更新载具信息
                    Vehicle currentVehicle = vehicleService.selVehicleById(vehicleNo);
                    currentVehicle.setVehicleStatus(2);// 在库中
                    currentVehicle.setCurrentLocation(wmsReceiveTaskResultEntity.getDestination());
                    vehicleService.modifyVehicle(currentVehicle);
                    // 添加库存
                    for (Task task : tasks) {
                        if (!Objects.equals(task.getTaskType(), TaskType.IN.getCode())) {
                            continue;
                        }
                        if (task.getTaskId().startsWith("HK")) {// 回库的库存
                            // 查询是不是回库的库存
                            Stock stockQuery1 = new Stock();
                            stockQuery1.setVehicleId(vehicleNo);
                            stockQuery1.setGoodsId(task.getGoodsId());
                            List<Stock> backStocks = stockService.selStocks(stockQuery1);
                            for (Stock tempBackStock : backStocks) {
                                tempBackStock.setLocationId(task.getDestination());
                                tempBackStock.setStockStatus(StockStatus.OK.getCode());
                                tempBackStock.setLastUpdateTime(new Date());
                                stockService.modifyStock(tempBackStock);
                                logger.info("更新回库库存");
                            }
                        } else if (task.getTaskId().startsWith("RK")) {// 新增库存
                            if (!task.getGoodsId().equals(WmsConstants.EMPTY_STOCK_GOODS_ID)) {// 空箱入库的情况下不生成库存
                                Stock exsitStockQuery = new Stock();
                                exsitStockQuery.setVehicleId(vehicleNo);
                                exsitStockQuery.setGoodsId(task.getGoodsId());
                                List<Stock> exsitStocks = stockService.selStocks(exsitStockQuery);
                                if (exsitStocks.size() > 0) {// 说明该箱子上已有该零件
                                    // 直接添加数量
                                    Stock exsitStock = exsitStocks.get(0);
                                    exsitStock.setRemainNum(exsitStock.getRemainNum() + task.getOperateNum());
                                    exsitStock.setRealNum(exsitStock.getRealNum() + task.getOperateNum());
                                    exsitStock.setStockStatus(StockStatus.OK.getCode());
                                    exsitStock.setLocationId(task.getDestination());
                                    stockService.modifyStock(exsitStock);
                                    logger.info("已有库存增加数量成功：{}", JSON.toJSONString(exsitStock));
                                } else {
                                    Stock stockTemp = new Stock();
                                    stockTemp.setStockId(WmsUtils.generateId("ST"));
                                    stockTemp.setLocationId(task.getDestination());
                                    stockTemp.setVehicleId(vehicleNo);
                                    stockTemp.setGoodsId(task.getGoodsId());
                                    // 查询物料信息后设定
                                    PartInfo partInfo = partInfoService.selPartByPartNo(task.getGoodsId());
                                    stockTemp.setGoodsName(partInfo.getItemDesc());
                                    if (Double.parseDouble(partInfo.getSLED()) > 0) {
                                        stockTemp.setProductionDate(task.getProductionDate());
                                        stockTemp.setShelfLife(Double.parseDouble(partInfo.getSLED()));
                                        stockTemp.setExpirationDate(task.getExpirationDate());
                                    }
                                    stockTemp.setAvailableNum(task.getOperateNum());
                                    stockTemp.setRemainNum(task.getOperateNum());
                                    stockTemp.setRealNum(task.getOperateNum());
                                    stockTemp.setProviderId(partInfo.getVendorId());
                                    stockTemp.setProviderName(partInfo.getVendorNameCN());
                                    stockTemp.setStockStatus(StockStatus.OK.getCode());
                                    stockTemp.setGoodsStatus(GoodsStatus.OK.getCode());
                                    stockTemp.setCreateTime(new Date());
                                    stockTemp.setLastUpdateTime(new Date());
                                    stockTemp.setIsInventory(0);
                                    stockTemp.setCurrentLocation(task.getDestination());
                                    logger.info("生成新库存：{}", JSON.toJSONString(stockTemp));
                                    stockService.addStock(stockTemp);
                                }
                            }
                        }
                        // 查看当前料箱上还有没有其他料
                        logger.info("更新料箱上其他库存");
                        Stock stockQuery3 = new Stock();
                        stockQuery3.setVehicleId(vehicleNo);
                        List<Stock> backStocks3 = stockService.selStocks(stockQuery3);
                        for (Stock tempBackStock3 : backStocks3) {
                            if (Objects.equals(tempBackStock3.getGoodsId(), task.getGoodsId())) {
                                continue;
                            }
                            if (tempBackStock3.getRealNum() <= 0) {// 无库存
                                stockService.deleteStock(tempBackStock3.getStockId());
                            } else {
                                tempBackStock3.setLocationId(task.getDestination());
                                tempBackStock3.setStockStatus(StockStatus.OK.getCode());
                                stockService.modifyStock(tempBackStock3);
                            }
                        }
                    }
                    // 对完成的入库任务进行处理
                    for (Task task : tasks) {
                        // 入库任务完成，先添加任务记录，然后删除任务。
                        task.setTaskStatus(WmsTaskStatus.FINISH.getCode());
                        task.setFinishTime(new Date());
                        taskRecordService.addTask(task);
                        taskService.deleteTask(task.getTaskId());
                    }
                } else if (taskType.compareTo(TaskType.OUT.getCode()) == 0) {// 出库任务
                    logger.info("出库任务完成，开始处理");
                    // 更改载具位置为站台
                    Vehicle vehicle = vehicleService.selVehicleById(vehicleNo);
                    vehicleService.modifyVehicle(vehicle);
                    // 更新库存当前位置----根据载具号查询到库存，该载具上的所有库存做统一处理。
                    Stock stockQueryParam1 = new Stock();
                    stockQueryParam1.setVehicleId(vehicleNo);
                    List<Stock> tempStockList1 = stockService.selStocks(stockQueryParam1);
                    for (Stock temp : tempStockList1) {
                        temp.setStockStatus(StockStatus.TRANS.getCode());
                        temp.setCurrentLocation(wmsReceiveTaskResultEntity.getDestination());
                        temp.setLastUpdateTime(new Date());
                        stockService.modifyStock(temp);
                    }
                    for (Task task : tasks) {
                        if (!Objects.equals(task.getTaskType(), TaskType.OUT.getCode())) {
                            continue;
                        }
                        if (task.getGoodsId().equals(WmsConstants.EMPTY_STOCK_GOODS_ID)) {
                            task.setTaskStatus(WmsTaskStatus.FINISH.getCode());// 出库完成状态
                            task.setFinishTime(new Date());
                            taskRecordService.addTask(task);
                            taskService.deleteTask(task.getTaskId());
                        } else {
                            task.setTaskStatus(WmsTaskStatus.OUT_SUCCESS.getCode());// 出库完成状态
                            taskService.executeTask(task);
                        }
                    }
                } else if (taskType.compareTo(TaskType.INVENTORY.getCode()) == 0) {// 盘点任务
                    logger.info("盘点任务完成，开始处理");
                    // 更改载具位置为站台
                    Vehicle vehicle = vehicleService.selVehicleById(vehicleNo);
                    vehicleService.modifyVehicle(vehicle);
                    // 更新库存当前位置----根据载具号查询到库存，该载具上的所有库存做统一处理。
                    Stock stockQueryParam1 = new Stock();
                    stockQueryParam1.setVehicleId(vehicleNo);
                    List<Stock> tempStockList1 = stockService.selStocks(stockQueryParam1);
                    for (Stock temp : tempStockList1) {
                        temp.setStockStatus(StockStatus.TRANS.getCode());
                        temp.setCurrentLocation(wmsReceiveTaskResultEntity.getDestination());
                        temp.setLastUpdateTime(new Date());
                        stockService.modifyStock(temp);
                    }
                    for (Task task : tasks) {
                        if (!Objects.equals(task.getTaskType(), TaskType.INVENTORY.getCode())) {
                            continue;
                        }
                        task.setTaskStatus(WmsTaskStatus.OUT_SUCCESS.getCode());// 出库完成状态
                        taskService.executeTask(task);
                    }
                }
            } else if (result.compareTo(WcsTaskStatus.RUN.getCode()) == 0) {// 任务开始执行
                logger.info("任务开始执行");
                for (Task task : tasks) {
                    task.setTaskStatus(WmsTaskStatus.RUN.getCode());// 任务开始执行
                    taskService.executeTask(task);
                }
            } else if (result.compareTo(WcsTaskStatus.EXCEPTION.getCode()) == 0) {// 任务开始执行
                logger.info("任务发生异常");
                for (Task task : tasks) {
                    task.setTaskStatus(WmsTaskStatus.EXCEPTION.getCode());// 任务开始执行
                    taskService.executeTask(task);
                }
            } else if (result.compareTo(WcsTaskStatus.CANCEL.getCode()) == 0) {
                if (taskType.compareTo(TaskType.IN.getCode()) == 0) {// 入库任务取消
                    logger.info("入库任务取消，开始处理");
                    for (Task tempInTask : tasks) {
                        if (tempInTask.getTaskId().startsWith("HK")) {// 回库任务，需要删除库存
                            Stock stockQueryParam1 = new Stock();
                            stockQueryParam1.setVehicleId(vehicleNo);
                            stockQueryParam1.setGoodsId(tempInTask.getGoodsId());
                            List<Stock> tempStockList1 = stockService.selStocks(stockQueryParam1);
                            for (Stock temp : tempStockList1) {
                                stockService.deleteStock(temp.getStockId());
                            }
                        }
                    }
                } else if (taskType.compareTo(TaskType.OUT.getCode()) == 0) {// 出库任务取消
                    logger.info("出库任务取消，开始处理");
                    // 更改载具位置为站台
                    logger.info("更新载具为在库中");
                    Vehicle vehicle = vehicleService.selVehicleById(vehicleNo);
                    vehicle.setVehicleStatus(VehicleStatus.ON.getCode());
                    vehicleService.modifyVehicle(vehicle);
                    // 更新库存当前位置----根据载具号查询到库存，该载具上的所有库存做统一处理。
                    logger.info("更新库存为正常状态");
                    Stock stockQueryParam1 = new Stock();
                    stockQueryParam1.setVehicleId(vehicleNo);
                    List<Stock> tempStockList1 = stockService.selStocks(stockQueryParam1);
                    for (Stock temp : tempStockList1) {
                        temp.setStockStatus(StockStatus.OK.getCode());
                        stockService.modifyStock(temp);
                    }
                } else if (taskType.compareTo(TaskType.INVENTORY.getCode()) == 0) {// 盘点任务取消
                    logger.info("盘点任务取消，开始处理");
                    // 更改载具位置为站台
                    logger.info("更新载具为在库中");
                    Vehicle vehicle = vehicleService.selVehicleById(vehicleNo);
                    vehicle.setVehicleStatus(VehicleStatus.ON.getCode());
                    vehicleService.modifyVehicle(vehicle);
                    // 更新库存当前位置----根据载具号查询到库存，该载具上的所有库存做统一处理。
                    logger.info("更新库存为正常状态");
                    Stock stockQueryParam1 = new Stock();
                    stockQueryParam1.setVehicleId(vehicleNo);
                    List<Stock> tempStockList1 = stockService.selStocks(stockQueryParam1);
                    for (Stock temp : tempStockList1) {
                        temp.setStockStatus(StockStatus.OK.getCode());
                        stockService.modifyStock(temp);
                    }
                }
                // 更新任务状态
                logger.info("删除取消的任务，并添加任务记录");
                for (Task task : tasks) {
                    task.setTaskStatus(WmsTaskStatus.CANCEL.getCode());// 任务开始执行
                    task.setFinishTime(new Date());
                    taskService.deleteTask(task.getTaskId());
                    taskRecordService.addTask(task);
                }
            }
        } catch (Exception e) {
            // 回滚事务
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            logger.error("发生异常");
            // 返回失败
            rsp.setCode(ResponseCode.ERROR.getCode());
            rsp.setMessage("发生异常，请尝试重新发送一次");
            return JSON.toJSONString(rsp);
        }
        logger.info("获取任务反馈处理成功");
        // 返回失败
        rsp.setCode(ResponseCode.OK.getCode());
        rsp.setMessage("任务处理成功");
        return JSON.toJSONString(rsp);
    }

    /**
     * WCS向WMS上报箱子到达拣货口
     * @param pickTask 拣选任务
     * @return 结果
     */
    @PostMapping("/boxArrive")
    @ResponseBody
    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
    public String boxArrive(@RequestBody PickTaskResponse pickTask) {
        logger.info("接收到WCS向WMS上报箱子到达拣货点：{}", JSON.toJSONString(pickTask));
        ResponseEntity response = new ResponseEntity();
        try {
            // 根据载具号加拣选点位找到对应的任务----出库任务/盘点任务
            Task taskQueryParam1 = new Task();
            taskQueryParam1.setVehicleNo(pickTask.getVehicleNo());
            taskQueryParam1.setTaskStatus(WmsTaskStatus.OUT_SUCCESS.getCode());
            List<Task> tasks = taskService.selTasks(taskQueryParam1);
            if (tasks.size() < 1) {
                logger.error("当前反馈的箱号{}不存在可以操作的任务", pickTask.getVehicleNo());
                // 返回失败
                response.setCode(ResponseCode.ERROR.getCode());
                response.setMessage("当前反馈的箱号没有对应的任务");
                return JSON.toJSONString(response);
            }
            // 更新当前载具的当前位置为拣选站台
            Vehicle vehicle = vehicleService.selVehicleById(pickTask.getVehicleNo());
            if (vehicle == null) {
                logger.error("没查询到对应载具{}", pickTask.getVehicleNo());
                // 返回失败
                response.setCode(ResponseCode.ERROR.getCode());
                response.setMessage("没查询到对应载具信息");
                return JSON.toJSONString(response);
            }
            vehicleService.modifyVehicle(vehicle);
            // 更新库存位置
            Stock stockQueryParam1 = new Stock();
            stockQueryParam1.setVehicleId(pickTask.getVehicleNo());
            List<Stock> stocks = stockService.selStocks(stockQueryParam1);
            if (stocks.size() < 1) {
                logger.error("载具{}没查询到对应库存", pickTask.getVehicleNo());
                // 返回失败
                response.setCode(ResponseCode.ERROR.getCode());
                response.setMessage("反馈的载具没查询到对应库存");
                return JSON.toJSONString(response);
            }
            for (Stock tempStock : stocks) {
                tempStock.setStockStatus(StockStatus.PICKING.getCode());
                tempStock.setCurrentLocation(pickTask.getPickStand());
                stockService.modifyStock(tempStock);
            }
            // 更新任务状态
            for (Task tempTaskForPicking : tasks) {
                if (Objects.equals(tempTaskForPicking.getTaskType(), TaskType.OUT.getCode())) {
                        // 更新任务状态
                        tempTaskForPicking.setTaskStatus(WmsTaskStatus.PICKING.getCode());
                        taskService.executeTask(tempTaskForPicking);
                } else if (Objects.equals(tempTaskForPicking.getTaskType(), TaskType.INVENTORY.getCode())) {// 盘点出库
                    // 更新任务状态
                    tempTaskForPicking.setTaskStatus(WmsTaskStatus.INVENTORY.getCode());
                    taskService.executeTask(tempTaskForPicking);
                }
            }
        } catch (Exception e) {
            // 回滚事务
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            logger.error("发生异常：{}", e.getMessage());
            response.setCode(ResponseCode.ERROR.getCode());
            response.setMessage("发生异常");
            return JSON.toJSONString(response);
        }
        logger.info("处理成功");
        response.setCode(ResponseCode.OK.getCode());
        response.setMessage("成功");
        return JSON.toJSONString(response);
    }

    /**
     * 当前箱子请求回库
     *
     * @param request 请求
     * @return 结果
     */
    @PostMapping("/finishPicking")
    @ResponseBody
    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
    public String finishPicking(@RequestBody FinishPickTaskRequest request) {
        logger.info("确认拣货完成：{}", JSON.toJSONString(request));
        ResponseEntity response = new ResponseEntity();
        try {
            if (StringUtils.isEmpty(request.getTaskId())) {//
                logger.error("任务号为空");
                response.setCode(ResponseCode.ERROR.getCode());
                response.setMessage("任务号为空");
                return JSON.toJSONString(response);
            }
            // 将当前任务信息更新
            Task taskQuery1 = new Task();
            taskQuery1.setTaskId(request.getTaskId());
            List<Task> tasks1 = taskService.selTasks(taskQuery1);
            if (tasks1.size() < 1) {
                logger.error("数据库中查询不到当前正在执行的任务：{}", request.getTaskId());
                response.setCode(ResponseCode.ERROR.getCode());
                response.setMessage("数据库中查询不到当前正在执行的任务");
                return JSON.toJSONString(response);
            }
            Task currentTask = tasks1.get(0);
            currentTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
            if (request.getPickNum() != null) {
                currentTask.setOperateNum(request.getPickNum());
            }
            if (Objects.equals(currentTask.getTaskType(), TaskType.INVENTORY.getCode())) {// 盘点任务
                currentTask.setOperateNum(currentTask.getTotalNum() - request.getRealNum());
            }
            currentTask.setFinishTime(new Date());
            taskRecordService.addTask(currentTask);
            taskService.deleteTask(currentTask.getTaskId());
            // 根据这个任务的数据来更新库存
            Stock stockQuery1 = new Stock();
            stockQuery1.setVehicleId(currentTask.getVehicleNo());
            stockQuery1.setGoodsId(currentTask.getGoodsId());
            List<Stock> stocks = stockService.selStocks(stockQuery1);
            if (stocks.size() < 1) {
                logger.error("查询不到对应库存");
                response.setCode(ResponseCode.ERROR.getCode());
                response.setMessage("查询不到对应库存");
                return JSON.toJSONString(response);
            }
            Stock currentStock = stocks.get(0);
            if (request.getRealNum() != null) {
                currentStock.setRealNum(request.getRealNum());
                if (Objects.equals(currentTask.getTaskType(), TaskType.INVENTORY.getCode())) {
                    currentStock.setRemainNum(currentStock.getRealNum());
                    currentStock.setAvailableNum(currentStock.getRealNum());
                }
            } else {
                currentStock.setRealNum(currentStock.getRealNum() - currentTask.getOperateNum());
            }

            // 判断当前任务的载具号是否还有其他任务
            Task taskQuery2 = new Task();
            taskQuery2.setVehicleNo(request.getVehicleNo());
            taskQuery2.setTaskType(TaskType.OUT.getCode());
            List<Task> sameVehicleTasks = taskService.selTasks(taskQuery2);
            if (sameVehicleTasks.size() > 0) {// 存在其他任务
                logger.info("当前载具还有其他任务");
                // 库存只更新
                stockService.modifyStock(currentStock);
            } else {
                // 标记当前箱子入库中
                // 标记当前载具为空箱
                Vehicle currentVehicle = vehicleService.selVehicleById(currentTask.getVehicleNo());
                currentVehicle.setVehicleStatus(VehicleStatus.IN.getCode());
                vehicleService.modifyVehicle(currentVehicle);
                //查找到对应的入库站台
                Stand standQuery2 = new Stand();
                standQuery2.setAllowIn(1);
                standQuery2.setAllowOut(0);
                standQuery2.setStandType(1);
                // 判断库存是否为0
                if (currentStock.getRealNum() <= 0) {// 库存为0
                    logger.info("拣货后库存为0，空箱回库");
                    // 删除当前库存
                    stockService.deleteStock(currentStock.getStockId());
                    // 根据这个任务的数据来更新库存
                    Stock stockQuery2 = new Stock();
                    stockQuery2.setVehicleId(currentTask.getVehicleNo());
                    List<Stock> stocks2 = stockService.selStocks(stockQuery2);
                    // 判断当前载具上是否还有其他库存
                    if (stocks2.size() == 0) {// 当前载具是空托
                        // 标记当前载具为空箱
                        currentVehicle.setIsEmpty(1);
                        vehicleService.modifyVehicle(currentVehicle);
                    } else {// 更新载具上其他库存为回库状态
                        for (Stock tempSameVehicleStock : stocks2) {
                            tempSameVehicleStock.setStockStatus(StockStatus.BACKING.getCode());
                            stockService.modifyStock(tempSameVehicleStock);
                        }
                    }
                    // 生成空托回库任务---回到原来位置
                    Task emptyBackTask = new Task();
                    emptyBackTask.setTaskId(WmsUtils.generateId("HK"));
                    emptyBackTask.setTaskType(TaskType.IN.getCode());
                    emptyBackTask.setTaskStatus(WmsTaskStatus.NEW.getCode());
                    emptyBackTask.setTaskGroup(WmsUtils.generateUUIDString());
                    emptyBackTask.setDestination(currentStock.getLocationId());
                    // 根据库位查找站台
                    Location currentLocation = locationService.selLocations(new Location(currentStock.getLocationId())).get(0);
                    standQuery2.setEquipmentId(currentLocation.getEquipmentId());
                    List<Stand> availableStands = standService.selStands(standQuery2);
                    emptyBackTask.setOrigin(availableStands.get(0).getStandId());
                    emptyBackTask.setWeight((double) 0);
                    emptyBackTask.setVehicleNo(currentTask.getVehicleNo());
                    emptyBackTask.setVehicleSize(0);
                    emptyBackTask.setCreateTime(new Date());
                    emptyBackTask.setUserName(currentTask.getUserName());
                    emptyBackTask.setGoodsId(WmsConstants.EMPTY_STOCK_GOODS_ID);
                    emptyBackTask.setTaskPriority(1);
                    taskService.addTask(emptyBackTask);
                } else {
                    logger.info("拣货后库存不为0，回库");
                    // 更新库存
                    currentStock.setRemainNum(currentStock.getRealNum());
                    stockService.modifyStock(currentStock);
                    // 设置当前载具的其他库存也为回库中
                    Stock stockQuery2 = new Stock();
                    stockQuery2.setVehicleId(currentTask.getVehicleNo());
                    List<Stock> stocks2 = stockService.selStocks(stockQuery2);
                    for (Stock sameVehicleStock : stocks2) {
                        sameVehicleStock.setStockStatus(StockStatus.BACKING.getCode());
                        stockService.modifyStock(sameVehicleStock);
                    }
                    // 生成入库任务
                    Task backTask = new Task();
                    backTask.setTaskId(WmsUtils.generateId("HK"));
                    backTask.setTaskType(TaskType.IN.getCode());
                    backTask.setTaskStatus(WmsTaskStatus.NEW.getCode());
                    backTask.setTaskGroup(WmsUtils.generateUUIDString());
                    backTask.setDestination(currentStock.getLocationId());
                    // 根据库位查找站台
                    Location currentLocation = locationService.selLocations(new Location(currentStock.getLocationId())).get(0);
                    standQuery2.setEquipmentId(currentLocation.getEquipmentId());
                    List<Stand> availableStands = standService.selStands(standQuery2);
                    backTask.setOrigin(availableStands.get(0).getStandId());
                    backTask.setWeight((double) 0);
                    backTask.setVehicleNo(currentTask.getVehicleNo());
                    backTask.setVehicleSize(0);
                    backTask.setCreateTime(new Date());
                    backTask.setUserName(currentTask.getUserName());
                    backTask.setGoodsId(currentStock.getGoodsId());
                    backTask.setGoodsName(currentStock.getGoodsName());
                    backTask.setProductionDate(currentStock.getProductionDate());
                    backTask.setExpirationDate(currentStock.getExpirationDate());
                    backTask.setOperateNum(currentStock.getRealNum());
                    backTask.setTotalNum(currentStock.getRealNum());
                    backTask.setTaskPriority(1);
                    taskService.addTask(backTask);
                }
            }

            logger.info("物料回库成功");
            response.setCode(0);
            response.setMessage("成功");
            return JSON.toJSONString(response);
        } catch (Exception e) {
            // 回滚事务
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            logger.error("发生异常：{}", e.getMessage());
            response.setCode(ResponseCode.ERROR.getCode());
            response.setMessage("发生异常");
            return JSON.toJSONString(response);
        }
    }

    /**
     * 查找所有任务
     */
    @PostMapping("/getTasks")
    @ResponseBody
    public String getTasks(@RequestBody TableRequest<Task, String> tableRequest) {
        TableResponse tblResp = new TableResponse();
        // 解析请求数据
        if (tableRequest == null || tableRequest.getPage() == null) {
            tblResp.setCode(ResponseCode.ERROR.getCode());
            tblResp.setMessage("请求数据为空，无法处理！");
            logger.error("请求数据为空，无法处理！");
            return JSON.toJSONString(tblResp);
        }
        // 处理分页信息
        PageDomain pageRequest = tableRequest.getPage();
        String[] orderByArr = {"task_id", "task_type", "task_status", "goods_id", "goods_name", "task_priority", "expiration_date", "create_time"};
        String orderByStr;

        if (StringUtils.isNotEmpty(pageRequest.getOrderByColumn()) && Arrays.asList(orderByArr).contains(StringUtils.toUnderScoreCase(pageRequest.getOrderByColumn()))) {
            orderByStr = pageRequest.getOrderBy();
        } else {
            // 默认排序
            orderByStr = "";
        }

        Task taskQuery = new Task();
        taskQuery.setTaskType(tableRequest.getParam().getTaskType());
        taskQuery.setGoodsId(tableRequest.getParam().getGoodsId());
        taskQuery.setVehicleNo(tableRequest.getParam().getVehicleNo());
        // 查找对应站台
        List<Stand> stands = standService.selStands(new Stand(2, HttpUtils.getIpAddr(servletRequest), 0));
        if (stands.size() > 0 && (Objects.equals(taskQuery.getTaskType(), TaskType.OUT.getCode()) || Objects.equals(taskQuery.getTaskType(), TaskType.INVENTORY.getCode()))) {
            taskQuery.setPickStand(stands.get(0).getStandId());
        }
        PageHelper.startPage(pageRequest.getPageNum(), pageRequest.getPageSize(), orderByStr);
        List<Task> tasks = taskService.selTaskList(taskQuery);
        PageInfo<Task> taskPageInfo = new PageInfo<>(tasks);
        tblResp.setCode(ResponseCode.OK.getCode());
        tblResp.setMessage("查询任务成功！");
        tblResp.setRows(taskPageInfo.getList());
        tblResp.setTotal(taskPageInfo.getTotal());
        return JSON.toJSONString(tblResp);
    }

    /**
     * 根据参数查询wms任务
     */
    @PostMapping("/getTaskByTask")
    @ResponseBody
    public String getTaskByTask(@RequestBody Task request) {
        ResponseEntity response = new ResponseEntity();
        if (request == null) {
            logger.error("请求参数为空");
            response.setCode(ResponseCode.ERROR.getCode());
            response.setMessage("请求参数为空");
            return JSON.toJSONString(response);
        }
        List<Stand> stands = standService.selStands(new Stand(2, HttpUtils.getIpAddr(servletRequest), 0));
        if (stands.size() > 0) {
            request.setPickStand(stands.get(0).getStandId());
        } else {
            request.setPickStand("other");
        }
        List<Task> tasks = taskService.selTasks(request);

        response.setCode(ResponseCode.OK.getCode());
        response.setMessage("成功");
        response.setReturnData(tasks.size() > 0 ? tasks.get(0) : null);
        return JSON.toJSONString(response);
    }
}