package com.zy.acs.wcs.asrs.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.zy.acs.wcs.asrs.entity.Loc;
import com.zy.acs.wcs.asrs.entity.WrkMast;
import com.zy.acs.wcs.asrs.service.BasDevpService;
import com.zy.acs.wcs.asrs.service.LocService;
import com.zy.acs.wcs.asrs.service.StaDescService;
import com.zy.acs.wcs.asrs.service.WrkMastService;
import com.zy.acs.wcs.common.OpenBusSubmitParam;
import com.zy.acs.wcs.common.TaskDto;
import com.zy.acs.wcs.common.utils.HttpHandler;
import com.zy.acs.wcs.core.DevpThread;
import com.zy.acs.wcs.core.cache.MessageQueue;
import com.zy.acs.wcs.core.cache.SlaveConnection;
import com.zy.acs.wcs.core.enums.SlaveType;
import com.zy.acs.wcs.core.model.DevpSlave;
import com.zy.acs.wcs.core.model.Task;
import com.zy.acs.wcs.core.model.protocol.StaProtocol;
import com.zy.acs.wcs.core.properties.SlaveProperties;
import com.zy.acs.wcs.core.thread.BarcodeThread;
import com.zy.acs.wcs.core.thread.SiemensDevpThread;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;

/**
 * 立体仓库WCS系统主流程业务
 * Created by vincent on 2020/8/6
 */
@Slf4j
@Service("mainService")
@Transactional
public class MainServiceImpl {

    public static final long COMMAND_TIMEOUT = 5 * 1000;

    @Autowired
    private SlaveProperties slaveProperties;

    @Autowired
    private WrkMastService wrkMastService;

    @Autowired
    private BasDevpService basDevpService;

    @Autowired
    private StaDescService staDescService;

    @Autowired
    private LocService locService;

    public static final ArrayList<Integer> locRow = new ArrayList<Integer>() {{
        add(49);
        add(50);
        add(51);
        add(52);
        add(53);
        add(54);
        add(55);
        add(56);
        add(57);
        add(58);
        add(59);
    }};

    private short workNo = 1000;

    private short workNo2 = 3000;

    private Short getWorkNo() {
        if (workNo > 2000) {
            workNo = 1000;
        } else {
            workNo++;
        }
        return workNo;
    }

    private Short getOutWorkNo() {
        if (workNo2 > 4000) {
            workNo2 = 3000;
        } else {
            workNo2++;
        }
        return workNo2;
    }


