package cn.cslg.pas.service.importPatent;

import cn.cslg.pas.common.core.base.Constants;
import cn.cslg.pas.common.dto.UploadPatentWebDTO;
import cn.cslg.pas.common.model.cronModel.ImportTaskConfig;
import cn.cslg.pas.common.model.cronModel.OrderConfig;
import cn.cslg.pas.common.utils.FormatUtil;
import cn.cslg.pas.common.utils.MathUtils;
import cn.cslg.pas.common.vo.ImportTaskAMVO;
import cn.cslg.pas.domain.business.ImportTask;
import cn.cslg.pas.domain.es.Patent;
import cn.cslg.pas.factorys.PatentImportFactory.PatentImportFactory;
import cn.cslg.pas.factorys.PatentImportFactory.PatentImportImp;
import cn.cslg.pas.service.business.CommonService;
import cn.cslg.pas.service.business.ImportTaskService;
import cn.cslg.pas.service.common.MessageService;
import com.alibaba.fastjson.JSON;
import io.swagger.v3.oas.models.security.SecurityScheme;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.Collectors;

@Configurable
public class TaskThread extends Thread {
    @Autowired
    SchedulingTaskService importTaskAdd;

    private ApplicationContext applicationContext;
    private final Lock taskThreadLock = new ReentrantLock();
    private final Condition taskThreadCondition = taskThreadLock.newCondition();
    private ImportTaskAMVO importTaskAMVO;
    private PatentProcess patentProcess = new PatentProcess();
    private List<UploadPatentWebDTO> uploadPatentWebDTOS = new ArrayList<>();

    /**
     * 从任务队列取出并执行任务
     */
    public TaskThread(ImportTaskAMVO importTaskAMVO, ApplicationContext applicationContext) {
        this.importTaskAMVO = importTaskAMVO;
        //十进制转二进制
        String imContents = "0000";
        //当任务为
        if (importTaskAMVO.getType().equals(1)) {
            imContents = "1100";
        } else if (!importTaskAMVO.getImportContent().equals(0)) {
            imContents = MathUtils.fun(2, importTaskAMVO.getImportContent());
        }
        //下载字段
        char[] importCells = imContents.toCharArray();
        char ifCataloguing = importCells[0];
        char ifAddPicture = importCells[1];
        char ifFullText = importCells[2];
        char ifPdf = importCells[3];
        importTaskAMVO.setIfAddCatalogue(ifCataloguing);
        importTaskAMVO.setIfAddPicture(ifAddPicture);
        importTaskAMVO.setIfAddFullText(ifFullText);
        importTaskAMVO.setIfAddPDF(ifPdf);
        importTaskAMVO.setThreadDoneCounter(0);
        importTaskAMVO.setMessageThreadDoneCounter(0);
        Integer threadCount = 0;
        Integer messageThreadCount = 0;

        if (ifAddPicture == '1') {
            threadCount += 1;
            this.patentProcess.setPictureDoneNum(importTaskAMVO.getDoneNum());
            this.patentProcess.setPictureDefaultNum(0);
        }
        if (ifCataloguing == '1' || ifFullText == '1') {
            threadCount += 1;
            this.patentProcess.setPatentMessageDefaultNum(0);
            this.patentProcess.setPatentMessageDoneNum(0);
            if (ifCataloguing == '1') {
                messageThreadCount += 1;
            }
            if (ifFullText == '1') {
                messageThreadCount += 1;
            }
        }
        if (ifPdf == '1') {
            this.patentProcess.setPdfDefaultNum(0);
            this.patentProcess.setPdfDoneNum(0);
            threadCount += 1;
        }
        importTaskAMVO.setMessageThreadCounter(messageThreadCount);
        importTaskAMVO.setThreadCounter(threadCount);
        this.applicationContext = applicationContext;
        this.patentProcess.setPatentDoneNum(importTaskAMVO.getDoneNum());
        this.patentProcess.setPatentDefaultNum(0);

    }


