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;

    public void startTask() {
        Integer freeCount = Constants.MAX_IMPORT_TASK_COUNT - threadPoolTaskExecutor.getActiveCount();
       if(importTaskAMVOS==null){
           importTaskAMVOS=new ArrayList<>();
       }
        // 当正在活跃的线程数小于最大线程数时
        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);
            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());
                if(importTaskCondition.getCustomFields()!=null) {
                    List<EsCustomFieldDTO> dtos = JSONArray.parseArray(importTaskCondition.getCustomFields());
                    importTaskAMVO.setFieldDTOS(dtos);
                }
                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获得
        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));
        }


    }
}