package cn.autoform.web.controller.workflow;

import cn.autoform.bean.FormSolidiFication;
import cn.autoform.bean.ProcessCon;
import cn.autoform.bean.ProcessState;
import cn.autoform.bean.system.UserInfo;
import cn.autoform.db.entity.ProcessApproval;
import cn.autoform.db.entity.ProcessInstance;
import cn.autoform.db.entity.ProcessTask;
import cn.autoform.db.exten.Process;
import cn.autoform.fw.exception.FormClientException;
import cn.autoform.fw.exception.IEMRuntimeException;
import cn.autoform.util.form.FormDataCodeToNameFilter;
import cn.autoform.util.thread.Keys;
import cn.autoform.util.thread.ThreadData;
import cn.autoform.util.tool.JSONTool;
import cn.autoform.util.tool.ObjectUtil;
import cn.autoform.web.client.CscApiService;
import cn.autoform.web.client.WorkflowClient;
import cn.autoform.web.client.impl.FormClientImpl;
import cn.autoform.web.client.util.WorkflowTool;
import cn.autoform.web.client.util.WorkflowTwe;
import cn.autoform.web.controller.resumable.util.FastDFSClient;
import cn.autoform.web.service.datamanagement.DataManagementService;
import cn.autoform.web.service.process.*;
import com.alibaba.fastjson.TypeReference;
import com.codingapi.tx.annotation.TxTransaction;
import lombok.extern.slf4j.Slf4j;
import net.sf.json.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.TimeoutException;

@Slf4j
@RestController
public class WorkflowController {

    @Autowired
    private FormClientImpl formClient;
    @Autowired
    private ProcessApprovalService processApp;


    @Autowired
    private ProcessInstanceService processInstance;

    @Autowired(required = false)
    private ProcessFilter processFilter;

    @Autowired
    private WorkflowClient workflowClient;


    @Resource(name = "processStateServiceImpl")
    private ProcessStateService process;

    @Value("${process-service-id}")
    private Integer processServiceId;

    @Resource
    private FastDFSClient fastDFSClient;

    /**
     * 流程logservice
     */
    @Resource(name = "processLogServiceImpl")
    private ProcessLogService processLogService;

    @Autowired
    private WorkflowTool workflowTool;

    @Autowired
    private WorkflowTwe workflowTwe;

    @Autowired
    private CscApiService cscApi;

    @Autowired
    private DataManagementService dataManagementService;
    public static final String Q = "[%s]:10";

    public static final String A = "[%s]:20";

    /**
     * 当前待办信息key
     */
    private static final String PROCESSINFORMATION = "processInformation";

    /**
     * 项目负责人
     */
    private static final String PROJECT_LEADER_PHONE = "projectLeaderPhone";


