package com.ld.igds.protocol.zldz.command;

import com.ld.igds.io.RemoteCommonService;
import com.ld.igds.io.constant.OrderRespEnum;
import com.ld.igds.io.request.*;
import com.ld.igds.io.response.BaseResponse;
import com.ld.igds.io.response.GrainResponse;
import com.ld.igds.protocol.zldz.command.builder.*;
import com.ld.igds.protocol.zldz.command.message.Message;
import com.ld.igds.protocol.zldz.task.CommandReSendService;
import com.ld.igds.protocol.zldz.task.CommandTask;
import com.ld.igds.protocol.zldz.util.ServerUtils;
import com.ld.io.api.InvokeResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 当前协议实现，粮情模块命令接口
 *
 * @author jiazx
 */
@Slf4j
@Component(RemoteCommonImpl.BEAN_ID)
public class RemoteCommonImpl extends BaseRemoteImpl implements RemoteCommonService {

    public static final String BEAN_ID = "zldz.remoteCommonService";

    @Autowired
    private CommandReSendService commandReSendService;

    @Override
    public BaseResponse heartBeat(BaseRequest request) {
        return new GrainResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public BaseResponse pullDevice(BaseRequest request) {
        return new GrainResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public BaseResponse pullDepot(BaseRequest request) {
        return new GrainResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public BaseResponse pullAccess(AccessRequest request) {
        return new GrainResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }

    @Override
    public BaseResponse pullDepotStatus(DepotStatusRequest request) {
        return new GrainResponse(OrderRespEnum.ORDER_ERROR.getCode(), "协议不支持");
    }


    @Override
    public BaseResponse checkTh(CheckThRequest request) {
        try {
            Message message = CommandBuilder1128.getInstance().buildMessage(request);

            log.info("平台------>>>分机：" + request.getSerName() + "-温湿度命令信息=" + message.toString());

            // 发送命令
            InvokeResult result = send(request.getIp(), request.getPort(), message.getByteMsg());

            // 封装返回信息
            if (InvokeResult.SUCCESS == result) {
                return new BaseResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                        "分机=" + request.getSerName() + "发送温湿度命令成功");
            } else {
                return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                        "分机=" + request.getSerName() + "发送温湿度命令失败：" + result.getMessage());
            }


        } catch (Exception e) {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "分机=" + request.getSerName() + "温湿度命令失败：" + e.getMessage());
        }
    }

