package com.dy.pipIrrRemote.rtu;

import com.alibaba.fastjson2.JSONObject;
import com.dy.common.aop.SsoAop;
import com.dy.common.mw.protocol.p206V1_0_0.CodeV1_0_1;
import com.dy.common.mw.protocol.p206V1_0_0.downVos.Com97Vo;
import com.dy.common.mw.protocol.p206V202404.CodeV202404;
import com.dy.common.mw.protocol.p206V202404.downVos.*;
import com.dy.common.util.IDLongGenerator;
import com.dy.common.webUtil.BaseResponse;
import com.dy.common.webUtil.BaseResponseUtils;
import com.dy.pipIrrGlobal.command.ComSupport;
import com.dy.pipIrrGlobal.command.dto.Param;
import com.dy.pipIrrRemote.common.CommandSv;
import com.dy.pipIrrRemote.common.dto.*;
import com.dy.pipIrrRemote.result.RemoteResultCode;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Objects;
import java.util.Optional;

/**
 * @author ZhuBaoMin
 * @date 2024-05-21 14:31
 * @LastEditTime 2024-05-21 14:31
 * @Description 设备终端控制类
 */

@Slf4j
@RestController
@RequestMapping(path="rtu")
@RequiredArgsConstructor
public class RtuCtrl extends ComSupport {
    private final CommandSv commandSv;
    private final IDLongGenerator idLongGenerator;

    @Value("${mw.rtuCallbackUrl_rm}")
    private String rtuCallbackUrl_rm;

