package com.zy.acs.gateway.handler;

import com.zy.acs.common.constant.RedisConstant;
import com.zy.acs.common.domain.AgvProtocol;
import com.zy.acs.common.domain.protocol.*;
import com.zy.acs.common.utils.RedisSupport;
import com.zy.acs.gateway.AbstractInboundHandler;
import com.zy.acs.gateway.Executors;
import com.zy.acs.gateway.constant.ProtocolType;
import com.zy.acs.gateway.domain.AgvPackage;
import com.zy.acs.gateway.process.AckMsgBuilder;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 业务处理 handler
 * Created by vincent on 2019-04-02
 */
@Component("gbPackageServerHandler")
@ChannelHandler.Sharable
public class AgvPackageServerHandler extends AbstractInboundHandler<AgvPackage> {

    private static final Logger log = LoggerFactory.getLogger(AgvPackageServerHandler.class);

    private final RedisSupport redis = RedisSupport.defaultRedisSupport;

    @Autowired
    private Executors executors;

    @Override
    @SuppressWarnings("all")
    protected boolean channelRead0(ChannelHandlerContext ctx, AgvPackage pac) throws Exception {
        // ack
        ProtocolType ackType = isNeedAck(pac);

        final String uniqueNo = pac.getHeader().getUniqueNo();

        label : switch (pac.getHeader().getProtocolType()){
            case PATH_ACK:      // 路径包 ack

                AGV_01_UP agv_01_up = (AGV_01_UP) pac.getBody().getMessageBody();

                redis.setObject(RedisConstant.AGV_CMD_UP_FLAG
                        , pac.getHeader().getUniqueNo() + "_" + agv_01_up.getSerialNo()
                        , agv_01_up);

                break label;

            case COMMAND_ACK:   // 命令包 ack

                AGV_02_UP agv_02_up = (AGV_02_UP) pac.getBody().getMessageBody();

                redis.setObject(RedisConstant.AGV_CMD_UP_FLAG
                        , pac.getHeader().getUniqueNo() + "_" + agv_02_up.getSerialNo()
                        , agv_02_up);

                break label;

            case ACTION_COMPLETE:   // 动作完成数据包


                AGV_11_UP agv_11_up = (AGV_11_UP) pac.getBody().getMessageBody();
                redis.push(RedisConstant.AGV_COMPLETE_FLAG, AgvProtocol.build(uniqueNo).setMessageBody(agv_11_up));

                // 动作完成应答
                if (null != ackType) {
                    AgvPackage ackPac = AckMsgBuilder.ofSuccess(pac, ackType);

                    AGV_A1_DOWN agv_a1_down = (AGV_A1_DOWN) ackPac.getBody().getMessageBody();
                    agv_a1_down.setAckSign((byte) agv_11_up.getCompleteCode());

                    ctx.writeAndFlush(ackPac);
                }


                break label;

            case DATA_CODE_REPORT:  // 有码实时数据

                AGV_12_UP agv_12_up = (AGV_12_UP) pac.getBody().getMessageBody();
                redis.push(RedisConstant.AGV_DATA_FLAG, AgvProtocol.build(uniqueNo).setMessageBody(agv_12_up));

//                executors.getInstance().execute(() -> {
//
//                    if (agvDataFeignApi.transfer(agv_12_up).fail()) {
//                        log.error("agvDataFeignApi.transfer(agv_12_up) fail!\n{}", JSON.toJSON(agv_12_up));
//                    }
//
//                });

                break label;

            case DATA_WITHOUT_CODE_REPORT:  // 无码实时数据

                AGV_13_UP agv_13_up = (AGV_13_UP) pac.getBody().getMessageBody();
                redis.push(RedisConstant.AGV_DATA_FLAG, AgvProtocol.build(uniqueNo).setMessageBody(agv_13_up));

//                executors.getInstance().execute(() -> {
//
//                    if (agvDataFeignApi.transfer(agv_13_up).fail()) {
//                        log.error("agvDataFeignApi.transfer(agv_13_up) fail!\n{}", JSON.toJSON(agv_13_up));
//                    }
//
//                });


                break label;

            case HEARTBEAT_REPORT:  // 心跳

                // 30s redis
                redis.setObject(RedisConstant.AGV_ONLINE_FLAG, pac.getHeader().getUniqueNo(), 1, 30);

                AGV_03_UP agv_03_up = (AGV_03_UP) pac.getBody().getMessageBody();
                redis.push(RedisConstant.AGV_DATA_FLAG, AgvProtocol.build(uniqueNo).setMessageBody(agv_03_up));


//                executors.getInstance().execute(() -> {
//
//                    if (agvDataFeignApi.transfer(agv_03_up).fail()) {
//                        log.error("agvDataFeignApi.transfer(agv_03_up) fail!\n{}", JSON.toJSON(agv_03_up));
//                    }
//                    if (agvDataFeignApi.transfer(AgvProtocol.build().setAgvNo(uniqueNo).setMessageBody(agv_03_up)).fail()) {
//                        log.error("agvDataFeignApi.transfer(agv_03_up) fail!\n{}", JSON.toJSON(agv_03_up));
//                    }
//
//                });

                break label;
                
            case SILO_REPORT:  // 料仓信息包

                AGV_70_UP agv_70_up = (AGV_70_UP) pac.getBody().getMessageBody();
                redis.push(RedisConstant.AGV_COMPLETE_FLAG, AgvProtocol.build(uniqueNo).setMessageBody(agv_70_up));

//                executors.getInstance().execute(() -> {
//
//                    if (agvDataFeignApi.transfer(agv_70_up).fail()) {
//                        log.error("agvDataFeignApi.transfer(agv_70_up) fail!\n{}", JSON.toJSON(agv_70_up));
//                    }
//
//                });


                break label;

            case LOGIN_REPORT:  // 登录

                AGV_F0_UP agv_f0_up = (AGV_F0_UP) pac.getBody().getMessageBody();
                redis.push(RedisConstant.AGV_DATA_FLAG, AgvProtocol.build(uniqueNo).setMessageBody(agv_f0_up));

                // 登录应答
                if (null != ackType) {
                    AgvPackage ackPac = AckMsgBuilder.ofSuccess(pac, ackType);

                    ctx.writeAndFlush(ackPac);
                }

                // 30s redis
                redis.setObject(RedisConstant.AGV_ONLINE_FLAG, pac.getHeader().getUniqueNo(), 1, 30);

                break label;

            case FAULT_REPORT: // 故障数据包

                AGV_04_UP agv_04_up = (AGV_04_UP) pac.getBody().getMessageBody();
                redis.push(RedisConstant.AGV_DATA_FLAG, AgvProtocol.build(uniqueNo).setMessageBody(agv_04_up));


                break label;

            default:
                break label;
        }
        return true;
    }


    /**
     * 服务器是否需要应答
     */
    public static ProtocolType isNeedAck(AgvPackage pac) {
        switch (pac.getHeader().getProtocolType()) {
            case ACTION_COMPLETE:
                return ProtocolType.ACTION_SUCCESS_ACK;
            case LOGIN_REPORT:
                return ProtocolType.LOGIN_ACK;
            default:
                return null;
        }
    }




}