    /**
     * 删除流程定义
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    @RequestMapping(value = "${requset.processdefine01}", method = RequestMethod.POST)
    public Map<String, Object> defineDelete(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        workflowTool.setRequest(request);
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.defineDelete(process);
        return result;
    }

    /**
     * 部署流程定义
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    @RequestMapping(value = "${requset.processdefine02}", method = RequestMethod.POST)
    public Map<String, Object> definePeploy(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        jsonObject.remove("tenantID");
        jsonObject.remove("formID");
        //写死版本号
        jsonObject.put("version", "1.1.1");
        System.out.println("参数：" + JSONTool.toJson(jsonStr));
        workflowTool.setRequest(request);
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.definePeploy(process);
        //修改数据库流程定义json信息
        processApp.definePeploy(result);
        System.out.println("结果：" + JSONTool.toJson(result));
        return result;
    }

    /**
     * 流程定义分页查询
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    @RequestMapping(value = "${requset.processdefine03}", method = RequestMethod.POST)
    public Map<String, Object> defineSeache(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        workflowTool.setRequest(request);
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.defineSeache(process);
        return result;
    }

    /**
     * 创建流程定义
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    @RequestMapping(value = "${requset.processdefine04}", method = RequestMethod.POST)
    public Map<String, Object> defineCreate(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        //取出本地流程定义，没有则创建
        ProcessApproval pro = processApp.selectApp(jsonObject.getString("formID"));
        if (pro != null) {
            return JSONTool.toObj(JSONTool.toJson(pro), new TypeReference<Map<String, Object>>() {
            });
//			return RestResultGenerator.genBussinessSuccessResult(pro);
        }
        workflowTool.setRequest(request);
        //查询是否已经初始化过
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> flag = workflowClient.check(workflowTwe.getProcess(getRse(new JSONObject())));
        String flag1 = Objects.toString(flag.get("data"), "true");
        System.out.println("返回结果：" + JSONTool.toJson(flag));
        //若没有初始化过，进行初始化
        if (flag1.equals("false")) {
            Map<String, Object> o = workflowClient.initialization(workflowTwe.getProcess(getRse(new JSONObject())));
            System.out.println("初始化接口:" + JSONTool.toJson(o));
        }
        Map<String, Object> result = workflowClient.defineCreate(process);
        //新创建的定义添加到本端
        ProcessApproval proc = new ProcessApproval();
        //proc.setOrganizationId(jsonObject.getString("organizationId"));
        proc.setFormId(jsonObject.getString("formID"));
        processApp.addProcessApproval(result, proc);
        System.out.println("返回结果:" + JSONTool.toJson(result));
//		return RestResultGenerator.genBussinessSuccessResult(result.get("data"));
        return JSONTool.toObj(JSONTool.toJson(result.get("data")), new TypeReference<Map<String, Object>>() {
        });
    }

    public JSONObject getRse(JSONObject js) {
        js.put("tenantId", ThreadData.get(Keys.TENANT_ID));
        js.put("companyId", ThreadData.get(Keys.COMPANY_ID));
        js.put("serviceId", ThreadData.get(Keys.SERVICE_ID));
        return js;
    }

    /**
     * 退回流程实例
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     * @throws FormClientException
     */
    @RequestMapping(value = "${requset.processinst01}", method = RequestMethod.POST)
    public Map<String, String> instBack(@RequestBody Map<String, Object> jsonStr, HttpServletRequest request) throws TimeoutException, IOException, FormClientException {
        System.out.println("参数:" + JSONTool.toJson(jsonStr));
        //添加流程log
        processLogService.addProcessLog(jsonStr, "20", null);
        //重新构造参数
        Map<String, Object> maps = new HashMap<String, Object>();
        maps.put("activityInstId", jsonStr.get("activityInstId"));
        maps.put("activityDefId", jsonStr.get("activityDefId"));
        maps.put("processInstId", jsonStr.get("processInstId"));
        maps.put("data", jsonStr.get("data"));
        System.out.println("工作流参数：" + JSONTool.toJson(maps));
        JSONObject jsonObject = JSONObject.fromObject(JSONTool.toJson(maps));
        workflowTool.setRequest(request);
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, String> result = workflowClient.instBack(process);
        System.out.println("返回结果:" + JSONTool.toJson(result));
//		if(result.get("data").equals("1")){
//		//添加退回Log
//		ProcessLog proLog = JSONTool.toObj(JSONTool.toJson(jsonStr),ProcessLog.class);
//		System.out.println(JSONTool.toJson(proLog));
//		processLogService.insertLog(proLog);
//		}
        //流程引擎执行失败，不进行表单状态的处理
        if(null != result && null != result.get("resCode") && result.get("resCode").contains("ErrCode")){
            return result;
        }
        if (true) {
            record(Objects.toString(jsonStr.get("processInstId"), ""), 1, jsonStr.get("activityDefId").toString());
        }

		if(workflowTool.isOne(Objects.toString(jsonStr.get("processInstId")))){
			processFilter.executeRollBack(
			        Objects.toString(jsonStr.get("formID"))
                    , Optional.ofNullable(jsonStr.get("dataRowNum")).map(Object::toString).map(Integer::valueOf).orElse(0)
                    , ThreadData.get(Keys.TENANT_ID));
		}

        return result;
    }

