package com.gkhy.safePlatform.safeCheck.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.gkhy.safePlatform.account.rpc.apimodel.AccountAuthService;
import com.gkhy.safePlatform.account.rpc.apimodel.AccountDepartmentService;
import com.gkhy.safePlatform.account.rpc.apimodel.AccountGroupService;
import com.gkhy.safePlatform.account.rpc.apimodel.model.resp.GroupRPCRespDTO;
import com.gkhy.safePlatform.account.rpc.apimodel.model.resp.UserRPCRespDTO;
import com.gkhy.safePlatform.commons.co.ContextCacheUser;
import com.gkhy.safePlatform.commons.enums.E;
import com.gkhy.safePlatform.commons.enums.ResultCodes;
import com.gkhy.safePlatform.commons.exception.AusinessException;
import com.gkhy.safePlatform.commons.exception.BusinessException;
import com.gkhy.safePlatform.commons.utils.idService.SnowFlow;
import com.gkhy.safePlatform.commons.vo.ResultVO;
import com.gkhy.safePlatform.safeCheck.common.RocketMQTemplateHelper;
import com.gkhy.safePlatform.safeCheck.entity.SafeCheckTaskUnit;
import com.gkhy.safePlatform.safeCheck.entity.SafeCheckTaskUnitAndWorkDO;
import com.gkhy.safePlatform.safeCheck.entity.SafeCheckUnitAndQuota;
import com.gkhy.safePlatform.safeCheck.entity.SafeCheckWork;
import com.gkhy.safePlatform.safeCheck.enums.*;
import com.gkhy.safePlatform.safeCheck.model.dto.req.SafeCheckTaskUnitPageReqDTO;
import com.gkhy.safePlatform.safeCheck.model.dto.req.SafeCheckTaskUnitReqDTO;
import com.gkhy.safePlatform.safeCheck.model.dto.req.SafeCheckUnitAndQuotaReqDTO;
import com.gkhy.safePlatform.safeCheck.model.dto.resp.SafeCheckTaskUnitPageRespDTO;
import com.gkhy.safePlatform.safeCheck.model.dto.resp.SafeCheckTaskUnitRespDTO;
import com.gkhy.safePlatform.safeCheck.model.dto.resp.SafeCheckUnitAndQuotaRespDTO;
import com.gkhy.safePlatform.safeCheck.model.query.TaskUnitDBQuery;
import com.gkhy.safePlatform.safeCheck.mq.msg.SafeCheckCreateTaskMsg;
import com.gkhy.safePlatform.safeCheck.service.SafeCheckTaskManagerService;
import com.gkhy.safePlatform.safeCheck.service.SafeCheckTaskUnitSchedulesService;
import com.gkhy.safePlatform.safeCheck.service.baseService.SafeCheckTaskUnitService;
import com.gkhy.safePlatform.safeCheck.service.baseService.SafeCheckUnitAndQuotaService;
import com.gkhy.safePlatform.safeCheck.service.baseService.SafeCheckWorkService;
import com.gkhy.safePlatform.safeCheck.util.UserInfoUtil;
import com.gkhy.safePlatform.safeCheck.util.timeChangeUtil;
import org.apache.dubbo.config.annotation.DubboReference;
import org.apache.rocketmq.client.producer.SendResult;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.swing.text.AbstractDocument;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Service
public class SafeCheckTaskManagerServiceImpl implements SafeCheckTaskManagerService {

    @DubboReference(check = false)
    private AccountAuthService accountAuthService;

    @DubboReference(check = false)
    private AccountDepartmentService accountDepartmentService;

    @DubboReference(check = false)
    private AccountGroupService accountGroupService;

    @Autowired
    private RocketMQTemplateHelper rocketMQTemplateHelper;

    @Value("${rocketmq.topic.safeCheckCreateTaskTopic}")
    private String safeCheckCreateTaskTopic;

    @Autowired
    private RedissonClient redissonClient;

    @Autowired
    private SafeCheckTaskUnitSchedulesService taskUnitSchedulesService;

    @Autowired
    private SafeCheckTaskUnitService safeCheckTaskUnitService;

    @Autowired
    private SafeCheckWorkService safeCheckWorkService;

    @Autowired
    private SafeCheckUnitAndQuotaService safeCheckUnitAndQuotaService;


    /**
     * @description 新建巡检任务单元
     */
    @Transactional
    @Override
    public void saveTaskUnit(ContextCacheUser currentUser, SafeCheckTaskUnitReqDTO safeCheckTaskUnitReqDTO) {
        //获取用户信息
        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
        UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);


        this.paramIsValid(safeCheckTaskUnitReqDTO);

        //0、加分布式锁
        String lockName = "SAFECHECK_TASK_UNIT_CREATE_"+safeCheckTaskUnitReqDTO.getUnitName();
        RLock createTaskUnitLock = redissonClient.getLock(lockName);
        createTaskUnitLock.lock(3, TimeUnit.SECONDS);

