package cn.cslg.pas.service.quartzService;

import cn.cslg.pas.common.core.base.Cycle;
import cn.cslg.pas.common.utils.DateUtils2;
import cn.cslg.pas.common.utils.utilVO.CheckDateConditionVO;
import cn.cslg.pas.common.utils.utilVO.NowDateFirstMessVO;
import cn.cslg.pas.domain.business.ImportTaskCondition;
import cn.cslg.pas.domain.business.PatentProject;
import cn.cslg.pas.service.MailSendService;
import cn.cslg.pas.service.business.ImportTaskConditionService;
import cn.cslg.pas.service.business.ImportTaskService;
import cn.cslg.pas.service.business.PatentProjectService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.RequiredArgsConstructor;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

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


@DisallowConcurrentExecution
@RequiredArgsConstructor
public class SysImportPatentJobService extends QuartzJobBean {
    private final ImportTaskConditionService importTaskConditionService;
    private final ImportTaskService importTaskService;
    private final PatentProjectService patentProjectService;
    private final MailSendService mailSendService;

    @Override
    public void executeInternal(JobExecutionContext context) throws JobExecutionException {

        mailSendService.sendSysCycleStartEmail();
        System.out.println("task start");
        this.addChinesePatent();

    }


    public void addChinesePatent() {
         List<String> cycles =this.getCnCycles();
        LambdaQueryWrapper<PatentProject> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PatentProject::getIfUpdate, true);
                if(cycles!=null&&cycles.size()>0){
                    queryWrapper.in(PatentProject::getUpdateCycle,cycles);
                }
        List<PatentProject> patentProjects = patentProjectService.list(queryWrapper);
        if (patentProjects != null && patentProjects.size() != 0) {
            List<Integer> projectId = patentProjects.stream().map(PatentProject::getProjectId).collect(Collectors.toList());
            //根据id查询检索条件
            LambdaQueryWrapper<ImportTaskCondition> queryWrapper1 = new LambdaQueryWrapper<>();
            queryWrapper1.in(ImportTaskCondition::getProjectId, projectId);
            queryWrapper1.eq(ImportTaskCondition::getIfCycle, true)
                    .eq(ImportTaskCondition::getIfUpdate, true);
            List<ImportTaskCondition> importTaskConditions = importTaskConditionService.list(queryWrapper1);

            importTaskConditions.forEach(item -> {

                PatentProject project = patentProjects.stream().filter(t -> t.getProjectId().equals(item.getProjectId())).findFirst().orElse(null);
                             importTaskService.addImportTaskByCondition(item, project);

            });
        }

    }


    public List<String> getCnCycles() {
        CheckDateConditionVO checkDateConditionVO = DateUtils2.checkDateCycleCondition(null);
        Boolean ifMeetMonth = checkDateConditionVO.getIfMeetMonth();
        Boolean ifMeetQuarter = checkDateConditionVO.getIfMeetQuarter();
        Boolean ifMeetYear = checkDateConditionVO.getIfMeetYear();
        List<String> cycles = new ArrayList<>();
        cycles.add(Cycle.WEEK);

        if (ifMeetMonth != null && ifMeetMonth) {
            cycles.add(Cycle.MONTH);
        }
        if (ifMeetQuarter != null && ifMeetQuarter) {
            cycles.add(Cycle.QUARTER);
        }
        if (ifMeetYear != null && ifMeetYear) {
            cycles.add(Cycle.YEAR);
        }
        return cycles;

    }
}