package com.monkeylessey.job.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.monkeylessey.enums.general.JobStatusEnum;
import com.monkeylessey.exception.JobException;
import com.monkeylessey.job.domain.entity.SysJob;
import com.monkeylessey.job.domain.form.SysJobForm;
import com.monkeylessey.job.domain.query.SysJobQuery;
import com.monkeylessey.job.domain.vo.SysJobVO;
import com.monkeylessey.job.mapper.SysJobMapper;
import com.monkeylessey.job.service.SysJobService;
import com.monkeylessey.job.utis.JobUtil;
import com.monkeylessey.response.Result;
import com.monkeylessey.framework.utils.SecurityUtil;
import com.monkeylessey.utils.PageUtil;
import lombok.RequiredArgsConstructor;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 定时任务表 服务实现类
 *
 * @author 向培
 * @since 2022-06-08
 */
@Service
@RequiredArgsConstructor
public class SysJobServiceImpl extends ServiceImpl<SysJobMapper, SysJob> implements SysJobService {

    private final SysJobMapper sysJobMapper;
    private final Scheduler scheduler;

    private static final Logger log = LoggerFactory.getLogger(SysJobServiceImpl.class);

    @Override
    public Result addSysJob(SysJobForm form) {
        SysJob entity = SysJobForm.getSysJob(null, form);
        String s = SecurityUtil.getCurrentUserName();
        entity.setCreateBy(s);
        try {
            JobUtil.createJob(scheduler, entity);
            baseMapper.insert(entity);
        } catch (ClassNotFoundException e) {
            log.error(e.getMessage());
            throw new JobException("Job类路径错误", e);
        } catch (SchedulerException e) {
            log.error(e.getMessage());
            throw new JobException("任务异常", e);
        }
        return Result.ok("添加成功");
    }

    @Override
    public Result editSysJob(SysJobForm form) {
        SysJob entity = SysJobForm.getSysJob(null, form);
        String s = SecurityUtil.getCurrentUserName();
        try {
            JobUtil.createJob(scheduler, entity);
            entity.setUpdateBy(s);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            throw new JobException("Job类路径错误", e);
        } catch (SchedulerException e) {
            e.printStackTrace();
            throw new JobException("任务异常", e);
        }
        baseMapper.updateById(entity);
        return Result.ok("修改成功");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result deleteSysJobById(String id) {
        try {
            JobUtil.deleteJob(scheduler, baseMapper.selectById(id));
        } catch (SchedulerException e) {
            throw new JobException("任务异常", e);
        }
        int i = baseMapper.deleteById(id);
        return Result.ok("删除成功");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result deleteSysJobByIds(List<String> ids) {
        try {
            for (String id : ids) {
                JobUtil.deleteJob(scheduler, baseMapper.selectById(id));
                baseMapper.deleteById(id);
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
            throw new JobException("任务异常", e);
        }
        return Result.ok("操作成功").data(baseMapper.deleteBatchIds(ids));
    }

    @Override
    public Result getSysJobByPage(SysJobQuery query) {
        List<SysJobVO> vos = new ArrayList<>();
        Long total = 0L;
        IPage<SysJob> page = PageUtil.getPage(query, SysJob.class);
        try {
            new LambdaQueryChainWrapper<>(this.baseMapper).page(page);
            vos = page.getRecords().stream()
                    .map(sysJob -> SysJobVO.getVoByEntity(sysJob, null))
                    .collect(Collectors.toList());
            total = page.getTotal();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.ok().data(vos).total(total);
    }

    @Override
    public Result getSysJobById(String id) {
        SysJob entity = baseMapper.selectById(id);
        SysJobVO vo = new SysJobVO();
        BeanUtils.copyProperties(entity, vo);
        return Result.ok().data(vo);
    }

    @Override
    public Result executeJobOnce(SysJobForm form) {
        try {
            JobUtil.executeOnce(scheduler, SysJobForm.getSysJob(null, form));
        } catch (SchedulerException e) {
            e.printStackTrace();
            throw new JobException("任务异常", e);
        }
        return Result.ok("执行成功");
    }

    @Override
    public Result pauseJob(SysJobForm form) {
        try {
            JobUtil.stopJob(scheduler, SysJobForm.getSysJob(null, form));
            new LambdaUpdateChainWrapper<>(baseMapper)
                    .set(SysJob::getJobStatus, JobStatusEnum.OFF)
                    .eq(SysJob::getId, form.getId())
                    .update();
        } catch (SchedulerException e) {
            e.printStackTrace();
            throw new JobException("任务异常", e);
        }
        return Result.ok("暂停成功");
    }

    @Override
    public Result startJob(SysJobForm form) {
        try {
            JobUtil.startJob(scheduler, SysJobForm.getSysJob(null, form));
            new LambdaUpdateChainWrapper<>(baseMapper)
                    .set(SysJob::getJobStatus, JobStatusEnum.ON)
                    .eq(SysJob::getId, form.getId())
                    .update();
        } catch (SchedulerException e) {
            throw new JobException("任务异常", e);
        }
        return Result.ok("启动成功");
    }
}