    /**
     * 设置代理
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    @RequestMapping(value = "${requset.processinst02}", method = RequestMethod.POST)
    public Map<String, Object> agentCreate(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        workflowTool.setRequest(request);
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.agentCreat(process);
        return result;
    }

    @PostMapping("/test/html")
    public Object testHtml(@RequestBody String jsonStr) {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        String htmlUrl = uploadHtml(jsonObject.getString("html"));
        return htmlUrl;
    }

    @RequestMapping(value = "/set/html", method = RequestMethod.POST)
    public Map<String, Object> setHtml(@RequestBody String jsonStr) throws TimeoutException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        ProcessState ps = new ProcessState(jsonObject.getString("formID"), jsonObject.getInt("dataRowNum"), ThreadData.get(Keys.TENANT_ID));
        ps.setHtmlUrl(uploadHtml(jsonObject.getString("html")));
        this.process.updateState(ps);
        return new ModelMap("resCode", "000000");
    }

    /**
     * 创建流程实例
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws Exception
     */
    @RequestMapping(value = "${requset.processinst03}", method = RequestMethod.POST)
    @TxTransaction(isStart = true)
    @Transactional
    public Map<String, Object> instCreat(@RequestBody String jsonStr, HttpServletRequest request) throws Exception {
        //添加流程办理中
        Integer dNum = null;
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        String formId = jsonObject.getString("formID");
        Integer dataRowNun = jsonObject.getInt("dataRowNum");
        String htmlUrl = uploadHtml(jsonObject.getString("html"));
        // 清除无用参数，参数超长问题
        jsonObject.remove("html");

        String tenantId = ThreadData.get(Keys.TENANT_ID);
        if (processFilter != null) {
            processFilter.executeBefor(jsonObject.getString("formID"), jsonObject.getInt("dataRowNum"), ThreadData.get(Keys.TENANT_ID));
        }
        //查看本条数据是否创建过流程
        ProcessApproval pro = null;
        ProcessInstance pros = new ProcessInstance();
        pros.setDataRowNum(jsonObject.getInt("dataRowNum"));
        pros.setFormID(jsonObject.getString("formID"));
        Map<String, Object> res = new HashMap<>();
        //判断是否已经创建流程实例，以创建返回
        //取出当前流程大状态
        ProcessInstance p = processInstance.selectInst(pros);
        ProcessState pse = process.selectState(new ProcessState(jsonObject.getString("formID"), jsonObject.getInt("dataRowNum"), ThreadData.get(Keys.TENANT_ID)));
        //验证操作人员
        checkData(pse);
        if (p != null) {
            ProcessState pgo = new ProcessState(jsonObject.getString("formID"), jsonObject.getInt("dataRowNum"), ThreadData.get(Keys.TENANT_ID));
            //取出当前流程大状态
            ProcessState ps = process.selectState(pgo);
            if (!ObjectUtil.empty(ps) && "10".equals(ps.getProcessState())) {
                //已有流程实例，并且状态为10，重新提交
                String i = instOne(htmlUrl, jsonObject.getString("formID"), jsonObject.getInt("dataRowNum"), ThreadData.get(Keys.TENANT_ID), p.getProcessInstId(), p.getProcessDefId());
                if (i != null) {

                    if (processFilter != null) {
                        processFilter.executeCreate(jsonObject.getString("formID"), jsonObject.getInt("dataRowNum"), ThreadData.get(Keys.TENANT_ID));
                    }

                    res.put("resCode", "00000");
                    return res;
                } else {

                }
            }
            res.put("data", "2");

            if (processFilter != null) {
                processFilter.executeCreate(jsonObject.getString("formID"), jsonObject.getInt("dataRowNum"), ThreadData.get(Keys.TENANT_ID));
            }
            return res;
        }
        pro = processApp.selectApp(jsonObject.getString("formID"));
        if (pro == null) {
            res.put("data", "3");
            return res;
        }

        jsonObject.put("processDefName", pro.getProcessDefName());
        jsonObject.put("processDefId", pro.getProcessDefId());
        jsonObject.put("processInstName", pse.getNumber());
        jsonObject.put("params", processApp.getProcessParam(
                formId
                , tenantId
                , dataRowNun));
        setSearchParam(jsonObject, pse);
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.autoFinish(process);
        //将流程实例添加在本端
        Object obj = result.get("data");
        if (ObjectUtil.empty(obj)) {
            throw new IEMRuntimeException("流程自动提交待办异常，自动提交失败");
        }
        StringBuffer tasks = new StringBuffer();
        ProcessInstance proInst = JSONTool.toObj(JSONTool.toJson(obj), ProcessInstance.class);
        try {
            //添加流程日志
            Map<String, Object> logMap = JSONTool.toObj(jsonStr, Map.class);
            logMap.put("processInstId", proInst.getProcessInstId());

            proInst.setFormID(formId);
            proInst.setTenantID(tenantId);
            proInst.setDataRowNum(dataRowNun);

            dNum = processLogService.addProcessLog(logMap, "30", null);

            ProcessState ps = new ProcessState(formId, dataRowNun, tenantId);
            ps.setProcessUser(ThreadData.get(Keys.OPEN_ID));
            ps.setProcessLog(null);
            ps.setHtmlUrl(htmlUrl);

            List<ProcessTask> list = proInst.getWorkItems();
            if (ObjectUtil.notEmpty(list)) {
                for (ProcessTask pr : list) {
                    tasks.append("[").append(pr.getParticipantId()).append("],");
//					proInst.setActivityInstId(pr.getActivityDefId());
                }
                ps.setProcessTask(tasks.toString().replaceAll(",$", ""));
                ps.setOrderStatus("21");
                ps.setProcessState("20");
            } else {
                this.budgetDeduction(tenantId, formId, dataRowNun);
                ps.setOrderStatus("40");
                ps.setProcessState("30");
            }
            proInst.setActivityInstId(proInst.getOneActivityDefId());
            processInstance.addProcess(proInst);

            this.process.updateState(ps);

//			if (workflowTool.isOver(result)) {
//				if (processFilter != null) {
//					processFilter.executeOver(jsonObject.getString("formID"), jsonObject.getInt("dataRowNum"), ThreadData.get(Keys.TENANT_ID));
//				}
//			}

            if (processFilter != null) {
                processFilter.executeAfter(jsonObject.getString("formID"), jsonObject.getInt("dataRowNum"), ThreadData.get(Keys.TENANT_ID));
            }

            if (processFilter != null) {
                processFilter.executeCreate(jsonObject.getString("formID"), jsonObject.getInt("dataRowNum"), ThreadData.get(Keys.TENANT_ID));
            }
        } catch (Exception e) {
            System.err.println("------------------------手动结束当前流程----------------");
            jsonObject.clear();
            jsonObject.put("processInstId", proInst.getProcessInstId());
            processLogService.delProcessLog(dNum);
            workflowClient.instOver(workflowTool.getProcess(jsonObject));
            log.error(e.getMessage(), e);

            res.put("resCode", "00018");
            return res;
        }
        return result;
    }

