package com.dy.pipIrrRemote.monitor.p202404V201.cdA3;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.dy.common.aop.SsoAop;
import com.dy.common.mw.protocol.Command;
import com.dy.common.mw.protocol.p206V202404.upVos.DataCd93_A3Vo;
import com.dy.common.util.Callback;
import com.dy.common.webUtil.BaseResponse;
import com.dy.common.webUtil.BaseResponseUtils;
import com.dy.pipIrrGlobal.voRm.VoUnclosedParam;
import com.dy.pipIrrRemote.common.dto.DtoBase;
import com.dy.pipIrrRemote.monitor.common.ComCtrl;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.http.MediaType;
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;

/**
 * @Author: liurunyu
 * @Date: 2025/5/15 09:23
 * @Description
 */
@Slf4j
@Tag(name = "远程命令", description = "App远程关阀")
@RestController("cdA3Ctrl")
@RequestMapping(path = "p202404V201/cdA3")
@RequiredArgsConstructor
@Scope("prototype") //因为有对象类属性，所以采用原型模式，每次请求新建一个实例对象
public class CdCtrl extends ComCtrl {

    private static final String RtuSuccessMsg = "控制器接收并执行命令成功，无返回数据";

    private static final String ComCode = "A3" ;

    @Autowired
    private CdSv sv ;
    /**
     * 向设备（控制器）发送命令
     * @param dto 前端发来的值对象
     * @param bindingResult 对dto验证的结果
     * @return 返回前端
     */
    @PostMapping(path = "send", consumes = MediaType.APPLICATION_JSON_VALUE)
    @SsoAop()
    public BaseResponse<Object> send(@RequestBody @Valid CdDto dto, BindingResult bindingResult) {
        BaseResponse<Object> res ;
        //发送命令前-1：验证
        res = super.pre1(sv, ComCode, dto, bindingResult);
        if(res == null) {
            //发送命令前-2：获得数据
            res = super.pre2(sv, ComCode, dto, bindingResult);
            if (res == null) {
                //获取开阀命令参数
                VoUnclosedParam opPa = sv.selectUncloseParam(dto.getIntakeId(), ctrlPo.getRtuAddr());
                if(opPa == null) {
                    return BaseResponseUtils.buildFail("该取水口上无您最近的开阀操作");
                }
                Long vcId = sv.getVcIdByNum(opPa.getVcNum()) ;
                if(vcId == null) {
                    return BaseResponseUtils.buildFail("服务端出错，未得到虚拟卡ID");
                }
                //发送命令前-3：保存命令日志
                CdParam comParam = CdParam.builder().commandCode(ComCode).projectNo(projectNo).controllerType(controllerType)
                        .icCardNo(opPa.getVcNum())//用户卡序列号（17位数字）（6字节BCD，2字节HEX）
                        .orderNo(opPa.getOrderNo())//订单号（16位数字）
                        .build();
                res = super.pre3(sv, dto.getIntakeId(), dto.getOperator(), ComCode, comParam);
                if (res == null) {
                    //发送命令前-4：准备Feature
                    super.pre4();
                    try {
                        //创建外部命令（发给控制器）
                        Command com = sv.createOuterCommand(ctrlPo.getRtuAddr(), "" + comId, ComCode);
                        com.rtuResultSendWebUrl = rtuResultSendWebUrl;
                        com.param = comParam;
                        //发送命令
                        res = super.doSend(sv, com);
                        if (res == null) {
                            //发送命令后
                            res = super.after(ComCode, new Callback() {
                                @Override
                                public void call(Object obj) {
                                    Boolean success = (Boolean) obj;
                                    if(success){
                                        //关阀成功，解除虚拟卡被占用
                                        sv.setVcNoUsed(vcId);
                                    }
                                }
                                @Override
                                public void call(Object... objs) {
                                }
                                @Override
                                public void exception(Exception e) {
                                }
                            });
                        }
                    } catch (Exception e) {
                        res = BaseResponseUtils.buildFail("服务端构造并向通信中间件发送请求时异常" + (e.getMessage() == null ? "" : e.getMessage()));
                    } finally {
                        //最终
                        super.end();
                    }
                }
            }
        }
        return res ;
    }

    @Override
    protected String checkDto(DtoBase dto) {
        return null;
    }

    @Override
    protected String dealComResult(String code, JSONObject resultData, Callback callback){
        String msg;
        if(resultData != null){
            JSONObject codeData = resultData.getJSONObject("data") ;
            if(codeData == null){
                msg = RtuSuccessMsg ;
            }else {
                String json = codeData.toJSONString();
                DataCd93_A3Vo cvo = JSON.parseObject(json, DataCd93_A3Vo.class) ;
                if(cvo != null){
                    if(callback != null){
                        if(cvo.clResult != null && cvo.clResult == 0){
                            callback.call(true);//关阀成功
                        }else{
                            callback.call(false);//关阀失败
                        }
                    }
                    msg = cvo.toStr(false) ;
                }else{
                    msg = RtuSuccessMsg ;
                }
            }
        }else{
            msg = RtuSuccessMsg ;
        }
        return msg;
    }
}