package com.example.demo.controller;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.activiti.bpmn.converter.BpmnXMLConverter;
import org.activiti.bpmn.converter.CallActivityXMLConverter;
import org.activiti.bpmn.converter.UserTaskXMLConverter;
import org.activiti.bpmn.model.*;
import org.activiti.bpmn.model.Process;
import org.activiti.editor.language.json.converter.BpmnJsonConverter;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.RepositoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.repository.DeploymentBuilder;
import org.activiti.engine.repository.Model;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.ClassPathResource;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author yanpeng
 * @version 1.0
 * @desc TODO
 * @company 北京中经网软件有限公司
 * @date 2020/10/27 14:34
 */
@RestController
@RequestMapping("workflow")
@Api(tags = "工作流接口")
public class WorkFlowController {

    @Autowired
    private ProcessEngine processEngine;

    @ApiOperation(value = "保存工作流")
    @GetMapping("model")
    public void model() {
        RepositoryService repositoryService = processEngine.getRepositoryService();
        Model model = repositoryService.newModel();
        model.setName("请假工作流");
        model.setKey("holidayex");
        repositoryService.saveModel(model);
        System.out.println(model.getId());
    }


    @ApiOperation(value = "保存xml")
    @GetMapping("modelxml")
    public void modelXml(String modeid) throws UnsupportedEncodingException {
        RepositoryService repositoryService = processEngine.getRepositoryService();
        Model model = repositoryService.getModel(modeid);
//        Deployment deploy = repositoryService.createDeployment().addClasspathResource("bpmn/testex1.bpmn").name("请假申请流程").deploy();
        // 创建转换对象
        BpmnXMLConverter bpmnXMLConverter = new BpmnXMLConverter();
        // XMLStreamReader读取XML资源
        XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
        XMLStreamReader xmlStreamReader = null;
        try {
            ClassPathResource resource = new ClassPathResource("bpmn/testex1.xml");
            xmlStreamReader = xmlInputFactory.createXMLStreamReader(resource.getInputStream());
        } catch (Exception e) {
            e.printStackTrace();
        }
        BpmnXMLConverter.addConverter(new UserTaskXMLConverter());
        BpmnXMLConverter.addConverter(new CallActivityXMLConverter());
        // 把xml转换成BpmnModel对象
        BpmnModel bpmnModel = bpmnXMLConverter.convertToBpmnModel(xmlStreamReader);
        // 创建转换对象
        BpmnJsonConverter bpmnJsonConverter = new BpmnJsonConverter();
        // 把BpmnModel对象转换成json
        String bpmnXml = bpmnJsonConverter.convertToJson(bpmnModel).toString();
        repositoryService.addModelEditorSource(model.getId(), bpmnXml.getBytes("utf-8"));
    }

    @Autowired
    private RepositoryService repositoryService;

    @ApiOperation(value = "发布工作流")
    @GetMapping("deploy")
    public void deploy(String modeid) throws Exception {
        Model modelData = repositoryService.getModel(modeid);
        byte[] bytes = repositoryService.getModelEditorSource(modelData.getId());
        JsonNode modelNode = new ObjectMapper().readTree(bytes);
        BpmnModel model = new BpmnJsonConverter().convertToBpmnModel(modelNode);
        model.getProcesses().get(0).setName(modelData.getName());
        //校验有没有开始结束节点-
        List<EndEvent> endEventList = model.getProcesses().get(0).findFlowElementsOfType(EndEvent.class);
        List<StartEvent> startEventList = model.getProcesses().get(0).findFlowElementsOfType(StartEvent.class);
        List<ExclusiveGateway> gateways = model.getProcesses().get(0).findFlowElementsOfType(ExclusiveGateway.class);
        if (gateways != null) {
            for (ExclusiveGateway gateway : gateways) {
                System.out.println(gateway.getId());
                Collection<FlowElement> flowElements = model.getProcesses().get(0).getFlowElements();
                List<SequenceFlow> collect = model.getProcesses().get(0).findFlowElementsOfType(SequenceFlow.class).stream().filter(x -> {
                    flowElements.remove(x);
                    return x.getSourceRef().equals(gateway.getId());
                }).collect(Collectors.toList());
                Collections.sort(collect, (x1, x2) -> {
                    if (x1.getConditionExpression() == null && x2.getConditionExpression() != null) {
                        return 1;
                    }
                    if (x1.getConditionExpression() != null && x2.getConditionExpression() == null) {
                        return -1;
                    }
                    return 0;
                });
                flowElements.addAll(collect);
                System.out.println(collect);
            }
        }
        if (startEventList.size() == 0) {
            System.out.println("没开始节点");
        }
        if (endEventList.size() == 0) {
            System.out.println("没有结束节点");
        }

        byte[] bpmnByates = new BpmnXMLConverter().convertToXML(model);
        //发布流程
        String processName = modelData.getName() + ".bpmn20.xml";
        String convertToXML = new String(bpmnByates);
        System.out.println(convertToXML);
        DeploymentBuilder deployment = repositoryService.createDeployment();
        deployment.name(modelData.getName());
        deployment.addString(processName, convertToXML);
//        deployment.key(modelData.getKey());
        deployment.key("holidayex");
        Deployment deploy = deployment.deploy();
        modelData.setDeploymentId(deploy.getId());
        System.out.println(deploy.getId());
        System.out.println(deploy.getKey());
        repositoryService.saveModel(modelData);
    }

    @ApiOperation(value = "启动工作流")
    @GetMapping("start")
    public void start(Integer num) {
        RuntimeService runtimeService = processEngine.getRuntimeService();
        Map<String,Object> map = new HashMap<>();
        map.put("num",num);
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("holidayex",map);
        System.out.println(processInstance.getProcessDefinitionId());
        System.out.println(processInstance.getId());
    }

    @Autowired
    private TaskService taskService;

    @ApiOperation(value = "查询任务")
    @GetMapping("query")
    public Boolean query() {
//        TaskService taskService = processEngine.getTaskService();
        List<Task> holidayex = taskService.createTaskQuery().processDefinitionKey("holidayex").list();
        holidayex.stream().forEach(x -> {
            System.out.println(x.getProcessDefinitionId());
            System.out.println(x.getId());
            System.out.println(x.getName());
            System.out.println(x.getAssignee());
        });
        return true;
    }


    @ApiOperation(value = "完成任务")
    @GetMapping("ok")
    public Boolean ok(String taskid) {
        TaskService taskService = processEngine.getTaskService();
        taskService.complete(taskid);
        return true;
    }
}