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

import com.gkhy.safePlatform.account.rpc.apimodel.AccountGroupService;
import com.gkhy.safePlatform.account.rpc.apimodel.model.resp.GroupRPCRespDTO;
import com.gkhy.safePlatform.commons.enums.E;
import com.gkhy.safePlatform.commons.exception.AusinessException;
import com.gkhy.safePlatform.commons.utils.idService.SnowFlow;
import com.gkhy.safePlatform.commons.vo.ResultVO;
import com.gkhy.safePlatform.safeCheck.entity.*;
import com.gkhy.safePlatform.safeCheck.enums.*;
import com.gkhy.safePlatform.safeCheck.service.SafeCheckTaskUnitSchedulesService;
import com.gkhy.safePlatform.safeCheck.service.baseService.*;
import com.gkhy.safePlatform.safeCheck.util.ConsolePrintIfEnvIsDevUtil;
import com.gkhy.safePlatform.safeCheck.util.timeChangeUtil;
import com.sun.org.apache.bcel.internal.generic.IF_ACMPEQ;
import org.apache.dubbo.config.annotation.DubboReference;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Service
public class  SafeCheckTaskUnitSchedulesServicelmpl implements SafeCheckTaskUnitSchedulesService {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private RedissonClient redissonClient;

    @DubboReference(check = false)
    private AccountGroupService accountGroupService;

    @Autowired
    private SafeCheckWorkService safeCheckWorkService;

    @Autowired
    private SafeCheckTaskUnitService safeCheckTaskUnitService;

    @Autowired
    private SafeCheckTaskService safeCheckTaskService;

    @Autowired
    private SafeCheckQuotaService safeCheckQuotaService;

    @Autowired
    private SafeCheckPointService safeCheckPointService;

    @Autowired
    private SafeCheckRegionService safeCheckRegionService;

    @Autowired
    private SafeCheckRfidService safeCheckRfidService;

    @Autowired
    private SafeCheckUnitAndQuotaService safeCheckUnitAndQuotaService;

    @Autowired
    private SafeCheckTaskAndQuotaService safeCheckTaskAndQuotaService;

    /**
     * @description 获取未来30分钟内的开启状态的任务单元
     */
    @Override
    public List<SafeCheckWork> findActiveWorkListByTime() {
        Date startTime = new Date();
        Date endTime = new Date(startTime.getTime()+ SchedulesTimeConfigEnum.SCHEDULES_SCAN_SECONDS.getSeconds()*1000);
        List<SafeCheckWork> workList = safeCheckWorkService.findActiveWorkListByTime(startTime,endTime, WorkStatusEnum.WORK_STATUS_OPEN.getStatus().intValue());
        if(workList != null && workList.size() > 0){
            return workList;
        }
        return null;
    }

    /**
     * @description 获取当前异常调度信息(下次通知时间在当前时间之前的)
     */
    @Override
    public List<SafeCheckWork> findFaildScheduleList() {
        Date nowTime = new Date();
        List<SafeCheckWork> workList = safeCheckWorkService.findFaildScheduleList(nowTime, WorkStatusEnum.WORK_STATUS_OPEN.getStatus()
                ,WorkStatusEnum.WORK_STATUS_DISPATCHING.getStatus());
        List<SafeCheckWork> faildWork = new ArrayList<>();
        if(workList != null && workList.size() > 0){
            for (SafeCheckWork work : workList) {
                if (work.getWorkStatus() == 1){
                    faildWork.add(work);
                }
                if (work.getWorkStatus() == 4){
                    Date nextCheckTime = work.getNextCheckTime();
                    //如果当前时间超过此次调度有效时间 work状态肯定不能为调度中
                    Date validTime = timeChangeUtil.nextValidTime(work.getValidTime(), work.getValidTimeUnit(), nextCheckTime);
                    if ((new Date()).compareTo(validTime) > 0){
                        faildWork.add(work);
                    }
                }
            }
            return faildWork;
        }
        return null;
    }

