package cn.cslg.pas.service.importPatent;

import cn.cslg.pas.common.utils.FormatUtil;
import cn.cslg.pas.common.vo.ImportTaskAMVO;
import cn.cslg.pas.common.vo.PatentWithIdVO;
import cn.cslg.pas.domain.es.Patent;
import cn.cslg.pas.domain.es.PatentJoin;
import cn.cslg.pas.service.business.es.EsService;
import cn.cslg.pas.service.common.FileManagerService;
import cn.cslg.pas.service.common.MessageService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SavePatentToEsThread extends Thread {
    private ApplicationContext applicationContext;
    private List<Patent> patents = new ArrayList<>();
    private final Lock taskLock = new ReentrantLock();
    private final Condition taskCondition = taskLock.newCondition();
    private TaskThread taskThread;
    private Boolean ifProductAll = false;

    @Override
    public void run() {
        while (!ifProductAll || patents.size() > 0) {
            try {

                //判断任务队列是否有任务，若没有则线程等待唤醒
                if (patents.size() == 0) {
                    taskLock.lock();
                    taskCondition.await();
                }

                Patent patent = patents.remove(0);
                //根据专利号查询专利
                EsService esService = applicationContext.getBean(EsService.class);
                PatentWithIdVO patentWithIdVO = esService.getIdByPatentNo(patent.getPatentNo());

                String patentId =null;
                // 若查出专利则更新
                if (patentWithIdVO != null) {
                    patentId =patentWithIdVO.getId();
                    Patent orgPatent = patentWithIdVO.getPatent();
                    BeanUtils.copyProperties(patent, orgPatent, FormatUtil.getNullPropertyNames(patent));
                    esService.updateDocument(orgPatent, patentWithIdVO.getId());
                } else {
                    PatentJoin patentJoin =new PatentJoin();
                    patentJoin.setName("patent");
                    patent.setPatentJoin(patentJoin);
                    patentId =  esService.addPatent(patent);

                }
                //判断是否和专题库或报告关联
                ImportTaskAMVO importTaskAMVO = taskThread.getImportTaskAMVO();

                //和专题库或报告进行关联
                if (importTaskAMVO.getProjectId() != null) {
                    if(patentId!=null){
                        Patent patentChild =new Patent();
                        PatentJoin patentJoin =new PatentJoin();
                        patentJoin.setParent(patentId);
                        patentJoin.setName("project");
                        patentChild.setPatentJoin(patentJoin);
                        patentChild.setProjectId(importTaskAMVO.getProjectId());
                     esService.addChildPatent(patentChild ,patentId);

                    }

                }
                //导入完成，通知前台
                MessageService messageService = applicationContext.getBean(MessageService.class);

                messageService.sendWebsocketMessage(importTaskAMVO, 1, 1, Long.parseLong("11"));
                System.out.println("patent" + patent.getPatentNo() + "done");
            } catch (Exception e) {
                System.out.println(e);
            }
        }
        taskThread.awakeTaskThread();
    }

    public SavePatentToEsThread(TaskThread taskThread, ApplicationContext applicationContext) {
        this.taskThread = taskThread;
        this.applicationContext = applicationContext;
    }


    public void awakeTask(Patent patent) {
        patents.add(patent);
        if (taskLock.tryLock()) {
            taskCondition.signalAll();
            taskLock.unlock();
        }
    }

    public void setIfProductAll(Boolean ifProductAll) {

        this.ifProductAll = ifProductAll;

    }
}