    @Override
    public BaseResponse writeConf(GrainSerConfRequest request) {
        try {
            // Step1 生成命令
            Message message = CommandBuilder1116_1.getInstance().buildMessage(request);

            log.info("平台------>>>分机：" + request.getSerName() + "-写入配置命令=" + message.toString());

            // 发送命令
            InvokeResult result = send(request.getIp(), request.getPort(), message.getByteMsg());

            // 封装返回信息
            if (InvokeResult.SUCCESS == result) {

                CommandTask commandData = new CommandTask();
                commandData.setCompanyId(request.getCompanyId());
                commandData.setIp(request.getIp());
                commandData.setPort(request.getPort());
                commandData.setByteCommand(message.getByteMsg());
                commandData.setCommand(message.getStrMsg());
                commandData.setResultType(ServerUtils.MSG_TYPE_8816);
                commandReSendService.reSendTask(commandData);

                return new BaseResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                        "分机=" + request.getSerName() + "写入配置命令发送成功");
            } else {
                return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                        "分机=" + request.getSerName() + "写入配置命令发送异常：" + result.getMessage());
            }

        } catch (Exception e) {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "分机=" + request.getSerName() + "写入配置命令发送异常：" + e.getMessage());
        }
    }

    @Override
    public BaseResponse readConf(GrainSerConfRequest request) {
        try {
            // Step1 生成命令
            Message message = CommandBuilder1116_0.getInstance().buildMessage(request);

            log.info("平台------>>>分机：" + request.getSerName() + "-读取配置命令=" + message.toString());

            // 发送命令
            InvokeResult result = send(request.getIp(), request.getPort(), message.getByteMsg());

            // 封装返回信息
            if (InvokeResult.SUCCESS == result) {
                CommandTask commandData = new CommandTask();
                commandData.setCompanyId(request.getCompanyId());
                commandData.setIp(request.getIp());
                commandData.setPort(request.getPort());
                commandData.setByteCommand(message.getByteMsg());
                commandData.setCommand(message.getStrMsg());
                commandData.setResultType(ServerUtils.MSG_TYPE_8816);
                commandReSendService.reSendTask(commandData);

                return new GrainResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                        "分机=" + request.getSerName() + "读取配置命令发送成功");
            } else {

                return new GrainResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                        "分机=" + request.getSerName() + "读取配置命令发送异常：" + result.getMessage());
            }
        } catch (Exception e) {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "分机=" + request.getSerName() + "读取配置命令发送异常：" + e.getMessage());
        }
    }

    @Override
    public BaseResponse initCable(BaseRequest request) {
        try {
            // Step1 生成粮情信息
            Message message = CommandBuilder1122.getInstance().buildMessage(request);

            log.info("平台------>>>分机：" + request.getSerName() + "-初始化电缆命令=" + message.toString());

            // 发送命令
            InvokeResult result = send(request.getIp(), request.getPort(),
                    message.getByteMsg());

            // 封装返回信息
            if (InvokeResult.SUCCESS == result) {
                CommandTask commandData = new CommandTask();
                commandData.setCompanyId(request.getCompanyId());
                commandData.setIp(request.getIp());
                commandData.setPort(request.getPort());
                commandData.setByteCommand(message.getByteMsg());
                commandData.setCommand(message.getStrMsg());
                commandData.setResultType(ServerUtils.MSG_TYPE_8822);
                commandReSendService.reSendTask(commandData);

                return new BaseResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                        "分机=" + request.getSerName() + "初始化电缆发送成功");
            } else {
                return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                        "分机=" + request.getSerName() + "初始化电缆命令发送失败：" + result.getMessage());
            }
        } catch (Exception e) {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "分机=" + request.getSerName() + "初始化电缆命令执行失败：" + e.getMessage());
        }
    }

    @Override
    public BaseResponse updateGrainSerCable(GrainSerConfRequest request) {
        if (null == request.getEditTag()) {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "当前操作没有制定修改标识，无法执行！");
        }

        //根据修改标识处理不同的逻辑 -- 2点号修改 3列号修改，4根号修改，5同步电缆，6根号替换
        if (2 == request.getEditTag()) {
            return updateGrainSerCable2(request);
        }
        if (3 == request.getEditTag()) {
            return updateGrainSerCable3(request);
        }
        if (4 == request.getEditTag()) {
            return updateGrainSerCable4(request);
        }
        if (5 == request.getEditTag()) {
            return updateGrainSerCable5(request);
        }
        if (6 == request.getEditTag()) {
            return updateGrainSerCable6(request);
        }
        return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                "没有匹配到当前需要操作的标识，标识=" + request.getEditTag());
    }

    /**
     * 根号替换
     *
     * @param request
     * @return
     */
    private BaseResponse updateGrainSerCable6(GrainSerConfRequest request) {
        if (null == request.getValue1() || null == request.getValue2()) {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "替换操作中，没有获取到新旧参数配置！");
        }

        // Step1
        Message message = CommandBuilder1126.getInstance().buildMessage(request);

        log.info("平台------>>>分机：" + request.getSerName() + "电缆-根号替换命令=" + message.toString());

        // 发送命令
        InvokeResult result = send(request.getIp(), request.getPort(),
                message.getByteMsg());

        // 封装返回信息
        if (InvokeResult.SUCCESS == result) {
            return new BaseResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                    "分机=" + request.getSerName() + "电缆-根号替换发送成功！");
        } else {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "分机=" + request.getSerName() + "电缆-根号替换发送失败：" + result.getMessage());
        }

    }

    /**
     * @param request
     * @return
     */
    private BaseResponse updateGrainSerCable5(GrainSerConfRequest request) {
        if (null == request.getValue1() || null == request.getValue2()) {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "同步电缆失败，同步电缆参数不完整");
        }


        // Step1
        Message message = CommandBuilder1126.getInstance().buildMessage(request);

        log.info("平台------>>>分机：" + request.getSerName() + "同步电缆-命令=" + message.toString());

        // 发送命令
        InvokeResult result = send(request.getIp(), request.getPort(),
                message.getByteMsg());

        // 封装返回信息
        if (InvokeResult.SUCCESS == result) {
            return new BaseResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                    "分机=" + request.getSerName() + "电缆-根号替换发送成功！");
        } else {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "分机=" + request.getSerName() + "电缆-根号替换发送失败：" + result.getMessage());
        }
    }

    private BaseResponse updateGrainSerCable4(GrainSerConfRequest request) {
        if (null == request.getValue1() || null == request.getValue2()) {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "替换操作中，没有获取到新旧参数配置！");
        }

        //输入值需要-1
        request.setValue1(request.getValue1() - 1);
        request.setValue2(request.getValue2() - 1);

        // Step1
        Message message = CommandBuilder1126.getInstance().buildMessage(request);

        log.info("平台------>>>分机：" + request.getSerName() + "-电缆-根号修改命令=" + message.toString());

        // 发送命令
        InvokeResult result = send(request.getIp(), request.getPort(),
                message.getByteMsg());

        // 封装返回信息
        if (InvokeResult.SUCCESS == result) {
            return new BaseResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                    "分机=" + request.getSerName() + "电缆-根号修改命令发送成功！");
        } else {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "分机=" + request.getSerName() + "电缆-根号修改命令发送失败：" + result.getMessage());
        }
    }

    private BaseResponse updateGrainSerCable3(GrainSerConfRequest request) {

        if (null == request.getEditCol()) {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "替换操作中，没有获取列参数！");
        }

        // Step1
        Message message = CommandBuilder1126.getInstance().buildMessage(request);

        log.info("平台------>>>分机：" + request.getSerName() + "电缆-列号修改命令=" + message.toString());

        // 发送命令
        InvokeResult result = send(request.getIp(), request.getPort(),
                message.getByteMsg());

        // 封装返回信息
        if (InvokeResult.SUCCESS == result) {
            return new BaseResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                    "分机=" + request.getSerName() + "电缆-列号修改命令发送成功！");
        } else {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "分机=" + request.getSerName() + "电缆-列号修改命令发送失败：" + result.getMessage());
        }
    }

    private BaseResponse updateGrainSerCable2(GrainSerConfRequest request) {

        if (null == request.getValue1() || null == request.getValue2()) {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "替换操作中，没有获取到新旧参数配置！");
        }

        //输入值需要-1
        request.setValue1(request.getValue1() - 1);
        request.setValue2(request.getValue2() == null ? 0 : request.getValue2());

        // Step1 生成命令
        Message message = CommandBuilder1126.getInstance().buildMessage(request);

        log.info("平台------>>>分机：" + request.getSerName() + "电缆-点号修改命令=" + message.toString());

        // 发送命令
        InvokeResult result = send(request.getIp(), request.getPort(), message.getByteMsg());

        // 封装返回信息
        if (InvokeResult.SUCCESS == result) {
            return new BaseResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                    "分机=" + request.getSerName() + "电缆-点号修改命令发送成功！");
        } else {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "分机=" + request.getSerName() + "电缆-点号修改命令发送失败：" + result.getMessage());
        }
    }


    /**
     * 获取通道电缆
     *
     * @param request
     * @return
     */
    @Override
    public BaseResponse checkGrainSerCable(GrainSerConfRequest request) {

        // Step1 生成粮情信息
        Message message = CommandBuilder1125.getInstance().buildMessage(request);

        log.info("平台------>>>分机：" + request.getSerName() + "获取通道电缆命令=" + message.toString());

        // 发送命令
        InvokeResult result = send(request.getIp(), request.getPort(), message.getByteMsg());

        // 封装返回信息
        if (InvokeResult.SUCCESS == result) {
            return new BaseResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                    "分机=" + request.getSerName() + "获取通道电缆命令发送成功！");
        } else {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "分机=" + request.getSerName() + "获取通道电缆命令发送失败：" + result.getMessage());
        }

    }


    @Override
    public BaseResponse destroyCon(BaseRequest request) {
        InvokeResult result = destory(request.getIp(), request.getPort());
        if (InvokeResult.SUCCESS == result) {
            return new BaseResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                    "分机=" + request.getSerName() + "断开连接执行成功");
        } else {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(), "分机=" + request.getSerName() + "断开连接失败：" + result.getMessage());
        }
    }

    @Override
    public BaseResponse updateSysDepotConf(BaseRequest request) {
        return new BaseResponse(OrderRespEnum.NO_FUNCTION);
    }

    @Override
    public BaseResponse sumGrainSerCable(GrainSerConfRequest request) {
        // Step1
        Message message = CommandBuilder1123.getInstance().buildMessage(request);

        log.info("平台------>>>分机：" + request.getSerName() + "电缆汇总命令=" + message.toString());

        // 发送命令
        InvokeResult result = send(request.getIp(), request.getPort(), message.getByteMsg());

        // 封装返回信息
        if (InvokeResult.SUCCESS == result) {
            return new BaseResponse(OrderRespEnum.ORDER_SUCCESS.getCode(),
                    "分机=" + request.getSerName() + "电缆汇总命令发送成功！");
        } else {
            return new BaseResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                    "分机=" + request.getSerName() + "电缆汇总命令发送失败：" + result.getMessage());
        }
    }


}