    public synchronized void generateStoreWrkFile() {
        try {
            // 根据输送线plc遍历
            for (DevpSlave devp : slaveProperties.getDevp()) {
                // 遍历入库口
                for (DevpSlave.Sta inSta : devp.getInSta()) {
                    // 获取入库站信息
                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                    StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
                    if (staProtocol == null) {
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
                    }
                    Short workNo = staProtocol.getWorkNo();
                    // 尺寸检测异常
                    boolean back = false;
                    String errMsg = "";
                    if (staProtocol.isFrontErr()) {
                        errMsg = "前超限";
                        back = true;
                    }
                    if (!back && staProtocol.isBackErr()) {
                        errMsg = "后超限";
                        back = true;
                    }
                    if (!back && staProtocol.isHighErr()) {
                        errMsg = "高超限";
                        back = true;
                    }
                    if (!back && staProtocol.isLeftErr()) {
                        errMsg = "左超限";
                        back = true;
                    }
                    if (!back && staProtocol.isRightErr()) {
                        errMsg = "右超限";
                        back = true;
                    }
                    if (!back && staProtocol.isWeightErr()) {
                        errMsg = "超重";
                        back = true;
                    }
                    if (!back && staProtocol.isBarcodeErr()) {
                        errMsg = "扫码失败";
                        back = true;
                    }
                    // 判断是否满足入库条件
                    if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable()
                            && !staProtocol.isEmptyMk() && workNo >= 9000 && staProtocol.isPakMk()) {
//                        // 获取条码扫描仪信息
                        BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
                        if (barcodeThread == null) {
                            continue;
                        }
                        String BoxNo = barcodeThread.getBarcode();
//                        if (Cools.isEmpty(BoxNo)) {
//                            log.error("{}号条码扫描失败，值：{}", inSta.getBarcode(), BoxNo);
//                            continue;
//                        }
                        if (back) {
                            staProtocol.setStaNo(inSta.getBackSta().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            log.info("组托入库托盘退回命令推送输送线队列成功==>{}，{}，{}", BoxNo, errMsg);
                        } else {
                            // TODO
                            OpenBusSubmitParam data = getData(inSta.getStaNo());
                            String response = new HttpHandler.Builder()
                                    .setUri("10.10.10.200:8088")
                                    .setPath("/api/open/bus/submit")
                                    .setJson(JSON.toJSONString(data))
                                    .build()
                                    .doPost();
                            JSONObject jsonObject = JSON.parseObject(response);
                            if (jsonObject.getInteger("code").equals(200)) {
                                createInWrk();
                                staProtocol.setWorkNo(getWorkNo());
                                staProtocol.setStaNo((short) 102);
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                                log.info("组托入库命令推送输送线队列成功:{}", staProtocol);
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            log.error("generateStoreWrkFile e", e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }

    private Loc getLoc() {
        List<Loc> list = locService.list(new LambdaQueryWrapper<Loc>().eq(Loc::getLocSts, 15).in(Loc::getRow, locRow));
        Collections.shuffle(list);
        return list.get(0);
    }


    private OpenBusSubmitParam getData(Integer stnNo) {
        OpenBusSubmitParam param = new OpenBusSubmitParam();
        param.setBatch(String.valueOf(System.currentTimeMillis()));

        TaskDto taskDto = new TaskDto();
        taskDto.setOriSta(stnNo + "");
        taskDto.setDestLoc(getLoc().getLocNo());
        taskDto.setPriority(100);
        taskDto.setSeqNum(String.valueOf(System.currentTimeMillis()).substring(15, 19));
        param.getTaskList().add(taskDto);
        return param;
    }


    private WrkMast createInWrk() {
        Date date = new Date();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(getWorkNo().intValue());
        wrkMast.setIoTime(new Date());
        wrkMast.setWrkSts(2L); // 工作状态：生成入库ID
        wrkMast.setIoType(10); // 入出库状态：1.入库
        wrkMast.setIoPri(13D); // 优先级
        wrkMast.setCrnNo(1);
        wrkMast.setSourceStaNo(101);
        wrkMast.setStaNo(103);
        wrkMast.setLocNo(getLoc().getLocNo());
        wrkMast.setBarcode(""); // 托盘码
        wrkMast.setFullPlt("Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setLinkMis("Y");
        // 操作人员数据
        wrkMast.setAppeTime(date);
        wrkMast.setModiTime(date);
        boolean res = wrkMastService.save(wrkMast);
        return wrkMast;
    }


    private WrkMast createOutWrk() {
        Date date = new Date();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(getOutWorkNo().intValue());
        wrkMast.setIoTime(new Date());
        wrkMast.setWrkSts(2L); // 工作状态：生成入库ID
        wrkMast.setIoType(10); // 入出库状态：1.入库
        wrkMast.setIoPri(13D); // 优先级
        wrkMast.setCrnNo(1);
        wrkMast.setSourceStaNo(101);
        wrkMast.setStaNo(103);
        wrkMast.setLocNo(getLoc().getLocNo());
        wrkMast.setBarcode(""); // 托盘码
        wrkMast.setFullPlt("Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setLinkMis("Y");
        // 操作人员数据
        wrkMast.setAppeTime(date);
        wrkMast.setModiTime(date);
        boolean res = wrkMastService.save(wrkMast);
        return wrkMast;
    }

    /**
     * 出库
     */
    public synchronized void out() throws IOException {
        for (DevpSlave devpSlave : slaveProperties.getDevp()) {
            for (DevpSlave.Sta sta : devpSlave.getOutSta()) {
                try {
                    // 获取堆垛机出库站信息
                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devpSlave.getId());
                    StaProtocol staProtocol = devpThread.getStation().get(sta.getStaNo());
                    if (staProtocol == null) {
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
                    }
                    if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == 0)) {
                        WrkMast one = wrkMastService.getOne(new QueryWrapper<WrkMast>().eq("sta_no", sta.getStaNo()).eq("wrk_sts", 14));
                        if (one != null) {
                            // 查询工作档
                            staProtocol.setWorkNo(getOutWorkNo());
                            staProtocol.setStaNo((short) 101);
                            MessageQueue.offer(SlaveType.Devp, devpSlave.getId(), new Task(2, staProtocol));
                            one.setWrkSts(15L);
                            wrkMastService.updateById(one);
                        }
                    }
                } catch (Exception e) {
                    log.error("出库到出库站异常:异常信息：" + e);
                }
            }
        }
    }


    /**
     * 入出库模式切换函数
     */
    public synchronized void ioConvert() {
        try {
            // 根据输送线plc遍历
            for (DevpSlave devp : slaveProperties.getDevp()) {
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
//                for (DevpSlave.Sta inSta : devp.getInSta()) {
//                    TaskWrk taskWrk = taskWrkService.selectByTargetPoint(inSta.getBackSta() + "");
//                    switch (inSta.getBackSta()) {
//                        case 101:
//                            if (taskWrk != null) {
//                                if (devpThread.ioModeOf1F1 != IoModeType.PAKOUT_MODE) {
//                                    // 出库切换中
//                                    devpThread.ioModeOf1F1 = IoModeType.PAKOUT_BOOTING;
//                                    TaskWrk pakin = taskWrkService.selectByStartPoint(inSta.getStaNo() + "");
//                                    if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
//                                            && !devpThread.getStation().get(inSta.getBackSta()).isLoading()
//                                            && devpThread.getStation().get(inSta.getBackSta()).getWorkNo() == 0) {
//                                        // 出库模式
//                                        devpThread.ioModeOf1F1 = IoModeType.PAKOUT_MODE;
//                                    }
//                                }
//                            } else {
//                                // 入库模式
//                                devpThread.ioModeOf1F1 = IoModeType.PAKIN_MODE;
//                            }
//                            break;
//                        case 104:
//                            if (taskWrk != null) {
//                                if (devpThread.ioModeOf1F2 != IoModeType.PAKOUT_MODE) {
//                                    // 出库切换中
//                                    devpThread.ioModeOf1F2 = IoModeType.PAKOUT_BOOTING;
//                                    TaskWrk pakin = taskWrkService.selectByStartPoint(inSta.getStaNo() + "");
//                                    if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
//                                            && !devpThread.getStation().get(inSta.getBackSta()).isLoading()
//                                            && devpThread.getStation().get(inSta.getBackSta()).getWorkNo() == 0) {
//                                        // 出库模式
//                                        devpThread.ioModeOf1F2 = IoModeType.PAKOUT_MODE;
//                                    }
//                                }
//                            } else {
//                                // 入库模式
//                                devpThread.ioModeOf1F2 = IoModeType.PAKIN_MODE;
//                            }
//                            break;
//                        case 107:
//                            if (taskWrk != null) {
//                                if (devpThread.ioModeOf1F3 != IoModeType.PAKOUT_MODE) {
//                                    // 出库切换中
//                                    devpThread.ioModeOf1F3 = IoModeType.PAKOUT_BOOTING;
//                                    TaskWrk pakin = taskWrkService.selectByStartPoint(inSta.getStaNo() + "");
//                                    if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
//                                            && !devpThread.getStation().get(inSta.getBackSta()).isLoading()
//                                            && devpThread.getStation().get(inSta.getBackSta()).getWorkNo() == 0) {
//                                        // 出库模式
//                                        devpThread.ioModeOf1F3 = IoModeType.PAKOUT_MODE;
//                                    }
//                                }
//                            } else {
//                                // 入库模式
//                                devpThread.ioModeOf1F3 = IoModeType.PAKIN_MODE;
//                            }
//                            break;
//                        case 110:
//                            if (taskWrk != null) {
//                                if (devpThread.ioModeOf1F4 != IoModeType.PAKOUT_MODE) {
//                                    // 出库切换中
//                                    devpThread.ioModeOf1F4 = IoModeType.PAKOUT_BOOTING;
//                                    TaskWrk pakin = taskWrkService.selectByStartPoint(inSta.getStaNo() + "");
//                                    if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
//                                            && !devpThread.getStation().get(inSta.getBackSta()).isLoading()
//                                            && devpThread.getStation().get(inSta.getBackSta()).getWorkNo() == 0) {
//                                        // 出库模式
//                                        devpThread.ioModeOf1F4 = IoModeType.PAKOUT_MODE;
//                                    }
//                                }
//                            } else {
//                                // 入库模式
//                                devpThread.ioModeOf1F4 = IoModeType.PAKIN_MODE;
//                            }
//                            break;
//                        case 113:
//                            if (taskWrk != null) {
//                                if (devpThread.ioModeOf1F5 != IoModeType.PAKOUT_MODE) {
//                                    // 出库切换中
//                                    devpThread.ioModeOf1F5 = IoModeType.PAKOUT_BOOTING;
//                                    TaskWrk pakin = taskWrkService.selectByStartPoint(inSta.getStaNo() + "");
//                                    if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
//                                            && !devpThread.getStation().get(inSta.getBackSta()).isLoading()
//                                            && devpThread.getStation().get(inSta.getBackSta()).getWorkNo() == 0) {
//                                        // 出库模式
//                                        devpThread.ioModeOf1F5 = IoModeType.PAKOUT_MODE;
//                                    }
//                                }
//                            } else {
//                                // 入库模式
//                                devpThread.ioModeOf1F5 = IoModeType.PAKIN_MODE;
//                            }
//                            break;
//                        case 203:
//                            if (taskWrk != null) {
//                                if (devpThread.ioModeOf2F1 != IoModeType.PAKOUT_MODE) {
//                                    // 出库切换中
//                                    devpThread.ioModeOf2F1 = IoModeType.PAKOUT_BOOTING;
//                                    TaskWrk pakin = taskWrkService.selectByStartPoint(inSta.getStaNo() + "");
//                                    if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
//                                            && !devpThread.getStation().get(inSta.getBackSta()).isLoading()
//                                            && devpThread.getStation().get(inSta.getBackSta()).getWorkNo() == 0) {
//                                        // 出库模式
//                                        devpThread.ioModeOf2F1 = IoModeType.PAKOUT_MODE;
//                                    }
//                                }
//                            } else {
//                                // 入库模式
//                                devpThread.ioModeOf2F1 = IoModeType.PAKIN_MODE;
//                            }
//                            break;
//
//                        case 207:
//                            if (taskWrk != null) {
//                                if (devpThread.ioModeOf2F2 != IoModeType.PAKOUT_MODE) {
//                                    // 出库切换中
//                                    devpThread.ioModeOf2F2 = IoModeType.PAKOUT_BOOTING;
//                                    TaskWrk pakin = taskWrkService.selectByStartPoint(inSta.getStaNo() + "");
//                                    if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
//                                            && !devpThread.getStation().get(inSta.getBackSta()).isLoading()
//                                            && devpThread.getStation().get(inSta.getBackSta()).getWorkNo() == 0) {
//                                        // 出库模式
//                                        devpThread.ioModeOf2F2 = IoModeType.PAKOUT_MODE;
//                                    }
//                                }
//                            } else {
//                                // 入库模式
//                                devpThread.ioModeOf2F2 = IoModeType.PAKIN_MODE;
//                            }
//                            break;
//
//                        case 212:
//                            if (taskWrk != null) {
//                                if (devpThread.ioModeOf2F3 != IoModeType.PAKOUT_MODE) {
//                                    // 出库切换中
//                                    devpThread.ioModeOf2F3 = IoModeType.PAKOUT_BOOTING;
//                                    TaskWrk pakin = taskWrkService.selectByStartPoint(inSta.getStaNo() + "");
//                                    if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
//                                            && !devpThread.getStation().get(inSta.getBackSta()).isLoading()
//                                            && devpThread.getStation().get(inSta.getBackSta()).getWorkNo() == 0) {
//                                        // 出库模式
//                                        devpThread.ioModeOf2F3 = IoModeType.PAKOUT_MODE;
//                                    }
//                                }
//                            } else {
//                                // 入库模式
//                                devpThread.ioModeOf2F3 = IoModeType.PAKIN_MODE;
//                            }
//                            break;
//                    }
//                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}