    @Override
    public void run() {
        //TODO 判断任务的类型
        String json = CommonService.readJsonFile(Constants.IMPORT_TASK_CONFIG + ".json");
        List<ImportTaskConfig> configs = JSON.parseArray(json, ImportTaskConfig.class);
        PatentImportFactory patentImportFactory = applicationContext.getBean(PatentImportFactory.class);
        //根据任务类型使用不同的导入类
        ImportTaskConfig config = configs.stream().filter(item -> item.getTaskType().equals(importTaskAMVO.getType()) && item.getImportTo().equals(Constants.IMPORT_PATENT_TO)).findFirst().orElse(null);
        PatentImportImp patentImportImp = patentImportFactory.getClass(config.getImportClass());
        patentImportImp.setTaskThread(this);
        patentImportImp.startPatentThread();
        taskThreadLock.lock();
        try {
            taskThreadCondition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        ImportTaskService importTaskService = applicationContext.getBean(ImportTaskService.class);
        ImportTask task = importTaskService.getById(importTaskAMVO.getId());
        if (importTaskAMVO.getState().equals(1)) {
            task.setState(2);
            importTaskAMVO.setState(2);

        } else {
            task.setState(importTaskAMVO.getState());
        }
        task.setDoneNum(this.patentProcess.getPatentDoneNum());
        importTaskAMVO.setDoneNum(this.patentProcess.getPatentDoneNum());
        task.updateById();
        MessageService messageService = applicationContext.getBean(MessageService.class);
        messageService.sendAllDoneMessage(importTaskAMVO);
    }


    /**
     * 任务是否完成代码块
     */
    public void awakeTaskThread() {
        synchronized ("导入任务是否完成") {
            importTaskAMVO.setThreadDoneCounter(importTaskAMVO.getThreadDoneCounter() + 1);
            if (importTaskAMVO.getThreadCounter().equals(importTaskAMVO.getThreadDoneCounter())) {
                if (taskThreadLock.tryLock()) {
                    //taskLock.lock();
                    taskThreadCondition.signalAll();
                    taskThreadLock.unlock();
                }
                MessageService messageService = applicationContext.getBean(MessageService.class);
                messageService.sendWebsocketMessage(importTaskAMVO, -1, patentProcess);
            }
        }
    }


    public ImportTaskAMVO getImportTaskAMVO() {
        return this.importTaskAMVO;
    }

    public ApplicationContext getApplicationContext() {
        return this.applicationContext;
    }


    public void updateProcess(Boolean ifDefault, Integer type, String appNo) {
        synchronized ("更新进度") {
            switch (type) {
                case 1:
                    patentProcess.setPatentMessageDoneNum(patentProcess.getPatentMessageDoneNum() + 1);
                    if (ifDefault) {
                        patentProcess.setPatentMessageDefaultNum(patentProcess.getPatentMessageDefaultNum() + 1);
                    }

                    break;
                case 2:
                    patentProcess.setPictureDoneNum(patentProcess.getPictureDoneNum() + 1);
                    if (ifDefault) {
                        patentProcess.setPictureDefaultNum(patentProcess.getPictureDefaultNum() + 1);
                    }
                    break;
                case 4:
                    patentProcess.setPdfDoneNum(patentProcess.getPdfDoneNum() + 1);
                    if (ifDefault) {
                        patentProcess.setPdfDefaultNum(patentProcess.getPdfDefaultNum() + 1);
                    }
                    break;
            }
            List<Integer> nums = new ArrayList<>();
            nums.add(patentProcess.getPictureDoneNum());
            nums.add(patentProcess.getPdfDoneNum());
            nums.add(patentProcess.getPatentMessageDoneNum());
            Integer min = MathUtils.getNotNullMinNum(nums);
            if (patentProcess.getPatentDoneNum() < min) {
                patentProcess.setPatentDoneNum(min);
                importTaskAMVO.setDoneNum(min);
                MessageService messageService = applicationContext.getBean(MessageService.class);
                messageService.sendWebsocketMessage(importTaskAMVO, -1, this.patentProcess);
            }
        }
    }


}