    /**
     * 通用处理接口
     * 97   清除用水记录
     * 98   清除充值记录
     * 99   清除日记录
     * 9A   清除年用水量
     * 50   查询终端地址
     * @param po
     * @param bindingResult
     * @return
     */
    @PostMapping(path = "common_deal", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop()
    public BaseResponse<Boolean> commonDeal(@RequestBody @Valid CommandDeal po, BindingResult bindingResult) {
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        Long intakeId = po.getIntakeId();
        Long operator = po.getOperator();
        Long comId = idLongGenerator.generate();

        // 获取系统参数
        if(!setuped) {
            setUp();
        }

        // 取水口ID换阀控器地址及通讯协议
        JSONObject job_rtu = getRtu(intakeId, null);
        if(job_rtu == null) {
            return BaseResponseUtils.buildErrorMsg(RemoteResultCode.RTU_NOT_EXIST.getMessage());
        }
        String rtuAddr = job_rtu.getString("rtuAddr");
        String protocol = job_rtu.getString("protocol");

        // 获取功能码
        String commandCode = po.getCommandCode();
        if(protocol.equals("p206V202404")) {
            // 创建视图
            ComCdXyVo param = new ComCdXyVo();
            param.controllerType = controllerType;
            param.projectNo = projectNo;

            /**
             * 构造命令、发送命令并处理请求结果及执行结果
             * 1 准备参数
             * 2 调用公共方法
             */
            Param myParam = new Param();
            myParam.setComId(comId);
            myParam.setCommandCode(commandCode);
            myParam.setCommandName(CodeV202404.getCodeName(commandCode));
            myParam.setIntakeId(intakeId);
            myParam.setRtuAddr(rtuAddr);
            myParam.setProtocol(protocol);
            myParam.setParam(param);
            myParam.setRtuResultSendWebUrl(rtuCallbackUrl_rm);
            myParam.setOperator(operator);
            return dealWithCommandResult(myParam);
        } else if(protocol.equals("p206V1_0_1")) {
            // 创建视图
            Com97Vo param = new Com97Vo() ;
            return BaseResponseUtils.buildSuccess("");
        } else {
            return BaseResponseUtils.buildFail("系统暂不支持该协议");
        }
    }

    /**
     * 设置设备终端地址
     * @param addr 设置设备终端地址传入对象
     * @param bindingResult
     * @return
     */
    @PostMapping(path = "set_addr", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop()
    public BaseResponse<Boolean> setAddr(@RequestBody @Valid Addr addr, BindingResult bindingResult) {
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        Long intakeId = addr.getIntakeId();
        String newRtuAddr = addr.getNewRtuAddr();
        Long operator = addr.getOperator();
        Long comId = idLongGenerator.generate();

        // 获取系统参数
        if(!setuped) {
            setUp();
        }

        // 取水口ID换阀控器地址及通讯协议
        JSONObject job_rtu = getRtu(intakeId, null);
        if(job_rtu == null) {
            return BaseResponseUtils.buildErrorMsg(RemoteResultCode.RTU_NOT_EXIST.getMessage());
        }
        String rtuAddr = job_rtu.getString("rtuAddr");
        String protocol = job_rtu.getString("protocol");

        String commandCode = null;
        if(protocol.equals("p206V202404")) {
            // 获取功能码
            commandCode = CodeV202404.cd_10;

            // 创建视图
            ComCd10Vo param = new ComCd10Vo() ;
            param.controllerType = controllerType;
            param.projectNo = projectNo;
            param.rtuNewAddr = newRtuAddr;

            /**
             * 构造命令、发送命令并处理请求结果及执行结果
             * 1 准备参数
             * 2 调用公共方法
             */
            Param myParam = new Param();
            myParam.setComId(comId);
            myParam.setCommandCode(commandCode);
            myParam.setCommandName(CodeV202404.getCodeName(commandCode));
            myParam.setIntakeId(intakeId);
            myParam.setRtuAddr(rtuAddr);
            myParam.setProtocol(protocol);
            myParam.setParam(param);
            myParam.setRtuResultSendWebUrl(rtuCallbackUrl_rm);
            myParam.setOperator(operator);
            return dealWithCommandResult(myParam);
        } else if(protocol.equals("p206V1_0_1")) {
            // 获取功能码
            commandCode = CodeV1_0_1.cd_10;

            // 创建视图
            Com97Vo param = new Com97Vo() ;
            return BaseResponseUtils.buildSuccess("");
        } else {
            return BaseResponseUtils.buildFail("系统暂不支持该协议");
        }
    }

    /**
     * 设置设备终端剩余水量和剩余金额报警值
     * @param po
     * @param bindingResult
     * @return
     */
    @PostMapping(path = "set_alarm", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop()
    public BaseResponse<Boolean> setAlarm(@RequestBody @Valid Alarm po, BindingResult bindingResult) {
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        Long intakeId = po.getIntakeId();
        Integer waterAlarm = Optional.ofNullable(po.getWaterAlarm()).orElse(0);
        Integer moneyAlarm = Optional.ofNullable(po.getMoneyAlarm()).orElse(0);
        Long operator = po.getOperator();
        Long comId = idLongGenerator.generate();

        // 获取系统参数
        if(!setuped) {
            setUp();
        }

        // 取水口ID换阀控器地址及通讯协议
        JSONObject job_rtu = getRtu(intakeId, null);
        if(job_rtu == null) {
            return BaseResponseUtils.buildErrorMsg(RemoteResultCode.RTU_NOT_EXIST.getMessage());
        }
        String rtuAddr = job_rtu.getString("rtuAddr");
        String protocol = job_rtu.getString("protocol");

        String commandCode = null;
        if(protocol.equals("p206V202404")) {
            // 获取功能码
            commandCode = CodeV202404.cd_16;

            // 创建视图
            ComCd16Vo param = new ComCd16Vo();
            param.controllerType = controllerType;
            param.projectNo = projectNo;
            param.waterAlarm = waterAlarm;
            param.moneyAlarm = moneyAlarm;

            /**
             * 构造命令、发送命令并处理请求结果及执行结果
             * 1 准备参数
             * 2 调用公共方法
             */
            Param myParam = new Param();
            myParam.setComId(comId);
            myParam.setCommandCode(commandCode);
            myParam.setCommandName(CodeV202404.getCodeName(commandCode));
            myParam.setIntakeId(intakeId);
            myParam.setRtuAddr(rtuAddr);
            myParam.setProtocol(protocol);
            myParam.setParam(param);
            myParam.setRtuResultSendWebUrl(rtuCallbackUrl_rm);
            myParam.setOperator(operator);
            return dealWithCommandResult(myParam);
        } else if(protocol.equals("p206V1_0_1")) {
            // 获取功能码
            commandCode = CodeV1_0_1.cd_10;

            // 创建视图
            Com97Vo param = new Com97Vo() ;
            return BaseResponseUtils.buildSuccess("");
        } else {
            return BaseResponseUtils.buildFail("系统暂不支持该协议");
        }
    }

    /**
     * 设置机井年最大开采量和水位下限
     * @param po
     * @param bindingResult
     * @return
     */
    @PostMapping(path = "set_well", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop()
    public BaseResponse<Boolean> setWell(@RequestBody @Valid DrivenWell po, BindingResult bindingResult) {
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        Long intakeId = po.getIntakeId();
        Integer maxAmountYear = Optional.ofNullable(po.getMaxAmountYear()).orElse(0);
        Double limitLevel = Optional.ofNullable(po.getLimitLevel()).orElse(0.0);
        Long operator = po.getOperator();
        Long comId = idLongGenerator.generate();

        // 获取系统参数
        if(!setuped) {
            setUp();
        }

        // 取水口ID换阀控器地址及通讯协议
        JSONObject job_rtu = getRtu(intakeId, null);
        if(job_rtu == null) {
            return BaseResponseUtils.buildErrorMsg(RemoteResultCode.RTU_NOT_EXIST.getMessage());
        }
        String rtuAddr = job_rtu.getString("rtuAddr");
        String protocol = job_rtu.getString("protocol");

        String commandCode = null;
        if(protocol.equals("p206V202404")) {
            // 获取功能码
            commandCode = CodeV202404.cd_22;

            // 创建视图
            ComCd22Vo param = new ComCd22Vo();
            param.controllerType = controllerType;
            param.projectNo = projectNo;
            param.maxAmountYear = maxAmountYear;
            param.limitLevel = limitLevel;

            /**
             * 构造命令、发送命令并处理请求结果及执行结果
             * 1 准备参数
             * 2 调用公共方法
             */
            Param myParam = new Param();
            myParam.setComId(comId);
            myParam.setCommandCode(commandCode);
            myParam.setCommandName(CodeV202404.getCodeName(commandCode));
            myParam.setIntakeId(intakeId);
            myParam.setRtuAddr(rtuAddr);
            myParam.setProtocol(protocol);
            myParam.setParam(param);
            myParam.setRtuResultSendWebUrl(rtuCallbackUrl_rm);
            myParam.setOperator(operator);
            return dealWithCommandResult(myParam);
        } else if(protocol.equals("p206V1_0_1")) {
            // 获取功能码
            commandCode = CodeV1_0_1.cd_10;

            // 创建视图
            Com97Vo param = new Com97Vo() ;
            return BaseResponseUtils.buildSuccess("");
        } else {
            return BaseResponseUtils.buildFail("系统暂不支持该协议");
        }
    }

    /**
     * 设置设备终端年用水量
     * @param po
     * @param bindingResult
     * @return
     */
    @PostMapping(path = "set_max_amount", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop()
    public BaseResponse<Boolean> setMaxAmount(@RequestBody @Valid WaterConsumption po, BindingResult bindingResult) {
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        Long intakeId = po.getIntakeId();
        Integer maxAmountYear = Optional.ofNullable(po.getMaxAmountYear()).orElse(0);
        Long operator = po.getOperator();
        Long comId = idLongGenerator.generate();

        // 获取系统参数
        if(!setuped) {
            setUp();
        }

        // 取水口ID换阀控器地址及通讯协议
        JSONObject job_rtu = getRtu(intakeId, null);
        if(job_rtu == null) {
            return BaseResponseUtils.buildErrorMsg(RemoteResultCode.RTU_NOT_EXIST.getMessage());
        }
        String rtuAddr = job_rtu.getString("rtuAddr");
        String protocol = job_rtu.getString("protocol");

        String commandCode = null;
        if(protocol.equals("p206V202404")) {
            // 获取功能码
            commandCode = CodeV202404.cd_26;

            // 创建视图
            ComCd26Vo param = new ComCd26Vo();
            param.controllerType = controllerType;
            param.projectNo = projectNo;
            param.maxAmountYear = maxAmountYear;

            /**
             * 构造命令、发送命令并处理请求结果及执行结果
             * 1 准备参数
             * 2 调用公共方法
             */
            Param myParam = new Param();
            myParam.setComId(comId);
            myParam.setCommandCode(commandCode);
            myParam.setCommandName(CodeV202404.getCodeName(commandCode));
            myParam.setIntakeId(intakeId);
            myParam.setRtuAddr(rtuAddr);
            myParam.setProtocol(protocol);
            myParam.setParam(param);
            myParam.setRtuResultSendWebUrl(rtuCallbackUrl_rm);
            myParam.setOperator(operator);
            return dealWithCommandResult(myParam);
        } else if(protocol.equals("p206V1_0_1")) {
            // 获取功能码
            commandCode = CodeV1_0_1.cd_10;

            // 创建视图
            Com97Vo param = new Com97Vo() ;
            return BaseResponseUtils.buildSuccess("");
        } else {
            return BaseResponseUtils.buildFail("系统暂不支持该协议");
        }
    }

    /**
     * 设置设备终端IP地址
     * @param po
     * @param bindingResult
     * @return
     */
    @PostMapping(path = "set_ip", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop()
    public BaseResponse<Boolean> setIp(@RequestBody @Valid Domain po, BindingResult bindingResult) {
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        Long intakeId = po.getIntakeId();
        Integer channel = po.getChannel();
        String ip = po.getIp();
        Integer port = po.getPort();
        Long operator = po.getOperator();
        Long comId = idLongGenerator.generate();

        // 获取系统参数
        if(!setuped) {
            setUp();
        }

        // 取水口ID换阀控器地址及通讯协议
        JSONObject job_rtu = getRtu(intakeId, null);
        if(job_rtu == null) {
            return BaseResponseUtils.buildErrorMsg(RemoteResultCode.RTU_NOT_EXIST.getMessage());
        }
        String rtuAddr = job_rtu.getString("rtuAddr");
        String protocol = job_rtu.getString("protocol");

        String commandCode = null;
        if(protocol.equals("p206V202404")) {
            // 获取功能码
            commandCode = CodeV202404.cd_21;

            // 创建视图
            ComCd21Vo param = new ComCd21Vo();
            param.controllerType = controllerType;
            param.projectNo = projectNo;
            param.channel = channel;
            param.ip = ip;
            param.port = port;

            /**
             * 构造命令、发送命令并处理请求结果及执行结果
             * 1 准备参数
             * 2 调用公共方法
             */
            Param myParam = new Param();
            myParam.setComId(comId);
            myParam.setCommandCode(commandCode);
            myParam.setCommandName(CodeV202404.getCodeName(commandCode));
            myParam.setIntakeId(intakeId);
            myParam.setRtuAddr(rtuAddr);
            myParam.setProtocol(protocol);
            myParam.setParam(param);
            myParam.setRtuResultSendWebUrl(rtuCallbackUrl_rm);
            myParam.setOperator(operator);
            return dealWithCommandResult(myParam);
        } else if(protocol.equals("p206V1_0_1")) {
            // 获取功能码
            commandCode = CodeV1_0_1.cd_10;

            // 创建视图
            Com97Vo param = new Com97Vo() ;
            return BaseResponseUtils.buildSuccess("");
        } else {
            return BaseResponseUtils.buildFail("系统暂不支持该协议");
        }
    }

    /**
     * 设置设备终端域名
     * @param po
     * @param bindingResult
     * @return
     */
    @PostMapping(path = "set_domain", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop()
    public BaseResponse<Boolean> setDomain(@RequestBody @Valid Domain po, BindingResult bindingResult) {
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        Long intakeId = po.getIntakeId();
        Integer channel = po.getChannel();
        String domain = po.getDomain();
        Integer port = po.getPort();
        Long operator = po.getOperator();
        Long comId = idLongGenerator.generate();

        // 获取系统参数
        if(!setuped) {
            setUp();
        }

        // 取水口ID换阀控器地址及通讯协议
        JSONObject job_rtu = getRtu(intakeId, null);
        if(job_rtu == null) {
            return BaseResponseUtils.buildErrorMsg(RemoteResultCode.RTU_NOT_EXIST.getMessage());
        }
        String rtuAddr = job_rtu.getString("rtuAddr");
        String protocol = job_rtu.getString("protocol");

        String commandCode = null;
        if(protocol.equals("p206V202404")) {
            // 获取功能码
            commandCode = CodeV202404.cd_23;

            // 创建视图
            ComCd23Vo param = new ComCd23Vo();
            param.controllerType = controllerType;
            param.projectNo = projectNo;
            param.channel = channel;
            param.domain = domain;
            param.port = port;

            /**
             * 构造命令、发送命令并处理请求结果及执行结果
             * 1 准备参数
             * 2 调用公共方法
             */
            Param myParam = new Param();
            myParam.setComId(comId);
            myParam.setCommandCode(commandCode);
            myParam.setCommandName(CodeV202404.getCodeName(commandCode));
            myParam.setIntakeId(intakeId);
            myParam.setRtuAddr(rtuAddr);
            myParam.setProtocol(protocol);
            myParam.setParam(param);
            myParam.setRtuResultSendWebUrl(rtuCallbackUrl_rm);
            myParam.setOperator(operator);
            return dealWithCommandResult(myParam);
        } else if(protocol.equals("p206V1_0_1")) {
            // 获取功能码
            commandCode = CodeV1_0_1.cd_10;

            // 创建视图
            Com97Vo param = new Com97Vo() ;
            return BaseResponseUtils.buildSuccess("");
        } else {
            return BaseResponseUtils.buildFail("系统暂不支持该协议");
        }
    }
}