package cn.cslg.pas.service.importPatent;

import cn.cslg.pas.common.core.base.Constants;
import cn.cslg.pas.common.dto.es.EsCustomFieldDTO;
import cn.cslg.pas.common.vo.ImportTaskAMVO;
import cn.cslg.pas.common.vo.ProgressVO;
import cn.cslg.pas.domain.business.ImportTask;
import cn.cslg.pas.domain.business.ImportTaskCondition;
import cn.cslg.pas.domain.business.ReportProject;
import cn.cslg.pas.service.business.ImportTaskConditionService;
import cn.cslg.pas.service.business.ImportTaskService;
import cn.cslg.pas.service.business.ReportProjectService;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.stream.Collectors;

@Service
public class SchedulingTaskService {
    @Autowired
    private ImportTaskService importTaskService;

    @Autowired
    private ApplicationContext applicationContext;
    @Autowired
    private ThreadPoolTaskExecutor threadPoolTaskExecutor;
    @Autowired
    private ImportTaskConditionService importTaskConditionService;

    @Autowired
    private ReportProjectService reportProjectService;
    private List<ImportTaskAMVO> importTaskAMVOS;
    @Autowired
    private WebVOTransformService webVOTransformService;

    public void startTask() {
        Integer freeCount = Constants.MAX_IMPORT_TASK_COUNT - threadPoolTaskExecutor.getActiveCount();
        if (importTaskAMVOS == null) {
            importTaskAMVOS = new ArrayList<>();
        }
        // 当正在活跃的线程数小于最大线程数时
        List<Integer> ids = importTaskAMVOS.stream().map(ImportTaskAMVO::getId).collect(Collectors.toList());
        if (freeCount > 0) {
            //查找任务
            LambdaQueryWrapper<ImportTask> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(ImportTask::getState, new ArrayList<>(Arrays.asList(0)))
                    .in((ImportTask::getType), new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5)))
                    .orderByDesc(ImportTask::getState);
            if (ids.size() > 0) {
                queryWrapper.notIn(ImportTask::getId, ids);
            }
            List<ImportTask> importTaskList = importTaskService.list(queryWrapper);
            if (importTaskList.size() > freeCount) {
                importTaskList = importTaskList.subList(0, freeCount - 1);
            }

            if (importTaskList.size() > 0) {
                // 装载任务信息
                List<ImportTaskAMVO> importTaskAMVOFromDbs = this.loadTaskAMVOS(importTaskList);

                for (int i = 0; i < importTaskAMVOFromDbs.size(); i++) {
                    importTaskList.get(i).setState(1);
                    importTaskList.get(i).updateById();
                    importTaskAMVOFromDbs.get(i).setState(1);
                    importTaskAMVOFromDbs.get(i).setThreadCounter(0);
                    TaskThread taskThread = new TaskThread(importTaskAMVOFromDbs.get(i), applicationContext);
                    threadPoolTaskExecutor.execute(taskThread);
                    importTaskAMVOS.add(importTaskAMVOFromDbs.get(i));
                }


            }

        }
    }

    public List<ImportTaskAMVO> loadTaskAMVOS(List<ImportTask> importTaskList) {

        //根据projectId 获得报告类型
        List<ImportTaskAMVO> importTaskAMVOS = new ArrayList<>();
        List<Integer> taskConditionIds = new ArrayList<>();
        List<ImportTaskCondition> importTaskConditions = new ArrayList<>();
        taskConditionIds = importTaskList.stream().map(ImportTask::getImportTaskConditionId).collect(Collectors.toList());
        //根据taskid查询taskCondition
        if (taskConditionIds.size() != 0) {
            LambdaQueryWrapper<ImportTaskCondition> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(ImportTaskCondition::getId, taskConditionIds);
            importTaskConditions = importTaskConditionService.list(queryWrapper);

        }
        for (ImportTask importTask : importTaskList) {

            ImportTaskCondition importTaskCondition = importTaskConditions.stream().filter(item -> item.getId().equals(importTask.getImportTaskConditionId())).findFirst().orElse(null);
            ImportTaskAMVO importTaskAMVO = new ImportTaskAMVO();
            BeanUtils.copyProperties(importTask, importTaskAMVO);
            if (importTaskCondition != null) {
                importTaskAMVO.setFileGuid(importTaskCondition.getFileGuid());
                importTaskAMVO.setSourceId(importTaskCondition.getSourceId());
                importTaskAMVO.setProjectId(importTaskCondition.getProjectId());
                importTaskAMVO.setProductId(importTaskCondition.getProductId());
                importTaskAMVO.setImportContent(importTaskCondition.getImportContent());
                importTaskAMVO.setDbType(importTaskCondition.getDbType());
                importTaskAMVO.setOrderBy(importTaskCondition.getOrderBy());
                importTaskAMVO.setOrderByType(importTaskCondition.getOrderByType());
                importTaskAMVO.setProjectType(importTaskCondition.getProjectType());
                importTaskAMVO.setPatentNoStr(importTaskCondition.getPatentNos());
                importTaskAMVO.setPdfType(importTaskCondition.getPdfType());
                if (importTaskCondition.getCustomFields() != null) {
                    JSONArray jsonArray = JSONArray.parseArray(importTaskCondition.getCustomFields());
                    List<EsCustomFieldDTO> dtos = jsonArray.toJavaList(EsCustomFieldDTO.class);
                    importTaskAMVO.setFieldDTOS(dtos);
                }

                //定时任务
                if (importTaskCondition.getIfCycle() != null && importTaskCondition.getIfCycle()) {
                    List<EsCustomFieldDTO> dtoList = webVOTransformService.getEsCustomFieldDTOList(importTaskAMVO);
                    if (importTaskAMVO.getFieldDTOS() == null) {
                        importTaskAMVO.setFieldDTOS(dtoList);
                    } else {
                        importTaskAMVO.getFieldDTOS().addAll(dtoList);
                    }
                }

                LambdaQueryWrapper<ReportProject> rQueryWrapper = new LambdaQueryWrapper<>();
                rQueryWrapper.eq(ReportProject::getProjectId, importTaskCondition.getProjectId());
                ReportProject reportProject = reportProjectService.getOne(rQueryWrapper, false);
                if (reportProject != null) {
                    importTaskAMVO.setReportType(reportProject.getReportType());
                }
            }
            ProgressVO progressVO = new ProgressVO();
            progressVO.setState(0);
            importTaskAMVO.setProgressVO(progressVO);
            importTaskAMVOS.add(importTaskAMVO);


        }
        return importTaskAMVOS;

    }

    public void pauseTask(Integer taskId, Integer state) {
        //根据id获得
        if (importTaskAMVOS != null) {
            ImportTaskAMVO importTaskAMVO = importTaskAMVOS.stream().filter(item -> item.getId().equals(taskId)).findFirst().orElse(null);
            if (importTaskAMVO != null) {
                importTaskAMVO.setState(state);
            }
        }
    }

    public List<ImportTaskAMVO> getImportTaskAMVOs() {
        return this.importTaskAMVOS;
    }

    public void removeTaskAMVO(Integer taskId) {
        if (importTaskAMVOS != null && importTaskAMVOS.size() > 0) {
            importTaskAMVOS.removeIf(i -> i.getId().equals(taskId));
        }


    }

    public void startPdfTask() {

    }
}