    public String uploadHtml(String html) {
//		log.debug("上传大小:{}", html.length());
        String url = fastDFSClient.uploadFile(html.getBytes(), "json");
//		log.debug("上传成功:{}", url);
        if (ObjectUtil.empty(url)) {
            throw new IEMRuntimeException("固化html失败!");
        }
        return url;
    }

    private void setSearchParam(JSONObject jsonObject, ProcessState pse) {
        log.debug("流程状态:{}", JSONTool.toJson(pse));
        Map<String, Object> name = new HashMap<>(pse.getMainInfo());
        FormDataCodeToNameFilter.accept(name);
        jsonObject.put("sourceSystem", "epc");
        if (StringUtils.isEmpty((String)pse.getMainInfo().get("reimburseMan"))
                || StringUtils.isEmpty((String)name.get("reimburseMan"))) {
            //todo set
            UserInfo userInfo = formClient.getUserInfo();
            jsonObject.put("search_1", userInfo.getUserCode());
            jsonObject.put("search_2", userInfo.getUserName());
        } else {
            jsonObject.put("search_1", pse.getMainInfo().get("reimburseMan"));
            jsonObject.put("search_2", name.get("reimburseMan"));
        }
        jsonObject.put("search_3", pse.getMainInfo().get("C_Type"));
        jsonObject.put("search_4", name.get("C_Type"));
        jsonObject.put("search_5", name.get("Remark"));
        log.debug("添加查询参数:{}", jsonObject.toString());
    }
//
//    @RequestMapping(value = "${requset.processinst03}", method = RequestMethod.POST)
//    public JSONObject setSearchParam1(@RequestBody String jsonStr) {
//        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
//        jsonObject.put("sourceSystem", "epc");
//            //todo set
//            UserInfo userInfo = formClient.getUserInfo();
//            jsonObject.put("search_1", userInfo.getUserCode());
//            jsonObject.put("search_2", userInfo.getUserName());
//        log.debug("添加查询参数:{}", jsonObject.toString());
//        return jsonObject;
//    }