        //判断任务单元的名称是否存在
        SafeCheckTaskUnit unitNameIsExit = safeCheckTaskUnitService.taskUnitNameIsExit(safeCheckTaskUnitReqDTO.getUnitName(), DelectStatusEnum.DELECT_NO.getStatus().intValue());
        if (unitNameIsExit != null){
            throw new AusinessException(E.DATA_DATABASE_EXIST,"巡检单元名称已存在");
        }
        //雪花算法生成id和uuid
        SnowFlow snowFlow = new SnowFlow();//雪花算法生成器
        String taskUnitUuid = UUID.randomUUID().toString();
        long taskUnitId = snowFlow.nextId();
        Date date = new Date();

        SafeCheckTaskUnit taskUnit = new SafeCheckTaskUnit();
        taskUnit.setId(taskUnitId);
        taskUnit.setUuid(taskUnitUuid);
        taskUnit.setDeleteStatus(DelectStatusEnum.DELECT_NO.getStatus());
        taskUnit.setTaskUnitStatus(TaskUnitStatusEnum.TASK_UNIT_STATUS_OPEN.getStatus());
        taskUnit.setUnitName(safeCheckTaskUnitReqDTO.getUnitName());
        taskUnit.setEnterpriseId(userInfo.getEnterprise().getId());
        taskUnit.setEnterpriseUuid(userInfo.getEnterprise().getUuid());
        taskUnit.setCreateUserName(userInfo.getRealName());
        taskUnit.setFileAddress(safeCheckTaskUnitReqDTO.getFileAddress());

        taskUnit.setGmtCreate(date);
        taskUnit.setLastEditUserName(userInfo.getRealName());
        taskUnit.setGmtModitify(date);


        String workUuid = UUID.randomUUID().toString();
        long workId = snowFlow.nextId();

        SafeCheckWork work = new SafeCheckWork();
        BeanUtils.copyProperties(safeCheckTaskUnitReqDTO,work);
        work.setId(workId);
        work.setUuid(workUuid);
        work.setDeleteStatus(DelectStatusEnum.DELECT_NO.getStatus());
        work.setWorkStatus(WorkStatusEnum.WORK_STATUS_OPEN.getStatus());
        work.setNextNoticeTime(timeChangeUtil.nextNoticeTime(safeCheckTaskUnitReqDTO.getNoticeTime(),
                safeCheckTaskUnitReqDTO.getNoticeTimeUnit(),safeCheckTaskUnitReqDTO.getFirstStartTime()));
        work.setNextCheckTime(safeCheckTaskUnitReqDTO.getFirstStartTime());
        work.setLastCheckTime(safeCheckTaskUnitReqDTO.getFirstStartTime());
        work.setUnitId(taskUnitId);
        work.setUnitUuid(taskUnitUuid);
        int saveWorkResult = safeCheckWorkService.saveWork(work);
        if (saveWorkResult == 0){
            throw new AusinessException(E.ADD_FAIL,"调度信息插入失败");
        }

        //调度信息插入成功后才会往数据库中批量插入巡检链中的巡检点
        List<SafeCheckUnitAndQuotaReqDTO> points = safeCheckTaskUnitReqDTO.getPoints();
        List<SafeCheckUnitAndQuota> safeCheckUnitAndQuotas = new ArrayList<>();
        safeCheckUnitAndQuotas = points.stream().map((point)->{
            SafeCheckUnitAndQuota safeCheckUnitAndQuota = new SafeCheckUnitAndQuota();
            BeanUtils.copyProperties(point,safeCheckUnitAndQuota);
            safeCheckUnitAndQuota.setUnitId(taskUnitId);
            safeCheckUnitAndQuota.setDeleteStatus(DelectStatusEnum.DELECT_NO.getStatus());
            safeCheckUnitAndQuota.setCreateUserName(userInfo.getRealName());
            safeCheckUnitAndQuota.setGmtCreate(date);
            safeCheckUnitAndQuota.setLastEditUserName(userInfo.getRealName());
            safeCheckUnitAndQuota.setGmtModitify(date);
            return safeCheckUnitAndQuota;
        }).collect(Collectors.toList());

        int saveUnitAndQuotaResult = safeCheckUnitAndQuotaService.saveUnitAndQuotas(safeCheckUnitAndQuotas);
        if (saveUnitAndQuotaResult != safeCheckUnitAndQuotas.size() ){
            throw new AusinessException(E.ADD_FAIL,"巡检链插入失败");
        }
        //保存任务
        taskUnit.setPointsLength(saveUnitAndQuotaResult);
        safeCheckTaskUnitService.saveTaskUnit(taskUnit);