    /**
     * @description 将任务单元work表的记录改为调度中
     */
    @Override
    public void updateWorkStatusById(SafeCheckWork work) {
        safeCheckWorkService.updateWorkStatusById(work, DelectStatusEnum.DELECT_NO.getStatus());
    }

    /**
     * @description 根据任务单元id创建任务
     */
    @Transactional
    @Override
    public SafeCheckTask createAutoTask(Long workId) {


        ConsolePrintIfEnvIsDevUtil.consolePrintIfEnvIsDev("【##】开始创建任务----->>  WORK ID:"+workId+" 【创建时间】"+new Date());
        SafeCheckTask task = new SafeCheckTask();

        //雪花算法生成id和uuid
        SnowFlow snowFlow = new SnowFlow();//雪花算法生成器
        String taskUuid = UUID.randomUUID().toString();
        long taskId = snowFlow.nextId();
        SafeCheckWork work = safeCheckWorkService.getWorkById(workId);

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

        SafeCheckTask safeCheckTask = safeCheckTaskService.getTaskByWorkIdAndTaskStartTime(workId,work.getNextCheckTime(),DelectStatusEnum.DELECT_NO.getStatus().intValue());

        if (safeCheckTask != null){
            return null;
        }

        Long taskUnitId = work.getUnitId();
        SafeCheckTaskUnit taskUnit = safeCheckTaskUnitService.getTaskUnitById(taskUnitId, DelectStatusEnum.DELECT_NO.getStatus().intValue());

        BeanUtils.copyProperties(work,task);
        task.setId(taskId);
        task.setUuid(taskUuid);
        task.setUnitId(taskUnitId);
        task.setTaskName(taskUnit.getUnitName());
        task.setExecClassgroupId(work.getExecClassgroupId());
        ResultVO<GroupRPCRespDTO> groupId = accountGroupService.getGroupInfoByGroupId(work.getExecClassgroupId());
        if (groupId != null && groupId.getData() != null){
            GroupRPCRespDTO groupRPCRespDTO = (GroupRPCRespDTO) groupId.getData();
            task.setExecClassgroupName(groupRPCRespDTO.getGroupName());
        }
        task.setPointsLength(taskUnit.getPointsLength());
        task.setDeleteStatus(DelectStatusEnum.DELECT_NO.getStatus());
        task.setTaskClaim(TaskClaimStatusEnum.TASK_CLAIM_STATUS_NO.getCode());
        task.setTaskType(work.getWorkType());
        task.setTaskStatus(TaskStatusEnum.TASK_CHECK_WAIT.getStatus());
        task.setStartTime(work.getNextCheckTime());
        Date nextValidTime = timeChangeUtil.nextValidTime(work.getValidTime(), work.getValidTimeUnit(), work.getNextCheckTime());
        task.setValidTime(nextValidTime);
        task.setNoticeTime(timeChangeUtil.nextNoticeTime(work.getNoticeTime(),work.getNoticeTimeUnit(),work.getNextCheckTime()));
        task.setGmtCreate(new Date());
        task.setCreateUserName(taskUnit.getCreateUserName());
        task.setEnterpriseId(taskUnit.getEnterpriseId());
        task.setEnterpriseUuid(taskUnit.getEnterpriseUuid());
        task.setCheckWorkId(work.getId());
        task.setCheckWorkUuid(work.getUuid());
        safeCheckTaskService.saveTask(task);
        ConsolePrintIfEnvIsDevUtil.consolePrintIfEnvIsDev("【##】成功生成任务----->>  TASK ID:"+taskId+" 【创建时间】"+new Date());
        //调出这个任务单元所有的巡检链
        List<SafeCheckUnitAndQuota> unitAndQuotas = safeCheckUnitAndQuotaService.listByTaskUnitId(taskUnitId, DelectStatusEnum.DELECT_NO.getStatus().intValue());
        if (unitAndQuotas == null ||unitAndQuotas.size() ==0){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"该任务无相关巡检链，请添加");
        }
        List<SafeCheckTaskAndQuota> taskAndQuotas;
        taskAndQuotas = unitAndQuotas.stream().map((unitAndQuota)->{
            SafeCheckTaskAndQuota taskAndQuota = new SafeCheckTaskAndQuota();
            BeanUtils.copyProperties(unitAndQuota,taskAndQuota,"id");
            Long quotaId = unitAndQuota.getQuotaId();
            SafeCheckQuota quota = safeCheckQuotaService.getQuotaById(quotaId, DelectStatusEnum.DELECT_NO.getStatus().intValue());
            if (quota != null){
                taskAndQuota.setQuotaContent(quota.getQuota());
            }else {
                taskAndQuota.setQuotaContent(null);
            }
            SafeCheckPoint point = safeCheckPointService.getOnePoint(unitAndQuota.getPointId(), DelectStatusEnum.DELECT_NO.getStatus().intValue());
            if (point != null){
                taskAndQuota.setPoint(point.getCode());
            }else {
                taskAndQuota.setPoint(null);
            }

            SafeCheckRegion region = safeCheckRegionService.getOneRegion(unitAndQuota.getRegionId(), DelectStatusEnum.DELECT_NO.getStatus().intValue());
            if (region != null){
                taskAndQuota.setRegion(region.getRegion());
            }else {
                taskAndQuota.setRegion(null);
            }

            SafeCheckRfid rfid = safeCheckRfidService.getRfidById(unitAndQuota.getRfidId(), DelectStatusEnum.DELECT_NO.getStatus().intValue());

            if (rfid != null){
                taskAndQuota.setRfid(rfid.getRfid());
                taskAndQuota.setRfidName(rfid.getRfidName());
            }else {
                taskAndQuota.setRfid(null);
                taskAndQuota.setRfidName(null);
            }
            taskAndQuota.setRfidPosition(RfidPositionEnum.RFID_POSITION_NO.getCode());
            taskAndQuota.setTaskId(taskId);
            taskAndQuota.setTaskUuid(taskUuid);
            taskAndQuota.setPointCheckStatus(PointCheckStatusEnum.POINT_CHECK_STATUS_UNFINISHED.getCode());
            return taskAndQuota;
        }).collect(Collectors.toList());

