package com.zy.asrs.controller;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.annotations.ManagerAuth;
import com.core.common.BaseRes;
import com.core.common.Cools;
import com.core.common.R;
import com.core.exception.CoolException;
import com.zy.asrs.domain.enums.CrnStatusType;
import com.zy.asrs.domain.param.CrnDemoParam;
import com.zy.asrs.domain.param.SteModeParam;
import com.zy.asrs.domain.param.SteOperatorParam;
import com.zy.asrs.domain.vo.SteMsgTableVo;
import com.zy.asrs.domain.vo.SteStateTableVo;
import com.zy.asrs.domain.vo.SteDataVo;
import com.zy.asrs.entity.BasSte;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.BasSteService;
import com.zy.asrs.service.WrkMastService;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.OutputQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.SlaveType;
import com.zy.core.enums.SteTaskModeType;
import com.zy.core.model.CrnSlave;
import com.zy.core.model.SteSlave;
import com.zy.core.model.Task;
import com.zy.core.model.command.SteCommand;
import com.zy.core.model.protocol.SteProtocol;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.properties.SystemProperties;
import com.zy.core.thread.SteThread;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

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

/**
 * 穿梭车接口
 * Created by vincent on 2022/3/14
 */
@Slf4j
@RestController
@RequestMapping("/ste")
public class SteController {

    @Autowired
    private SlaveProperties slaveProperties;
    @Autowired
    private BasSteService basSteService;
    @Autowired
    private WrkMastService wrkMastService;