        //如果通知时间与当前时间的时间间隔小于任务单元调度的时间，就立即创建任务 目前调度时间是5分钟
        if (work.getNextNoticeTime().getTime() - (new Date()).getTime() < 5*60*1000){
            SafeCheckCreateTaskMsg createTaskMsg = new SafeCheckCreateTaskMsg();
            createTaskMsg.setWorkId(workId);
            //当前时间30秒后创建任务
            createTaskMsg.setCreateTaskTime(new Date((new Date()).getTime()+30*1000));
            rocketMQTemplateHelper.syncSend(safeCheckCreateTaskTopic, createTaskMsg);

            work.setWorkStatus(WorkStatusEnum.WORK_STATUS_DISPATCHING.getStatus());
            taskUnitSchedulesService.updateWorkStatusById(work);
        }

        //释放分布式锁
        createTaskUnitLock.unlock();
    }

    /**
     * @description 根据任务单元id删除任务单元
     */
    @Transactional
    @Override
    public void deleteTaskUnit(ContextCacheUser currentUser, Long taskUnitId) {
        //获取用户信息
        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
        UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
        Date date = new Date();
        //先判断这个point是否存在
        if (taskUnitId == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检任务单元id不能为空");
        }
        SafeCheckTaskUnit taskUnit = safeCheckTaskUnitService.getTaskUnitById(taskUnitId,DelectStatusEnum.DELECT_NO.getStatus().intValue());
        taskUnit.setGmtModitify(date);
        taskUnit.setLastEditUserName(userInfo.getRealName());
        taskUnit.setDeleteStatus(DelectStatusEnum.DELECT_YES.getStatus());
        List<Integer> taskUnitStatus = new ArrayList<>();
        taskUnitStatus.add(TaskUnitStatusEnum.TASK_UNIT_STATUS_CLOSE.getStatus().intValue());
        taskUnitStatus.add(TaskUnitStatusEnum.TASK_UNIT_STATUS_EXPIRE.getStatus().intValue());
        //step1:先将任务单元表状态置为删除
        int deleteTaskUnitResult = safeCheckTaskUnitService.deleteTaskUnit(taskUnit, taskUnitStatus, DelectStatusEnum.DELECT_NO.getStatus().intValue());
        if (deleteTaskUnitResult == 0){
            throw new AusinessException(E.NOT_DELETE,"开启状态的任务单元不允许删除,删除失败");
        }

        SafeCheckWork work = safeCheckWorkService.getWorkByTaskUnitId(taskUnitId,DelectStatusEnum.DELECT_NO.getStatus().intValue());


        work.setDeleteStatus(DelectStatusEnum.DELECT_YES.getStatus());
        List<Integer> workStatus = new ArrayList<>();
        workStatus.add(WorkStatusEnum.WORK_STATUS_CLOSE.getStatus().intValue());
        workStatus.add(WorkStatusEnum.WORK_STATUS_EXPIRE.getStatus().intValue());
        //step2:将调度信息删除状态置为删除
        int deleteWorkResult = safeCheckWorkService.deleteWorkById(work,workStatus,DelectStatusEnum.DELECT_NO.getStatus().intValue());
        if (deleteWorkResult == 0){
            throw new AusinessException(E.NOT_DELETE,"开启、调度中状态的调度单元不允许删除,删除失败");
        }


        List<SafeCheckUnitAndQuota> unitAndQuotas = safeCheckUnitAndQuotaService.listByTaskUnitId(taskUnitId, DelectStatusEnum.DELECT_NO.getStatus().intValue());

        //step3:查看巡检单元与巡检链表中是否存在关联数据

        if (unitAndQuotas != null && unitAndQuotas.size() > 0){
            unitAndQuotas = unitAndQuotas.stream().map((unitAndQuota)->{
                unitAndQuota.setDeleteStatus(DelectStatusEnum.DELECT_YES.getStatus());
                unitAndQuota.setLastEditUserName(userInfo.getRealName());
                unitAndQuota.setGmtModitify(date);
                return unitAndQuota;
            }).collect(Collectors.toList());
            int updateUnitAndQuotaResult  = safeCheckUnitAndQuotaService.updateUnitAndQuotasById(unitAndQuotas,DelectStatusEnum.DELECT_NO.getStatus().intValue());
            if (updateUnitAndQuotaResult != unitAndQuotas.size()){
                throw new AusinessException(E.NOT_DELETE,"巡检任务单元:巡检链删除失败");
            }
        }
    }


    /**
     * @description 根据id更新巡检任务单元信息
     */
    @Transactional
    @Override
    public void updateTaskUnitMainById(ContextCacheUser currentUser, SafeCheckTaskUnitReqDTO safeCheckTaskUnitReqDTO) {
        //获取用户信息
        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
        UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);

        this.paramIsValid(safeCheckTaskUnitReqDTO);

        String unitName = safeCheckTaskUnitReqDTO.getUnitName();

        //0、加分布式锁
        String lockName = "SAFECHECK_TASK_UNIT_MAIN_UPDATE_"+unitName;
        RLock regionUpdateTaskUnitMainLock = redissonClient.getLock(lockName);
        regionUpdateTaskUnitMainLock.lock(3, TimeUnit.SECONDS);

        SafeCheckTaskUnit newTaskUnit = safeCheckTaskUnitService.taskUnitNameIsExit(safeCheckTaskUnitReqDTO.getUnitName(), DelectStatusEnum.DELECT_NO.getStatus().intValue());
        Long taskid = safeCheckTaskUnitReqDTO.getId();
        if (taskid == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检任务单元id不能为空");
        }
        if (!taskid.equals(newTaskUnit.getId())){
            throw new AusinessException(E.DATA_DATABASE_EXIST,"巡检单元名称已存在");
        }
        Date date = new Date();

        SafeCheckTaskUnit taskUnit = safeCheckTaskUnitService.getTaskUnitById(safeCheckTaskUnitReqDTO.getId(), DelectStatusEnum.DELECT_NO.getStatus().intValue());
        taskUnit.setUnitName(safeCheckTaskUnitReqDTO.getUnitName());
        taskUnit.setLastEditUserName(userInfo.getRealName());
        taskUnit.setGmtModitify(date);
        safeCheckTaskUnitService.updateTaskUnitNameById(taskUnit,DelectStatusEnum.DELECT_NO.getStatus().intValue());

        SafeCheckWork oldWork = safeCheckWorkService.getWorkByTaskUnitId(safeCheckTaskUnitReqDTO.getId(), DelectStatusEnum.DELECT_NO.getStatus().intValue());
        Date oldNextCheckTime = oldWork.getNextCheckTime();
        BeanUtils.copyProperties(safeCheckTaskUnitReqDTO,oldWork,"id","uuid");
        if (!safeCheckTaskUnitReqDTO.getFirstStartTime().equals(oldNextCheckTime)){
            oldWork.setWorkStatus(WorkStatusEnum.WORK_STATUS_OPEN.getStatus());
        }
        oldWork.setNextNoticeTime(timeChangeUtil.nextNoticeTime(safeCheckTaskUnitReqDTO.getNoticeTime()
                ,safeCheckTaskUnitReqDTO.getNoticeTimeUnit(),safeCheckTaskUnitReqDTO.getFirstStartTime()));
        oldWork.setNextCheckTime(safeCheckTaskUnitReqDTO.getFirstStartTime());
        safeCheckWorkService.updateWorkInfoById(oldWork,DelectStatusEnum.DELECT_NO.getStatus().intValue());

        //1、释放分布式锁
        regionUpdateTaskUnitMainLock.unlock();
    }

    /**
     * @description 根据id更新巡检任务单元状态
     */
    @Transactional
    @Override
    public String updateTaskUnitStatusById(ContextCacheUser currentUser, SafeCheckTaskUnitReqDTO safeCheckTaskUnitReqDTO) {
        //获取用户信息
        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
        UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);

        Long taskUnitId = safeCheckTaskUnitReqDTO.getId();
        Integer newTaskUnitStatus = safeCheckTaskUnitReqDTO.getTaskUnitStatus().intValue();
        Date date = new Date();

        SafeCheckTaskUnit taskUnit = safeCheckTaskUnitService.getTaskUnitById(taskUnitId, DelectStatusEnum.DELECT_NO.getStatus().intValue());
        Integer oldTaskUnitStatus = taskUnit.getTaskUnitStatus().intValue();
        if (newTaskUnitStatus == oldTaskUnitStatus){
            throw new AusinessException(E.UPDATE_FAIL,"巡检任务单元已处于"+TaskUnitStatusEnum.getValue(safeCheckTaskUnitReqDTO.getTaskUnitStatus())+"状态");
        }
        taskUnit.setTaskUnitStatus(newTaskUnitStatus.byteValue());
        taskUnit.setGmtModitify(date);
        taskUnit.setLastEditUserName(userInfo.getRealName());
        //修改任务单元的状态
        safeCheckTaskUnitService.updateTaskUniStatusById(taskUnit,DelectStatusEnum.DELECT_NO.getStatus().intValue());

        SafeCheckWork work = safeCheckWorkService.getWorkByTaskUnitId(taskUnitId,DelectStatusEnum.DELECT_NO.getStatus().intValue());
        work.setWorkStatus(newTaskUnitStatus.byteValue());
        //修改任务单元关联调度表的状态
        safeCheckWorkService.updateWorkStatusById(work,DelectStatusEnum.DELECT_NO.getStatus().intValue());

        //修改巡检链数据的状态
        List<SafeCheckUnitAndQuota> unitAndQuotas = safeCheckUnitAndQuotaService.listByTaskUnitId(taskUnitId, DelectStatusEnum.DELECT_NO.getStatus().intValue());

        if (unitAndQuotas != null && unitAndQuotas.size() > 0){
            unitAndQuotas = unitAndQuotas.stream().map((unitAndQuota)->{
                unitAndQuota.setLastEditUserName(userInfo.getRealName());
                unitAndQuota.setGmtModitify(date);
                return unitAndQuota;
            }).collect(Collectors.toList());
            int updateUnitAndQuotaResult  = safeCheckUnitAndQuotaService.updateUnitAndQuotasById(unitAndQuotas,DelectStatusEnum.DELECT_NO.getStatus().intValue());
            if (updateUnitAndQuotaResult != unitAndQuotas.size()){
                throw new AusinessException(E.UPDATE_FAIL,"巡检任务单元:巡检链状态修改失败");
            }
        }
        String newTaskUnitStatusString = TaskUnitStatusEnum.getValue(newTaskUnitStatus.byteValue());
        return newTaskUnitStatusString;
    }


    /**
     * @description 根据任务单元id查询任务单元
     */
    @Override
    public SafeCheckTaskUnitRespDTO getTaskUnitById(Long taskUnitId) {
        if (taskUnitId == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检单元id不能为空");
        }
        SafeCheckTaskUnitRespDTO taskUnitRespDTO = new SafeCheckTaskUnitRespDTO();
        SafeCheckTaskUnit taskUnit = safeCheckTaskUnitService.getTaskUnitById(taskUnitId, DelectStatusEnum.DELECT_NO.getStatus().intValue());
        BeanUtils.copyProperties(taskUnit,taskUnitRespDTO);

        SafeCheckWork work = safeCheckWorkService.getWorkByTaskUnitId(taskUnitId, DelectStatusEnum.DELECT_NO.getStatus().intValue());
        BeanUtils.copyProperties(work,taskUnitRespDTO,"id","uuid");
        List<SafeCheckUnitAndQuota> unitAndQuotas = safeCheckUnitAndQuotaService.listByTaskUnitId(taskUnitId,DelectStatusEnum.DELECT_NO.getStatus().intValue());

        if (unitAndQuotas == null || unitAndQuotas.size()==0){
            taskUnitRespDTO.setPoints(null);
        }
        List<SafeCheckUnitAndQuotaRespDTO> points = unitAndQuotas.stream().map((unitAndQuota)->{
            SafeCheckUnitAndQuotaRespDTO unitAndQuotaRespDTO = new SafeCheckUnitAndQuotaRespDTO();
            BeanUtils.copyProperties(unitAndQuota,unitAndQuotaRespDTO);
            return unitAndQuotaRespDTO;
        }).collect(Collectors.toList());
        taskUnitRespDTO.setPoints(points);
        return taskUnitRespDTO;
    }

    /**
     * @description 查询所有巡检任务单元数据并进行分页(包含条件查询)
     */
    @Override
    public IPage listTaskUnitByPage(Page pageInfo, SafeCheckTaskUnitPageReqDTO safeCheckTaskUnitPageReqDTO,ContextCacheUser currentUser) {
        TaskUnitDBQuery taskUnitDBQuery = new TaskUnitDBQuery();
        BeanUtils.copyProperties(safeCheckTaskUnitPageReqDTO,taskUnitDBQuery);

        List<Long> depIds = null;
        if (UserTypeEnum.STAFF.getCode() == currentUser.getType()){
            ResultVO<List<Long>> resultVO = accountDepartmentService.listDepAndSubDepIds(currentUser.getDepId());
            depIds = (List<Long>) resultVO.getData();
        }
        taskUnitDBQuery.setDepIds(depIds);
        UserRPCRespDTO userInfo;
        if (safeCheckTaskUnitPageReqDTO.getCreateUserId() == null) {
            taskUnitDBQuery.setCreateUserName(null);
        }else {
            //获取用户信息
            ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(safeCheckTaskUnitPageReqDTO.getCreateUserId());
            userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
            if (userInfo == null){
                taskUnitDBQuery.setCreateUserName(null);
            }else {
                String realName = userInfo.getRealName();
                taskUnitDBQuery.setCreateUserName(realName);
            }
        }
        IPage pageInfoResult = safeCheckTaskUnitService.listTaskUnitByPage(pageInfo,taskUnitDBQuery);
        List<SafeCheckTaskUnitAndWorkDO> records = pageInfoResult.getRecords();
        if (records == null || records.size() == 0){
            pageInfoResult.setRecords(null);
        }
        List<SafeCheckTaskUnitPageRespDTO> pageRespDTOs =records.stream().map((safeCheckTaskUnitAndWorkDO)->{
            SafeCheckTaskUnitPageRespDTO pageRespDTO = new SafeCheckTaskUnitPageRespDTO();
            BeanUtils.copyProperties(safeCheckTaskUnitAndWorkDO,pageRespDTO);
            pageRespDTO.setCheckCycleUnit(TimeUnitEnum.getValue(safeCheckTaskUnitAndWorkDO.getCheckCycleUnit()));
            return pageRespDTO;
        }).collect(Collectors.toList());
        pageInfoResult.setRecords(pageRespDTOs);
        return pageInfoResult;
    }


    /**
     * @description 根据巡检点的id删除巡检链中的巡检点
     */
    @Transactional
    @Override
    public void deleteTaskUnitPoint(ContextCacheUser currentUser, HashMap<String, Object> taskUnitAndPointId) {
        //获取用户信息
        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
        UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
        Date date = new Date();
        Long taskUnitId = (Long) taskUnitAndPointId.get("taskUnitId");
        if (taskUnitAndPointId == null){
            throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
        }
        if (taskUnitAndPointId.get("id") == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检点id不能为空");
        }
        if (taskUnitId == null){
            throw  new AusinessException(E.DATA_PARAM_NULL,"巡检单位id不能为空");
        }
        SafeCheckUnitAndQuota unitAndQuota = safeCheckUnitAndQuotaService.
                getUnitAndQuotaByid(taskUnitAndPointId,DelectStatusEnum.DELECT_NO.getStatus().intValue());

        unitAndQuota.setDeleteStatus(DelectStatusEnum.DELECT_YES.getStatus());
        unitAndQuota.setGmtModitify(date);
        unitAndQuota.setLastEditUserName(userInfo.getRealName());

        safeCheckUnitAndQuotaService.deleteTaskUnitPoint(unitAndQuota,DelectStatusEnum.DELECT_NO.getStatus().intValue());
        //删除成功后更新巡检任务单元表中巡检链的长度
        SafeCheckTaskUnit taskUnit = safeCheckTaskUnitService.getTaskUnitById(taskUnitId, DelectStatusEnum.DELECT_NO.getStatus().intValue());

        taskUnit.setPointsLength(taskUnit.getPointsLength()-1);
        taskUnit.setGmtModitify(date);
        taskUnit.setLastEditUserName(userInfo.getRealName());

        safeCheckTaskUnitService.updateTaskUnitPointsLengthById(taskUnit,DelectStatusEnum.DELECT_NO.getStatus().intValue());

    }

    /**
     * @description 根据巡检任务单元的id及巡检单元与巡检指标关联表的id对巡检点信息内容进行修改
     */
    @Transactional
    @Override
    public void updateTaskUnitPointById(ContextCacheUser currentUser, SafeCheckUnitAndQuotaReqDTO safeCheckUnitAndQuotaReqDTO) {
        //获取用户信息
        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
        UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
        Date date = new Date();
        this.pointParamIsValid(safeCheckUnitAndQuotaReqDTO);

        HashMap<String, Object> taskUnitAndPointId = new HashMap<>();

        taskUnitAndPointId.put("taskUnitId",safeCheckUnitAndQuotaReqDTO.getUnitId());
        taskUnitAndPointId.put("id",safeCheckUnitAndQuotaReqDTO.getId());

        SafeCheckUnitAndQuota unitAndQuota = safeCheckUnitAndQuotaService.
                getUnitAndQuotaByid(taskUnitAndPointId,DelectStatusEnum.DELECT_NO.getStatus().intValue());
        BeanUtils.copyProperties(safeCheckUnitAndQuotaReqDTO,unitAndQuota);
        unitAndQuota.setLastEditUserName(userInfo.getRealName());
        unitAndQuota.setGmtModitify(date);
        safeCheckUnitAndQuotaService.updateTaskUnitPointById(unitAndQuota,DelectStatusEnum.DELECT_NO.getStatus().intValue());

        //更新下修改记录
        SafeCheckTaskUnit taskUnit = safeCheckTaskUnitService.getTaskUnitById(safeCheckUnitAndQuotaReqDTO.getUnitId(),
                DelectStatusEnum.DELECT_NO.getStatus().intValue());
        taskUnit.setPointsLength(taskUnit.getPointsLength());
        taskUnit.setGmtModitify(date);
        taskUnit.setLastEditUserName(userInfo.getRealName());

        safeCheckTaskUnitService.updateTaskUnitPointsLengthById(taskUnit,DelectStatusEnum.DELECT_NO.getStatus().intValue());
    }

    /**
     * @description 往巡检链中新增一个巡检点
     */
    @Transactional
    @Override
    public void saveTaskUnitPoint(ContextCacheUser currentUser, SafeCheckUnitAndQuotaReqDTO safeCheckUnitAndQuotaReqDTO) {
        //获取用户信息
        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
        UserRPCRespDTO userInfo = UserInfoUtil.judgeUserInfo(rpcResult);
        Date date = new Date();
        this.pointParamIsValid(safeCheckUnitAndQuotaReqDTO);
        SafeCheckUnitAndQuota unitAndQuota = new SafeCheckUnitAndQuota();
        BeanUtils.copyProperties(safeCheckUnitAndQuotaReqDTO,unitAndQuota);
        unitAndQuota.setDeleteStatus(DelectStatusEnum.DELECT_NO.getStatus());
        unitAndQuota.setGmtCreate(date);
        unitAndQuota.setCreateUserName(userInfo.getRealName());
        unitAndQuota.setGmtModitify(date);
        unitAndQuota.setLastEditUserName(userInfo.getRealName());
        safeCheckUnitAndQuotaService.saveTaskUnitPoint(unitAndQuota);

        //新增成功后更新巡检任务单元表中巡检链的长度
        SafeCheckTaskUnit taskUnit = safeCheckTaskUnitService.getTaskUnitById(safeCheckUnitAndQuotaReqDTO.getUnitId(),
                DelectStatusEnum.DELECT_NO.getStatus().intValue());
        taskUnit.setPointsLength(taskUnit.getPointsLength()+ 1);
        taskUnit.setGmtModitify(date);
        taskUnit.setLastEditUserName(userInfo.getRealName());

        safeCheckTaskUnitService.updateTaskUnitPointsLengthById(taskUnit,DelectStatusEnum.DELECT_NO.getStatus().intValue());
    }


    /**
     * @description 新建巡检单元主数据进行参数校验
     */
    private void paramIsValid(SafeCheckTaskUnitReqDTO safeCheckTaskUnitReqDTO){
        if (safeCheckTaskUnitReqDTO == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检任务单元不能为空");
        }
        if (safeCheckTaskUnitReqDTO.getUnitName() == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检任务单元名称不能为空");
        }
        if (safeCheckTaskUnitReqDTO.getWorkType() == 0){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检任务单元作业类型不能为空");
        }
        if (safeCheckTaskUnitReqDTO.getExecClassgroupId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检任务单元执行班组不能为空");
        }
        //todo 暂时不用部门id
//        if (safeCheckTaskUnitReqDTO.getExecDepId() == null){
//            throw new AusinessException(E.DATA_PARAM_NULL,"巡检任务单元执行部门不能为空");
//        }
        if (safeCheckTaskUnitReqDTO.getWorkType() == WorkTypeEnum.WORK_TYPE_CYCLE.getCode()) {
            if (safeCheckTaskUnitReqDTO.getCheckCycle() == 0) {
                throw new AusinessException(E.DATA_PARAM_NULL, "巡检任务单元巡检周期不能为空");
            }
            if (safeCheckTaskUnitReqDTO.getCheckCycleUnit() == null){
                throw new AusinessException(E.DATA_PARAM_NULL,"巡检任务单元巡检周期时间单位不能为空");
            }
        }
        if (safeCheckTaskUnitReqDTO.getNoticeTime() == 0){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检任务单元提前通知时间不能为空");
        }
        if (safeCheckTaskUnitReqDTO.getNoticeTimeUnit() != null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检任务单元提前通知时间单位不能为空");
        }
        if (safeCheckTaskUnitReqDTO.getValidTime() == 0 ){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检任务单元有效时间不能为空");
        }
        if (safeCheckTaskUnitReqDTO.getValidTimeUnit() != null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检任务单元有效时间单位不能为空");
        }
        if (safeCheckTaskUnitReqDTO.getFirstStartTime() == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检任务单元首次作业调度时间不能为空");
        }

        Date noticeTime = timeChangeUtil.nextNoticeTime(safeCheckTaskUnitReqDTO.getNoticeTime(),
                safeCheckTaskUnitReqDTO.getNoticeTimeUnit(), safeCheckTaskUnitReqDTO.getFirstStartTime());
        //新增任务单元设置的通知时间不能在当前时间之前
        if ((new Date()).compareTo(noticeTime) > 0){
            throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"任务单元设置的通知时间不能在当前时间之前");
        }
        //任务执行的间隔时间大于单次任务通知时间加上有效时间:也就是下次通知时间肯定要在本次任务执行之后 todo
        //1.获得下次通知时间
        if(safeCheckTaskUnitReqDTO.getWorkType() == WorkTypeEnum.WORK_TYPE_CYCLE.getCode()) {
            Date nextNoticeTime = timeChangeUtil.nextNoticeTimeByCurrentNoticeTime(safeCheckTaskUnitReqDTO.getCheckCycle(),
                    safeCheckTaskUnitReqDTO.getCheckCycleUnit(), noticeTime);
            //2.获得本次任务的有效截至日期
            Date currentTaskvalidTime = timeChangeUtil.nextValidTime(safeCheckTaskUnitReqDTO.getValidTime(), safeCheckTaskUnitReqDTO.getValidTimeUnit()
                    , safeCheckTaskUnitReqDTO.getFirstStartTime());
            if (nextNoticeTime.compareTo(currentTaskvalidTime) <= 0) {
                throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "巡检周期间隔时间需大于巡检通知时间加上巡检执行有效时间");
            }
        }
        if (safeCheckTaskUnitReqDTO.getPoints() == null && safeCheckTaskUnitReqDTO.getPoints().size() == 0){
            throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"任务单元关联的巡检点不能为空");
        }
        for (SafeCheckUnitAndQuotaReqDTO point : safeCheckTaskUnitReqDTO.getPoints()) {
            this.pointParamIsValidWhenTaskUnitAdd(point);
        }

    }

    /**
     * @description 任务单元首次创建时包含的point进行数据校验
     */
    private void pointParamIsValidWhenTaskUnitAdd(SafeCheckUnitAndQuotaReqDTO safeCheckUnitAndQuotaReqDTO){
        if (safeCheckUnitAndQuotaReqDTO == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检点信息不能为空");
        }
        if (safeCheckUnitAndQuotaReqDTO.getPointId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检点id不能为空");
        }
        if (safeCheckUnitAndQuotaReqDTO.getRegionId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检区域id不能为空");
        }
        if (safeCheckUnitAndQuotaReqDTO.getRfidId() == 0){
            throw new AusinessException(E.DATA_PARAM_NULL,"rfid值不能为空");
        }
        if (safeCheckUnitAndQuotaReqDTO.getQuotaId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检指标id不能为空");
        }
        if (safeCheckUnitAndQuotaReqDTO.getQuotaUnit() == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检指标单位不能为空");
        }
        if (safeCheckUnitAndQuotaReqDTO.getExecSequence() == 0){
            throw new AusinessException(E.DATA_PARAM_NULL,"执行顺序不能为空");
        }
        if (safeCheckUnitAndQuotaReqDTO.getDataReportType() == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"数据填报类型能为空");
        }
        if(safeCheckUnitAndQuotaReqDTO.getSecondReferenceValue() != null){
            if (safeCheckUnitAndQuotaReqDTO.getSecondReferenceSign() == null){
                throw new AusinessException(E.DATA_PARAM_NULL,"请选择参考值 > or >= 符号");
            }
        }
        if (safeCheckUnitAndQuotaReqDTO.getThirdReferenceValue() != null){
            if (safeCheckUnitAndQuotaReqDTO.getThirdReferenceValue() == null){
                throw new AusinessException(E.DATA_PARAM_NULL,"请选择参考值 < or <= 符号");
            }
        }
    }

    /**
     * @description 新增巡检点相关参数校验
     */
    private void pointParamIsValid(SafeCheckUnitAndQuotaReqDTO safeCheckUnitAndQuotaReqDTO){
        if (safeCheckUnitAndQuotaReqDTO == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检点信息不能为空");
        }
        if (safeCheckUnitAndQuotaReqDTO.getUnitId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"任务单元id不能为空");
        }
        if (safeCheckUnitAndQuotaReqDTO.getPointId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检点id不能为空");
        }
        if (safeCheckUnitAndQuotaReqDTO.getRegionId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检区域id不能为空");
        }
        if (safeCheckUnitAndQuotaReqDTO.getRfidId() == 0){
            throw new AusinessException(E.DATA_PARAM_NULL,"rfid值不能为空");
        }
        if (safeCheckUnitAndQuotaReqDTO.getQuotaId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检指标id不能为空");
        }
        if (safeCheckUnitAndQuotaReqDTO.getQuotaUnit() == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"巡检指标单位不能为空");
        }
        if (safeCheckUnitAndQuotaReqDTO.getExecSequence() == 0){
            throw new AusinessException(E.DATA_PARAM_NULL,"执行顺序不能为空");
        }
        if (safeCheckUnitAndQuotaReqDTO.getDataReportType() == null){
            throw new AusinessException(E.DATA_PARAM_NULL,"数据填报类型能为空");
        }
        if(safeCheckUnitAndQuotaReqDTO.getSecondReferenceValue() != null){
            if (safeCheckUnitAndQuotaReqDTO.getSecondReferenceSign() == null){
                throw new AusinessException(E.DATA_PARAM_NULL,"请选择参考值 > or >= 符号");
            }
        }
        if (safeCheckUnitAndQuotaReqDTO.getThirdReferenceValue() != null){
            if (safeCheckUnitAndQuotaReqDTO.getThirdReferenceValue() == null){
                throw new AusinessException(E.DATA_PARAM_NULL,"请选择参考值 < or <= 符号");
            }
        }
    }
}