        //批量将任务关联的巡检指标插入到任务指标关联表中
        int saveTaskAndQuotaResult = safeCheckTaskAndQuotaService.saveTaskAndQuotas(taskAndQuotas);
        if (saveTaskAndQuotaResult != taskAndQuotas.size() ){
            throw new AusinessException(E.ADD_FAIL,"任务关联指标插入失败");
        }
        ConsolePrintIfEnvIsDevUtil.consolePrintIfEnvIsDev("【##】任务关联指标插入成功----->> TASK ID:"+taskId+" 【完成时间】"+new Date());


        //释放分布式锁
        createTaskLock.unlock();
        return task;
    }

    /**
     * @description 变更任务状态
     */
    @Override
    public int updateTaskStatus(Long taskId, Byte taskStatus) {
        int updateResult = 0;

        //0、加分布式锁
        String lockName = "SAFECHECK_MQ_TASK_STATUS_UPDATE_"+taskId+"_"+taskStatus;
        RLock mqUpdateTaskStatusLock = redissonClient.getLock(lockName);
        mqUpdateTaskStatusLock.lock(3, TimeUnit.SECONDS);

        SafeCheckTask safeCheckTask = safeCheckTaskService.getTaskByTaskIdAndTaskStatus(taskId,taskStatus);
        if (safeCheckTask != null){
            return 1;
        }
        //将待巡检状态的任务转为巡检中
        if (taskStatus.intValue() == 2){
            updateResult =  safeCheckTaskService.updateTaskStatus(taskId,taskStatus,TaskStatusEnum.TASK_CHECK_WAIT.getStatus());
        }
        //将巡检中状态的任务转为超时未巡检
        if (taskStatus.intValue() == 4){
            updateResult =  safeCheckTaskService.updateTaskStatus(taskId,taskStatus,TaskStatusEnum.TASK_CHECK_RUNNING.getStatus());
        }

        //释放分布式锁
        mqUpdateTaskStatusLock.unlock();
        return updateResult;
    }

    /**
     * @description 根据任务id查询任务
     */
    @Override
    public SafeCheckTask getTaskById(Long taskId) {
        SafeCheckTask task =  safeCheckTaskService.getTaskById(taskId);
        return task;
    }

    /**
     * @description 将work的状态由调度中改为开启状态,同时对下次通知时间、下次开始时间、上一次排查开始时间进行更新  ；如果是单次作业，直接关闭 todo
     */
    @Transactional
    @Override
    public int resetWorkStatus(Long workId) {

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

        SafeCheckWork safeCheckWork = safeCheckWorkService.getWorkByIdAndWorkStatus(workId,WorkStatusEnum.WORK_STATUS_DISPATCHING.getStatus());
        if (safeCheckWork == null){
            return 1;
        }
        SafeCheckWork work = safeCheckWorkService.getWorkById(workId);
        Date checkTime = work.getNextCheckTime();
        work.setLastCheckTime(checkTime);
        int updateResult = 0;
        if (work.getWorkType() == WorkTypeEnum.WORK_TYPE_DAILY.getCode()) {
            work.setNextCheckTime(null);
            work.setNextNoticeTime(null);
            updateResult = safeCheckWorkService.resetWorkStatus(work, WorkStatusEnum.WORK_STATUS_CLOSE.getStatus());
            //单次任务同时也要把任务关闭
            SafeCheckTaskUnit taskUnit = new SafeCheckTaskUnit();
            taskUnit.setId(work.getUnitId());
            taskUnit.setTaskUnitStatus(TaskUnitStatusEnum.TASK_UNIT_STATUS_CLOSE.getStatus());
            safeCheckTaskUnitService.updateTaskUniStatusById(taskUnit,DelectStatusEnum.DELECT_NO.getStatus());
        }else {
            Date nextCheckTime = timeChangeUtil.nextCheckTime(work.getCheckCycle(), work.getCheckCycleUnit(),checkTime);
            Date nextNoticeTime = timeChangeUtil.nextNoticeTime(work.getNoticeTime(), work.getNoticeTimeUnit(), nextCheckTime);
            work.setNextCheckTime(nextCheckTime);
            work.setNextNoticeTime(nextNoticeTime);
            updateResult = safeCheckWorkService.resetWorkStatus(work, WorkStatusEnum.WORK_STATUS_OPEN.getStatus());
        }
        //释放分布式锁
        mqUpdateWorkOpenStatusLock.unlock();
        return updateResult;
    }

    /**
     * @description 对于通知时间在当前时间之前的调度信息 将通知时间更改为当前时间之后的十分钟
     */
    @Override
    public int resetScheduleTime(Long id, Date newNoticeTime) {
        SafeCheckWork work = safeCheckWorkService.getWorkById(id);
        Date lastCheckTime = work.getNextCheckTime();
        Date nextCheckTime= timeChangeUtil.getNextCheckTimeByNextNoticeTime(work.getNoticeTime(), work.getNoticeTimeUnit(), newNoticeTime);

        work.setNextNoticeTime(newNoticeTime);
        work.setNextCheckTime(nextCheckTime);
        work.setLastCheckTime(lastCheckTime);
        int updateResult = safeCheckWorkService.resetWorkStatus(work, TaskUnitStatusEnum.TASK_UNIT_STATUS_OPEN.getStatus());
        return updateResult;
    }
}