    /**
     * 撤销流程实例
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     * @throws FormClientException
     */
    @RequestMapping(value = "${requset.processinst04}", method = RequestMethod.POST)
    public Map<String, Object> instDrawBack(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException, FormClientException {
//		System.out.println("撤回参数"+jsonStr);
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        workflowTool.setRequest(request);
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.instDrawBack(process);
//		System.out.println(" 撤销返回结果:"+JSONTool.toJson(result));
        //修改流程大状态
        if (result != null && "00000".equals(result.get("resCode"))) {
            this.updateState(jsonObject.getString("processInstId"));
        }
		if(workflowTool.isOne(jsonObject.getString("processInstId"))){
			processFilter.executeRollBack(jsonObject.getString("formID"), jsonObject.getInt("datarowNum"), ThreadData.get(Keys.TENANT_ID));
		}
        return result;
    }

    /**
     * 结束流程实例
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    @RequestMapping(value = "${requset.processinst05}", method = RequestMethod.POST)
    public Map<String, Object> instOver(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        workflowTool.setRequest(request);
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.instOver(process);
        System.out.println("返回参数:" + JSONTool.toJson(result));
        return result;
    }

    /**
     * 设置代办
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    @RequestMapping(value = "${requset.processinst06}", method = RequestMethod.POST)
    public Map<String, Object> chargeCreate(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        workflowTool.setRequest(request);
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.chargeCreate(process);
        return result;
    }

    /**
     * 执行流程实例
     *
     * @param
     * @param request
     * @return
     * @throws Exception
     */
    @RequestMapping(value = "${requset.processinst07}", method = RequestMethod.POST)
    @TxTransaction(isStart = true)
    @Transactional
    public Map<String, Object> instFinish(@RequestBody Map<String, Object> map, HttpServletRequest request) throws Exception {
        //添加流程log
        processLogService.addProcessLog(map, "10", null);
        String formId = Objects.toString(map.get("formID"), "");
        Integer dataRowNum = NumberUtils.createInteger(Objects.toString(map.get("dataRowNum"), "0"));
        String tenantId = Objects.toString(map.get("tenantID"), "");
        if (processFilter != null) {
            processFilter.executeBefor(formId, dataRowNum, tenantId);
        }
        Map<String, Object> workFlowParam = new HashMap<>();
        workFlowParam.put("processInstId", map.get("processInstId"));
        workFlowParam.put("activityInstId", map.get("activityInstId"));
        workFlowParam.put("data", map.get("data"));
        workFlowParam.put("formID", map.get("formID"));
        workFlowParam.put("dataRowNum", map.get("dataRowNum"));
        workFlowParam.put("tenantID", map.get("tenantID"));
        workFlowParam.put("userName", map.get("userName"));
        workFlowParam.put("params", processApp.getProcessParam(
                Objects.toString(map.get("formID"))
                , Objects.toString(map.get("tenantID"))
                , NumberUtils.createInteger(Objects.toString(map.get("dataRowNum"), "0"))));
        JSONObject jsonObject = JSONObject.fromObject(JSONTool.toJson(workFlowParam));
        //执行前判断是否是项目负责人审批
        setProjectleader(JSONTool.toObj(JSONTool.toJson(map.get(PROCESSINFORMATION)), ProcessTask.class)
                , new ProcessState(formId, dataRowNum, tenantId), jsonObject);
        workflowTool.setRequest(request);
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.instFinish(process);
//		System.out.println("执行返回结果:"+JSONTool.toJson(result));
        if (workflowTool.isOver(result)) {
            this.budgetDeduction(tenantId, formId, dataRowNum);
        } else {
            record(Objects.toString(map.get("processInstId"), ""), 0, map.get("activityInstId").toString());//if(result.get("data") != null)
        }
        if (processFilter != null) {
            processFilter.executeAfter(formId, dataRowNum, tenantId);
        }
        return result;
    }

    /**
     * 查询流程待办
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    @RequestMapping(value = "${requset.processinst08}", method = RequestMethod.POST)
    public Map<String, Object> instSeacheHandle(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        jsonObject.put("appId", processServiceId);
        jsonObject.put("tenantId", ThreadData.get(Keys.TENANT_ID));
        jsonObject.put("compId", ThreadData.get(Keys.COMPANY_ID));
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.instSeacheHandle(process);
        return result;
    }

    /**
     * 流程实例log
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    @RequestMapping(value = "${requset.processinst09}", method = RequestMethod.POST)
    public Map<String, Object> instLog(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        ProcessInstance pros = new ProcessInstance();
        pros.setDataRowNum(Integer.parseInt(jsonObject.getString("dataRowNum")));
        pros.setFormID(jsonObject.getString("formID"));
        ProcessInstance prop = processInstance.selectInst(pros);
        System.out.println("流程实例:" + JSONTool.toJson(prop));
        if (prop == null) {
            Map<String, Object> remap = new HashMap<>();
            remap.put("data", null);
            return remap;
        }
        jsonObject.put("processInstId", prop.getProcessInstId());

        workflowTool.setRequest(request);
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.instLog(process);
        //每次操作更新本端节点,暂时不操作
        //processNodeService.operation(result,jsonObject.get("processInstId").toString());
        System.out.println("流程Log:" + JSONTool.toJson(result));
        return result;
    }

    /**
     * 获取所有可退回项目
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    @RequestMapping(value = "${requset.processinst10}", method = RequestMethod.POST)
    public Map<String, Object> getBack(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        workflowTool.setRequest(request);
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.getBack(process);
        return result;
    }

    /**
     * 查询代理
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    @RequestMapping(value = "${requset.processinst11}", method = RequestMethod.POST)
    public Map<String, Object> instAgent(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        workflowTool.setRequest(request);
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.instAgent(process);
        return result;
    }

    /**
     * 查询代理去除流程定义信息
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    @RequestMapping(value = "${requset.processinst12}", method = RequestMethod.POST)
    public Map<String, Object> instAgentDefMsg(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        workflowTool.setRequest(request);
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.instAgentDefMsg(process);
        return result;
    }

    /**
     * 查询流程实例
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    @RequestMapping(value = "${requset.processinst13}", method = RequestMethod.POST)
    public Map<String, Object> instSeache(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        workflowTool.setRequest(request);
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.instSeache(process);
        return result;
    }

    /**
     * 租户注册系统
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    @RequestMapping(value = "${requset.processapp01}", method = RequestMethod.POST)
    public Map<String, Object> appCreate(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        workflowTool.setRequest(request);
        Process process = workflowTool.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.appCreate(process);
        return result;
    }

    /**
     * 初始化租户接口
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    @RequestMapping(value = "process/initialization", method = RequestMethod.POST)
    public Map<String, Object> initialization(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        Process process = workflowTwe.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.initialization(process);
        return result;
    }


    /**
     * 检查初始化
     *
     * @param jsonStr
     * @param request
     * @return
     * @throws TimeoutException
     * @throws IOException
     */
    @RequestMapping(value = "process/check", method = RequestMethod.POST)
    public Map<String, Object> check(@RequestBody String jsonStr, HttpServletRequest request) throws TimeoutException, IOException {
        JSONObject jsonObject = JSONObject.fromObject(jsonStr);
        Process process = workflowTwe.getProcess(jsonObject);
        Map<String, Object> result = workflowClient.check(process);
        return result;
    }

    public static final String unsubmitted = "20";

    /**
     * 提交流程时，添加表单大状态
     *
     * @throws TimeoutException
     * @throws FormClientException
     */
    public int updateState(String formId, Integer dataRowNun, String tenantId, String processIntsId) throws FormClientException, TimeoutException {
        ProcessState pro = new ProcessState();
        pro.setFormId(formId);
        /*10:未提交，20:审核中，30审核完成 */
        pro.setProcessState(unsubmitted);
        pro.setDataRowNum(dataRowNun);
        pro.setProcessTask(processIntsId);
        pro.setTenantId(tenantId);
        pro.setProcessUser(cscApi.getUserId(ThreadData.get(Keys.OPEN_ID)));
        process.updateState(pro);
        return process.updateState(pro);
    }
//	@Resource(name = "processStateServiceImpl")
//	ProcessStateService pros;
//	@PostMapping("/qwe")
//	public void dfds() throws TimeoutException, FormClientException{
////		pros.selectState(null);
////		pros.updateState(null);
//		ThreadData.set(Keys.COMPANY_ID, "17");
//		ThreadData.set(Keys.OPEN_ID, "7d65637b5d634dae");
//
//	}

    /**
     * 每次审批后修改表单大状态
     */
    public int instState() {
        return 1;
    }


    /**
     * 自动提交流程第一步
     *
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    public String instOne(String htmlUrl, String formId, Integer dataRowNun, String tenantId, String processIntsId, String processDefId) throws Exception {
        //查询待办
//		System.err.println("--------------------开始自动提交------------------------");
        JSONObject o = new JSONObject();
        o.put("processInstId", processIntsId);
        o.put("params", processApp.getProcessOneActivityParam(
                processIntsId
                , processDefId
                , formId
                , tenantId
                , dataRowNun));
        Map<String, Object> result = workflowClient.instSeacheHandle(workflowTool.getProcess(o));
        Map<String, Object> map = JSONTool.toObj(JSONTool.toJson(result.get("data")), Map.class);
        String arctiv = null;
        if (!ObjectUtil.empty(map.get("data"))) {
            List<ProcessTask> list = JSONTool.toList(JSONTool.toJson(map.get("data")), ProcessTask.class);
            if (!ObjectUtil.empty(list) && list.size() > 0) {
//				System.out.println("-----------------查询自动提交待办-------------------------");
                o.put("activityInstId", list.get(0).getActivityInstId());
                arctiv = list.get(0).getActivityDefId();
                //执行前判断是否是项目负责人审批
                setProjectleader(list.get(0)
                        , new ProcessState(formId, dataRowNun, tenantId), o);
            } else {
                throw new IEMRuntimeException("流程自动提交待办异常，无待办信息！！");
            }
        }
        o.getString("activityInstId");
        //自动审批第一步
        Map<String, Object> result1 = workflowClient.instFinish(workflowTool.getProcess(o));
        Object c = result1.get("data");
        ProcessState p = new ProcessState(formId, dataRowNun, tenantId);
        p.setProcessUser(ThreadData.get(Keys.OPEN_ID));
        String tasks = "";
        if (!ObjectUtil.empty(c)) {
            ProcessInstance pro = JSONTool.toObj(JSONTool.toJson(c), ProcessInstance.class);
            List<ProcessTask> list = pro.getWorkItems();
            if (list.size() > 0) {
                StringBuffer s = new StringBuffer();
                for (ProcessTask pr : list) {
//					System.out.println("["+cscApi.getUserId(pr.getOpenId())+"]");
//					s.append("["+cscApi.getUserId(pr.getOpenId())+"]");
                    s.append("[" + pr.getParticipantId() + "]");
                }
                tasks = s.toString().replaceAll(",$", "");

                p.setProcessTask(tasks);
                p.setOrderStatus("21");
                p.setProcessState("20");
            } else {
                this.budgetDeduction(tenantId, formId, dataRowNun);
                p.setOrderStatus("40");
                p.setProcessState("30");
//				return arctiv;
            }
        } else {
            throw new IEMRuntimeException("流程自动提交待办异常，自动提交失败");
        }
        //查询待办，把待办人存储到大状态中
        o.remove("activityInstId");
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("processInstId", processIntsId);
        p.setProcessLog(null);
        p.setProcessTask(tasks);
        p.setHtmlUrl(htmlUrl);
        //单据状态改为审核中
        System.err.println("---------------------自动审批第一步----------------------");
        System.out.println("------------------------圆满结束--------------------------");

        process.updateState(p);
        return arctiv;
    }

    /**
     * 审批，退回后后记录已办，和下个节点待办
     *
     * @throws FormClientException
     * @throws TimeoutException
     */
    @SuppressWarnings("unchecked")
    public int record(String processIntsId, Integer flag, String activityInstId) throws TimeoutException, FormClientException {
        //取出表单id
        ProcessInstance pros = processInstance.selectInsts(processIntsId);
        System.out.println("当前流程:" + JSONTool.toJson(pros));
        ProcessState pro = new ProcessState(pros.getFormID(), pros.getDataRowNum(), pros.getTenantID());
        //取出当前流程大状态
        ProcessState p = process.selectState(pro);
        p.setDataRowNum(pros.getDataRowNum());
        p.setFormId(pros.getFormID());
        p.setTenantId(pros.getTenantID());
        System.out.println("当前流程大状态:" + JSONTool.toJson(p));
        //添加已办，已退回
        ProcessCon con = new ProcessCon();
        con.setRetired(p.getProcessLog());
        String z = null;
        if (flag == 0) {
            //添加已办
            con.getRetired().add(String.format(Q, cscApi.getUserId(ThreadData.get(Keys.OPEN_ID))));
            z = con.getLog();
        } else {
            //添加已退
            con.getRetired().add(String.format(A, cscApi.getUserId(ThreadData.get(Keys.OPEN_ID))));
            z = con.getLog();
            if (activityInstId.equals(pros.getActivityInstId())) {
                p.setProcessState("10");
                p.setOrderStatus(p.getOrderCode() != null && !p.getOrderCode().isEmpty() ? "15" : "20");
                z = "";
//				//修改流程log得状态
//				ProcessLog plog = new ProcessLog(pros.getFormID(),pros.getDataRowNum()
//						,pros.getTenantID(),processIntsId
//						,ThreadData.get(Keys.COMPANY_ID),ThreadData.get(Keys.OPEN_ID));
//				plog.setDataType("30");
//				processLogService.updateState(plog);
                //结束流程
//				this.processInstOver(processIntsId);
            }
        }
        p.setProcessLog(z);
        //添加新的待办--------------------------
        JSONObject o = new JSONObject();
        o.put("processInstId", processIntsId);
        Map<String, Object> result3 = workflowClient.instSeacheHandle(workflowTool.getProcess(o));
        Map<String, Object> map1 = JSONTool.toObj(JSONTool.toJson(result3.get("data")), Map.class);
        if (!ObjectUtil.empty(map1.get("data"))) {
            List<ProcessTask> list = JSONTool.toList(JSONTool.toJson(map1.get("data")), ProcessTask.class);
            if (list.size() > 0) {
                StringBuffer s = new StringBuffer();
                for (ProcessTask pr : list) {
                    s.append("[" + cscApi.getUserId(pr.getOpenId()) + "]");
                }
                p.setProcessTask(s.toString().replaceAll(",$", ""));
            }
        }
        //修改当表单大状态
        System.out.println("当前状态:" + JSONTool.toJson(p));
        process.updateState(p);
        return 1;
    }

    //判断是否撤回到了 提交活动步骤
    @SuppressWarnings("unchecked")
    public boolean updateState(String proId) throws TimeoutException, FormClientException {
        System.out.println("------------------判断是否撤销到提交活动------------------------");
        //取出当前流程实例
        ProcessInstance pro = processInstance.selectInsts(proId);
        System.out.println("当前流程实例:" + JSONTool.toJson(pro));
        //查询当前待办
        JSONObject o = new JSONObject();
        o.put("processInstId", pro.getProcessInstId());
        Map<String, Object> result = workflowClient.instSeacheHandle(workflowTool.getProcess(o));
        Map<String, Object> map1 = JSONTool.toObj(JSONTool.toJson(result.get("data")), Map.class);
        System.out.println("当前待办信息:" + JSONTool.toJson(map1));
        if (!ObjectUtil.empty(map1.get("data"))) {
            List<ProcessTask> list = JSONTool.toList(JSONTool.toJson(map1.get("data")), ProcessTask.class);
            ProcessState p = new ProcessState(pro.getFormID(), pro.getDataRowNum(), pro.getTenantID());
            //查询流程大状态
            ProcessState processState = process.selectState(p);
            StringBuffer s = new StringBuffer();
            for (ProcessTask pr : list) {
                s.append("[" + cscApi.getUserId(pr.getOpenId()) + "]");
            }
            p.setProcessTask(s.toString().replaceAll(",$", ""));

            System.out.println("修改流程大状态成功");
            //判断是否是撤销到第一节点
            if (pro.getActivityInstId().equals(list.get(0).getActivityDefId())) {
                //修改流程大状态为未提交
                p.setProcessState("10");
                p.setOrderStatus(processState.getOrderCode() != null
                        && !Objects.equals("", processState.getOrderCode()) ? "15" : "20");
                p.setProcessLog("");
                //结束流程
//				this.processInstOver(proId);
//				//修改流程log得状态
//                ProcessLog plog = new ProcessLog(pro.getFormID(),pro.getDataRowNum()
//                        ,pro.getTenantID(),proId
//                        ,ThreadData.get(Keys.COMPANY_ID),ThreadData.get(Keys.OPEN_ID));
//                plog.setDataType("30");
//                processLogService.updateState(plog);
            }
            process.updateState(p);

        }
        return true;
    }

    //流程结束后执行预算逻辑
    public void budgetDeduction(String tenantId, String formId, Integer dataRowNum) throws FormClientException, TimeoutException {
        if (this.processFilter != null) {
            this.processFilter.executeOver(formId, dataRowNum, tenantId);
        }
    }

//	//取出表单的自动生成编号
//	public String getNumber(pse, String formId,Integer dataRowNum,String tenantId) throws TimeoutException, FormClientException{
//		return getProcessState(formId, dataRowNum,tenantId).getNumber();
//	}

    public ProcessState getProcessState(String formId, Integer dataRowNum, String tenantId) throws TimeoutException, FormClientException {
        return process.selectState(new ProcessState(formId, dataRowNum, tenantId));
    }

    public FormSolidiFication formSolidiFication(String formId, Integer dataRowNum, String tenantId) throws TimeoutException {
        return dataManagementService.formSolidiFication(formId, dataRowNum, tenantId);
    }

    /**
     * 结束流程操作-1
     *
     * @throws TimeoutException
     */
    public int processStateOver(String proId) throws TimeoutException {

        return processInstance.updateProState(proId);
    }


    /**
     * 结束流程操作-2
     *
     * @throws TimeoutException
     */
    public int processInstOver(String proId) throws TimeoutException {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("processInstId", proId);
        workflowClient.instOver(workflowTool.getProcess(jsonObject));
        return 1;
    }

    public void checkData(ProcessState ps) {
        if (Objects.equals(ps.getCreateUser(), ThreadData.get(Keys.OPEN_ID))) {
            log.debug("当前数据操作人员通过验证");
        } else {
            throw new IEMRuntimeException("FORM_USER_AGREEMENT");
        }
    }


    //到账状态
    private static final String CONFORMINGSTATE = "conformingstate";

    //回执号
    private static final String VOUCHERNO = "voucherno";

    //未到账,常量
    private static final String WDZ = "T00001";

    //交易号
    private static final String TRADENUMBER = "tradeNumber";

    /**
     * 新接口 ，编辑并提交，编辑并退回
     */
    @RequestMapping(value = "${requset.processinst14}", method = RequestMethod.POST)
    public Map vouchernoWirte(@RequestBody Map<String, Object> map, HttpServletRequest request) throws Exception {
        String state = Objects.toString(map.get(CONFORMINGSTATE), null);
        String proInstId = Objects.toString(map.get("processInstId"));//当前流程实例id
        //修改表单数据
        ProcessState st = new ProcessState(Objects.toString(map.get("formID")), Integer.parseInt(map.get("dataRowNum").toString()), Objects.toString(map.get("tenantID")));
        st.setConformingstate(state);
        st.setTradeNumber(Objects.toString(map.get(TRADENUMBER), ""));
        st.setVoucherno(Objects.toString(map.get(VOUCHERNO), ""));
        process.updateState(st);
        //判断执行还是退回
        if (Objects.equals(WDZ, state)) {
            log.debug("进入退回");
            //获取可退回活动项
            Map<String, Object> ms = this.getBack(JSONTool.toJson(
                    new ModelMap("processInstId", proInstId)), request);
            Map<String, Object> m = ((List<Map>) ms.get("data")).get(0);
            m.put("formID", map.get("formID"));
            m.put("dataRowNum", map.get("dataRowNum"));
            m.put("tenantID", map.get("tenantID"));
            m.put("processInstId", proInstId);
            m.put("activityInstId", map.get("activityInstId"));
            return this.instBack(m, request);
        } else {
            log.debug("进入执行");
            map.remove(CONFORMINGSTATE);
            map.remove(VOUCHERNO);
            map.remove(TRADENUMBER);
            return this.instFinish(map, request);
        }

    }


    public void setProjectleader(ProcessTask processTask, ProcessState processState, JSONObject jsonObject) throws TimeoutException {
        log.debug("当前是否活动指派前:" + processTask.getAppointActivity());
        if (processTask.getAppointActivity() != null && processTask.getAppointActivity()) {
            ProcessState ps = process.selectState(processState);
            String phone = Objects.toString(ps.getMainInfo().get(PROJECT_LEADER_PHONE), null);
            if (phone != null && !Objects.equals(phone, "")) {
                String id = cscApi.getUserId(phone);
                log.debug("当前人员id:" + id);
                if (id != null && !Objects.equals(id, "")) {
                    jsonObject.put("wfpIds", Arrays.asList(id));
                    jsonObject.put("workItemId", processTask.getWorkItemId());
                }
            }
        }
    }
}