    @PostMapping("/table/ste/state")
    @ManagerAuth(memo = "穿梭车信息表")
    public R steStateTable(){
        List<SteStateTableVo> list = new ArrayList<>();
        List<BasSte> stes = basSteService.selectList(new EntityWrapper<BasSte>().orderBy("ste_no"));
        for (BasSte basSte : stes) {
            // 表格行
            SteStateTableVo vo = new SteStateTableVo();
            vo.setSteNo(basSte.getSteNo());   //  穿梭车号
            list.add(vo);
            // 获取穿梭车信息
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, basSte.getSteNo());
            if (steThread == null) {
                continue;
            }
            SteProtocol steProtocol = steThread.getSteProtocol();
            if (steProtocol == null) {
                continue;
            }
            vo.setTaskNo(steProtocol.getTaskNo().intValue());  //  任务号
            vo.setStatusVal(steProtocol.getMode().intValue());  // 在线状态
            vo.setStatusType(steProtocol.mode == 0 ? "离线" : "在线");   //  模式状态
            if (!Cools.isEmpty(steProtocol.getStatus())) {
                vo.setStatus(steProtocol.getStatusType().desc);     //  状态
            }
            if (!Cools.isEmpty(steProtocol.getLoad())) {
                vo.setLoading(steProtocol.getLoad()==1?"✔":"×");  //  有物
            }
            if (!Cools.isEmpty(steProtocol.getWaiting())) {
                vo.setWaiting(steProtocol.getWaiting()?"✔":"×");
            }
            vo.setRow(steProtocol.getRow());
            vo.setBay(steProtocol.getBay());
            vo.setLev(steProtocol.getLev());
            vo.setCharge(steProtocol.getCharge() + "%");
            if (!Cools.isEmpty(steProtocol.getLoca())) {
                vo.setLoca(steProtocol.getLocaType().desc);
            }
            vo.setSpeed(steProtocol.getSpeed());
            vo.setCloser(steProtocol.getCloser());
            if (!Cools.isEmpty(steProtocol.getPos())) {
                vo.setPos(steProtocol.getPos()==0?"低位":"高位");
            }
            if (!Cools.isEmpty(steProtocol.getTrack())) {
                vo.setTrack(steProtocol.getTrack()==0?"✔":"×");
            }
            if (!Cools.isEmpty(steProtocol.getChargeStatus())) {
                vo.setChargeStatus(steProtocol.getChargeStatus()==1?"✔":"×");
            }
        }
        return R.ok().add(list);
    }

    @PostMapping("/table/ste/msg")
    @ManagerAuth(memo = "穿梭车数据表")
    public R steMsgTable(){
        List<SteMsgTableVo> list = new ArrayList<>();
        List<BasSte> stes = basSteService.selectList(new EntityWrapper<BasSte>().orderBy("ste_no"));
        for (BasSte basSte : stes) {
            // 表格行
            SteMsgTableVo vo = new SteMsgTableVo();
            vo.setSteNo(basSte.getSteNo());   //  穿梭车号
            list.add(vo);
            // 获取穿梭车信息
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, basSte.getSteNo());
            if (steThread == null) {
                continue;
            }
            SteProtocol steProtocol = steThread.getSteProtocol();
            if (steProtocol == null) {
                continue;
            }

            vo.setWorkNo(steProtocol.getTaskNo().intValue());  //  任务号
            if (steProtocol.getTaskNo() > 0) {
                WrkMast wrkMast = wrkMastService.selectById(steProtocol.getTaskNo());
                if (wrkMast != null) {
                    vo.setStatus(CrnStatusType.process(wrkMast.getIoType()).getDesc());   //  模式状态
                    vo.setSourceStaNo(wrkMast.getSourceStaNo$());    //  源站
                    vo.setStaNo(wrkMast.getStaNo$());   //  目标站
                    vo.setSourceLocNo(wrkMast.getSourceLocNo());    //  源库位
                    vo.setLocNo(wrkMast.getLocNo());    //  目标库位
                }
            } else {
                vo.setStatus(steProtocol.mode == 1? CrnStatusType.MACHINE_AUTO.getDesc(): CrnStatusType.MACHINE_UN_AUTO.getDesc());   //  模式状态
            }
            vo.setSpeed(steProtocol.getSpeed());  // 速度
            vo.setCloser(steProtocol.getCloser());  // 近点距离
            vo.setPakMk(steProtocol.getPakMk());    // 作业标记
        }
        return R.ok().add(list);
    }

    @PostMapping("/output/ste")
    @ManagerAuth
    public R steOutput(){
        StringBuilder str = new StringBuilder();
        String s;
        int i = 0;
        while((s = OutputQueue.STE.poll()) != null && i <=10) {
            str.append("\n").append(s);
            i++;
        }
        return R.ok().add(str.toString());
    }

    @GetMapping("/detl/{steNo}")
    public R steDetl(@PathVariable("steNo") Integer steNo){
        SteDataVo vo = new SteDataVo();
        for (SteSlave ste : slaveProperties.getSte()) {
            if (steNo.equals(ste.getId())) {
                vo.setSteNo(ste.getId());
                BasSte basSte = basSteService.selectById(ste.getId());
                if (!Cools.isEmpty(basSte)) {
                    vo.setRow(basSte.getRow());
                    vo.setBay(basSte.getBay());
                    vo.setLev(basSte.getLev());
                    vo.setCrnNo(basSte.getCrnNo());
                    vo.setWorkNo(basSte.getWrkNo());
                    vo.setPakMk(basSte.getPakMk());
                }
                break;
            }
        }
        return R.ok().add(vo);
    }

    @PostMapping("/detl/update")
    @ManagerAuth
    public R steUpdate(SteDataVo vo){
        BasSte basSte = basSteService.selectById(vo.getSteNo());
        if (basSte == null) {
            return R.error();
        }
        // 获取穿梭车信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, vo.getSteNo());
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (steProtocol == null) {
           throw new CoolException(vo.getSteNo() + "号穿梭车不在线，无法保存");
        }
        if (!Cools.isEmpty(vo.getRow(), vo.getBay(), vo.getLev())) {
            if (!steThread.modifyPosHandle(vo.getRow(), vo.getBay(), vo.getLev())) {
                throw new CoolException("服务器错误");
            }
        }
        SteCommand steCommand = new SteCommand();
        steCommand.setTaskNo(vo.getWorkNo());
        if (MessageQueue.offer(SlaveType.Ste, vo.getSteNo(), new Task(2, steCommand))) {
        } else {
            throw new CoolException("命令下发失败");
        }
        basSte.setPakMk(vo.getPakMk());
        basSte.setWrkNo(vo.getWorkNo());
        basSte.setCrnNo(vo.getCrnNo());
        basSte.setUpdateTime(new Date());
        if (!basSteService.updateById(basSte)) {
            throw new CoolException("修改失败");
        }
        return R.ok();
    }


    /****************************************************************/
    /************************** 手动操作 ******************************/
    /****************************************************************/

    @PostMapping("/mode/switch")
    @ManagerAuth
    public R crnDemo(SteModeParam param) throws InterruptedException {
        if (Cools.isEmpty(param.getSteNo())){
            return R.error();
        }
        if (Cools.isEmpty(param.getPassword())){
            return R.error("请输入口令");
        }
        if (!param.getPassword().equals(SystemProperties.WCS_PASSWORD)){
            return R.error("口令错误");
        }
        Thread.sleep(200L);
        for (SteSlave steSlave : slaveProperties.getSte()) {
            if (steSlave.getId().equals(param.getSteNo())) {
                // 获取穿梭车信息
                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steSlave.getId());
                SteProtocol steProtocol = steThread.getSteProtocol();
                if (steProtocol == null) { continue; }
                SteCommand steCommand = new SteCommand();
                steCommand.setSteNo(param.getSteNo()); // 穿梭车编号
                if (steProtocol.getMode() == 0) {
                    steCommand.setControlMode((short) 1);
                } else {
                    steCommand.setControlMode((short) 0);
                }
                if (MessageQueue.offer(SlaveType.Ste, param.getSteNo(), new Task(2, steCommand))) {
                    return R.ok();
                } else {
                    throw new CoolException("命令下发失败");
                }
            }
        }
        return R.ok();
    }

    @ManagerAuth(memo = "手动操作")
    @PostMapping("/operator/ste")
    public R steOperator(SteOperatorParam param){
        if (Cools.isEmpty(param.getSteNo(), param.getSteTaskMode())) {
            return R.parse(BaseRes.PARAM);
        }

        for (SteSlave ste : slaveProperties.getSte()) {
            // 获取堆垛机信息
            if (param.getSteNo().equals(ste.getId())) {
                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
                if (steThread == null) {
                    throw new CoolException("穿梭车不在线");
                }
                SteProtocol steProtocol = steThread.getSteProtocol();
                if (steProtocol == null) {
                    throw new CoolException("穿梭车不在线");
                }
                SteTaskModeType steTaskModeType = SteTaskModeType.get(param.getSteTaskMode());
                SteCommand steCommand = new SteCommand();
                steCommand.setSteNo(ste.getId()); // 穿梭车编号
                if (param.getSteTaskMode() == 16) {
                    steCommand.setComplete(true);
                } else if (param.getSteTaskMode() == 99) {
                    steCommand.setControlMode((short) 1);
                } else if (param.getSteTaskMode() == 100) {
                    steCommand.setControlMode((short) 0);
                } else {
                    if (steTaskModeType == null) {
                        throw new CoolException("任务类型错误");
                    }
                    steCommand.setTaskNo(param.getTaskNo()); // 工作号
                    steCommand.setTaskMode(steTaskModeType);
                }
                if (MessageQueue.offer(SlaveType.Ste, ste.getId(), new Task(2, steCommand))) {
                    return R.ok();
                } else {
                    throw new CoolException("命令下发失败");
                }
            }
        }
        return R.error();
    }

}