package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.whyc.constant.CMD_Constant;
import com.whyc.dto.BattRtSetDto;
import com.whyc.dto.DevalarmSet;
import com.whyc.dto.Response;
import com.whyc.mapper.CKPowerDevBattRtDataSetMapper;
import com.whyc.mapper.CKPowerDevBattRtStateSetMapper;
import com.whyc.mapper.CKPowerDevBattSetLogMapper;
import com.whyc.mapper.CkpowerdevBattRsalarmSetMapper;
import com.whyc.pojo.db_ckpwrdev_data_rt.*;
import com.whyc.util.OpCmdUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;

import static com.baomidou.mybatisplus.core.toolkit.Wrappers.update;

@Service
public class CKPowerDevBattRtStateSetService {

    @Resource
    private CKPowerDevBattRtStateSetMapper mapper;

    @Autowired
    private CKPowerDevBattRtDataSetService dataSetService;

    @Resource
    private CKPowerDevBattSetLogMapper setLogMapper;

    @Resource
    private CKPowerDevBattSetLogService setLogService;

    @Autowired
    private CKPowerDevBattRtDataService dataService;

    @Autowired
    private CKPowerDevBattRtStateService stateService;

    @Autowired
    private CKPowerDevBattRsAlarmService rsAlarmService;

    @Autowired
    private CkpowerdevBattRsalarmSetService rsAlarmSetService;

    @Resource
    private CkpowerdevBattRsalarmSetMapper rsalarmSetMapper;

    @Autowired(required = false)
    private CKPowerDevBattRtDataSetMapper rtDataSetMapper;

    public Response updateMon(BattRtSetDto setDto) {
        List<CKPowerDevBattRtDataSet> dataSetList = setDto.getDataSetList();
        Integer battIndex = dataSetList.get(0).getBattIndex();
        //CkpowerdevBattRsalarmSet rsAlarmSet = setDto.getRsAlarmSet();
        //查询data和state表数据并设置到对应的set表
        updateDataFromDataAndStateAndAlarmToSet(dataSetList);
        //设置state_set表,与李军沟通确定,组端和单体设置,都采用设置下面这个cmd值.因为单体和组端会一起设置
        int opCmd;
        if(battIndex == 0) {
            opCmd = CMD_Constant.CMD_SetBatt1MonData;
        }else if(battIndex == 1){
            opCmd =CMD_Constant.CMD_SetBatt2MonData;
        }else{
            return new Response().set(0,"未指定具体的电池组或电池组超出2组,无法设置");
        }
        //设置data_set表
        dataSetService.updateBatch(dataSetList);
        //设置state_set表
        CKPowerDevBattRtStateSet stateSet = new CKPowerDevBattRtStateSet();
        stateSet.setBattIndex(battIndex);
        stateSet.setOpCmd(opCmd);
        update(stateSet);
        //设置rsalarm_set
        //rsAlarmSetService.update(rsAlarmSet);
        //读取opCmd返回是否成功
        QueryWrapper<CKPowerDevBattRtStateSet> query = Wrappers.query();
        Response opStatus =OpCmdUtil.getOpStatus(mapper, query, opCmd,20,battIndex);
        if(opStatus.getData()!=null && (boolean)opStatus.getData()) { //成功
            //记录日志
            Date now = new Date();
            List<CKPowerDevBattSetLog> logList = setDto.getLogList();
            //查询最大的操作编号
            String opNum=setLogMapper.getOpNum()!=null?setLogMapper.getOpNum():"0";
            logList.forEach(log->{
                log.setOpNum(String.valueOf(Integer.valueOf(opNum)+1));
                log.setCmdType(stateSet.getOpCmd());
                log.setBattIndex(stateSet.getBattIndex());
                log.setCreateTime(now);
                log.setCreateDay(now);
            });
            setLogService.addBatch(logList);
        }
        return opStatus;
    }

    public Response updateGroup(CKPowerDevBattRtStateSet stateSet) {
        //查询state表数据并设置到对应的set表
        updateDataFromStateToSet(stateSet.getBattIndex());
        //设置state_set表,与李军沟通确定,组端和单体设置,都采用设置下面这个cmd值.因为单体和组端会一起设置
        if(stateSet.getBattIndex() == 0) {
            stateSet.setOpCmd(CMD_Constant.CMD_SetBatt1MonData);
        }else if(stateSet.getBattIndex() == 1){
            stateSet.setOpCmd(CMD_Constant.CMD_SetBatt2MonData);
        }else{
            return new Response().set(0,"未指定具体的电池组或电池组超出2组,无法设置");
        }
        update(stateSet);
        //读取opCmd返回是否成功
        QueryWrapper<CKPowerDevBattRtStateSet> query = Wrappers.query();
        Response opStatus =OpCmdUtil.getOpStatus(mapper, query, stateSet.getOpCmd(),20,stateSet.getBattIndex());
        if(opStatus.getData()!=null && (boolean)opStatus.getData()) { //成功
            //记录日志
            Date now = new Date();
            List<CKPowerDevBattSetLog> logList = stateSet.getLogList();
            //查询最大的操作编号
            String opNum=setLogMapper.getOpNum()!=null?setLogMapper.getOpNum():"0";
            logList.forEach(log->{
                log.setOpNum(String.valueOf(Integer.valueOf(opNum)+1));
                log.setMonNum(0);
                log.setCmdType(stateSet.getOpCmd());
                log.setBattIndex(stateSet.getBattIndex());
                log.setCreateTime(now);
                log.setCreateDay(now);
            });
            setLogService.addBatch(logList);
        }
        return opStatus;
    }

    private void updateDataFromStateToSet(Integer battIndex) {
        CKPowerDevBattRtState state = stateService.get(battIndex);

        CKPowerDevBattRtStateSet stateSet = new CKPowerDevBattRtStateSet();
        BeanUtils.copyProperties(state,stateSet);
        update(stateSet);
    }

    private void updateDataFromDataAndStateAndAlarmToSet(List<CKPowerDevBattRtDataSet> dataSetList) {
        Integer battIndex = dataSetList.get(0).getBattIndex();
        List<Integer> monNumList = dataSetList.stream().map(CKPowerDevBattRtDataSet::getMonNum).collect(Collectors.toList());
        //获取实时表数据并写入set表
        List<CKPowerDevBattRtData> rtDataList = dataService.getMonList(battIndex,monNumList);
        CKPowerDevBattRtState state = stateService.get(battIndex);
        CkpowerdevBattRsalarm rsAlarm =  rsAlarmService.get();

        //属性迁移
        List<CKPowerDevBattRtDataSet> rtSetDataList = new LinkedList<>();
        CKPowerDevBattRtStateSet stateSet = new CKPowerDevBattRtStateSet();
        CkpowerdevBattRsalarmSet rsAlarmSet = new CkpowerdevBattRsalarmSet();
        for (CKPowerDevBattRtData temp : rtDataList) {
            CKPowerDevBattRtDataSet set = new CKPowerDevBattRtDataSet();
            BeanUtils.copyProperties(temp,set);
            rtSetDataList.add(set);
        }
        BeanUtils.copyProperties(state,stateSet);
        BeanUtils.copyProperties(rsAlarm,rsAlarmSet);
        //rt表数据更新到set表中
        dataSetService.updateBatch(rtSetDataList);
        update(stateSet);
        rsAlarmSetService.update(rsAlarmSet);

    }

    private void update(CKPowerDevBattRtStateSet stateSet) {
        UpdateWrapper<CKPowerDevBattRtStateSet> update = Wrappers.update();
        update.eq("batt_index",stateSet.getBattIndex());
        mapper.update(stateSet,update);
    }

    //核容终止时设置组端数据
    public Response updateStateHrStop(CKPowerDevBattRtStateSet stateSet) {
        //1.刷新rsAlarmSet，rtdataSet,rtState告警实时数据<指定默认刷第一组数据>
        rsAlarmSetService.updateDataFromDataAndStateAndRsAlarmToSetHrStop();
        //设置state_set表
        mapper.update(stateSet,null);
        //发送命令
        UpdateWrapper wrapper=new UpdateWrapper();
        wrapper.set("op_cmd",CMD_Constant.CMD_SetBattAlarm);
        rsalarmSetMapper.update(null,wrapper);
        //读取opCmd返回是否成功
        QueryWrapper<CkpowerdevBattRsalarmSet> query = Wrappers.query();
        Response opStatus = OpCmdUtil.getOpStatus(rsalarmSetMapper,query, CMD_Constant.CMD_SetBattAlarm,20,null);
        if(opStatus.getData()!=null && (boolean)opStatus.getData()) { //成功
            //记录日志
            Date now = new Date();
            List<CKPowerDevBattSetLog> logList = stateSet.getLogList();
            //查询最大的操作编号
            String opNum=setLogMapper.getOpNum()!=null?setLogMapper.getOpNum():"0";
            logList.forEach(log->{
                log.setOpNum(String.valueOf(Integer.valueOf(opNum)+1));
                log.setMonNum(0);
                log.setCmdType(CMD_Constant.CMD_SetBattAlarm);
                log.setBattIndex(0);
                log.setCreateTime(now);
                log.setCreateDay(now);
            });
            setLogService.addBatch(logList);
        }
        return opStatus;
    }

    //核容终止时设置单体数据
    public Response updateDataHrStop(BattRtSetDto setDto) {
        //1.刷新rsAlarmSet，rtdataSet,rtState告警实时数据<指定默认刷第一组数据>
        rsAlarmSetService.updateDataFromDataAndStateAndRsAlarmToSetHrStop();
        //设置data_set表
        rtDataSetMapper.updateBatchInRsAlarm(setDto.getDataSetList());
        //发送命令
        UpdateWrapper wrapper=new UpdateWrapper();
        wrapper.set("op_cmd",CMD_Constant.CMD_SetBattAlarm);
        rsalarmSetMapper.update(null,wrapper);
        //读取opCmd返回是否成功
        QueryWrapper<CkpowerdevBattRsalarmSet> query = Wrappers.query();
        Response opStatus = OpCmdUtil.getOpStatus(rsalarmSetMapper,query, CMD_Constant.CMD_SetBattAlarm,20,null);
        if(opStatus.getData()!=null && (boolean)opStatus.getData()) { //成功
            //记录日志
            Date now = new Date();
            List<CKPowerDevBattSetLog> logList = setDto.getLogList();
            //查询最大的操作编号
            String opNum=setLogMapper.getOpNum()!=null?setLogMapper.getOpNum():"0";
            logList.forEach(log->{
                log.setOpNum(String.valueOf(Integer.valueOf(opNum)+1));
                log.setCmdType(CMD_Constant.CMD_SetBattAlarm);
                log.setBattIndex(0);
                log.setCreateTime(now);
                log.setCreateDay(now);
            });
            setLogService.addBatch(logList);
        }
        return opStatus;
    }
}