package com.yihu.hos.system.service;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.hos.common.graph.DGraphImpl;
import com.yihu.hos.common.graph.Edge;
import com.yihu.hos.common.graph.IDGraph;
import com.yihu.hos.core.datatype.StringUtil;
import com.yihu.hos.system.dao.AppDao;
import com.yihu.hos.system.dao.AppServiceDao;
import com.yihu.hos.system.dao.FlowProcessDao;
import com.yihu.hos.system.dao.ProcessorDao;
import com.yihu.hos.system.model.*;
import com.yihu.hos.web.framework.model.Result;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;

@Service("ProcessManager")
public class ProcessManager {

    public static final String BEAN_ID = "ProcessManager";

    @Resource(name = AppDao.BEAN_ID)
    private AppDao appDao;
    @Resource(name = AppServiceDao.BEAN_ID)
    private AppServiceDao appServiceDao;
    @Resource(name = ProcessorDao.BEAN_ID)
    private ProcessorDao processorDao;
    @Resource(name = FlowProcessDao.BEAN_ID)
    private FlowProcessDao processDao;
    @Resource(name = FlowManager.BEAN_ID)
    private FlowManager flowManager;

    private ObjectMapper objectMapper = new ObjectMapper();

    public Result getAllEndpoints(String endpointName) throws Exception {

        List<SystemServiceEndpoint> serviceEndpointList = appServiceDao.getListByName(endpointName);
        List<String> appIdList = new ArrayList<>();
        Map<String, List<ProcessResultModel>> appServiceMap = new HashMap<>();
        for (SystemServiceEndpoint endpoint : serviceEndpointList) {
            ProcessResultModel resultModel = new ProcessResultModel();
            resultModel.setName(endpoint.getName());
            resultModel.setValue(endpoint.getEndpoint());
            resultModel.setNodeType("service");
            appIdList.add(endpoint.getAppId());

            List<ProcessResultModel> endpointList;
            if (appServiceMap.get(endpoint.getAppId()) != null) {
                endpointList = appServiceMap.get(endpoint.getAppId());
            } else {
                endpointList = new ArrayList<>();
            }
            endpointList.add(resultModel);
            appServiceMap.put(endpoint.getAppId(), endpointList);
        }
        List<SystemApp> appList = appDao.getAllByIdList(appIdList);
        JSONArray jsonArray = new JSONArray();
        for (SystemApp app : appList) {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("title", app.getName());
            List<ProcessResultModel> resultModelList = appServiceMap.get(app.getId());
            List<ProcessResultModel> resultModelListListTemp = new ArrayList<>();
            if (app.getName().equals("起始端点")) {
                for (ProcessResultModel resultModel : resultModelList) {
                    resultModel.setNodeType("default");
                    resultModelListListTemp.add(resultModel);
                }
                jsonObject.put("list", resultModelListListTemp);
                jsonArray.add(0, jsonObject);
            } else {
                resultModelListListTemp = resultModelList;
                jsonObject.put("list", resultModelListListTemp);
                jsonArray.add(jsonObject);
            }
        }
        return Result.success(jsonArray.toString());
    }

//    public Result getAppServiceByAppId(String appId) throws Exception {
//        String hql = "from SystemServiceEndpoint where appId = "+appId+"";
//        List<SystemServiceEndpoint> serviceEndpointList = appServiceDao.getEntityList(SystemServiceEndpoint.class, hql);
//        String result = objectMapper.writeValueAsString(serviceEndpointList);
//        return Result.success(result);
//    }

    public String getFlowchart(Integer flowId) throws Exception {
        SystemServiceFlowProcess serviceFlowProcess = processDao.getFlowProcessByFlowId(flowId);
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("code", serviceFlowProcess.getCode());
        jsonObject.put("name", serviceFlowProcess.getName());
        jsonObject.put("flowId", serviceFlowProcess.getFlowId());
        jsonObject.put("result", serviceFlowProcess.getResult());

        return jsonObject.toString();
    }

    public Result getAllProcessor(String processorName) throws Exception {
        List<SystemServiceFlowProcessor> processorList = processorDao.getListByName(processorName);
        List<ProcessResultModel> resultModelList = new ArrayList<>();
        for (SystemServiceFlowProcessor processor : processorList) {
            ProcessResultModel resultModel = new ProcessResultModel();
            resultModel.setName(processor.getName());
            resultModel.setValue(processor.getPackageName() + "." + processor.getClassName());
            resultModel.setNodeType("processor");
            resultModelList.add(resultModel);
        }
        String result = objectMapper.writeValueAsString(resultModelList);
        return Result.success(result);
    }

    public void saveProcess(String code, String name, Integer flowId, String positionJsonStr) throws Exception {
        SystemServiceFlowProcess process = new SystemServiceFlowProcess();
        process.setCode(code);
        process.setName(name);
        process.setResult(positionJsonStr);
        process.setFlowId(flowId);
        processDao.saveEntity(process);
    }

    public static void main(String[] args) throws Exception {
        String flowJsonStr = "{\n" +
                "    \"nodes\": {\n" +
                "        \"esb_node_0\": {\n" +
                "            \"name\": \"SDf\",\n" +
                "            \"value\": \"sd\",\n" +
                "            \"nodeType\": \"default\"\n" +
                "        },\n" +
                "        \"esb_node_1\": {\n" +
                "            \"name\": \"crawler转换器\",\n" +
                "            \"value\": \"CrawlerProcessor0\",\n" +
                "            \"nodeType\": \"processor\"\n" +
                "        },\n" +
                "        \"esb_node_2\": {\n" +
                "            \"name\": \"判断\",\n" +
                "            \"value\": \"\",\n" +
                "            \"nodeType\": \"judgement\"\n" +
                "        },\n" +
                "        \"esb_node_3\": {\n" +
                "            \"name\": \"循环\",\n" +
                "            \"value\": \"\",\n" +
                "            \"nodeType\": \"circle\"\n" +
                "        },\n" +
                "        \"esb_node_4\": {\n" +
                "            \"name\": \"全流程-用户信息\",\n" +
                "            \"value\": \"全流程-用户信息\",\n" +
                "            \"nodeType\": \"service\"\n" +
                "        },\n" +
                "        \"esb_node_5\": {\n" +
                "            \"name\": \"全流程-就诊信息\",\n" +
                "            \"value\": \"jetty:http://localhost:8080/clinicInfo\",\n" +
                "            \"nodeType\": \"service\"\n" +
                "        },\n" +
                "        \"esb_node_6\": {\n" +
                "            \"name\": \"分流\",\n" +
                "            \"value\": \"\",\n" +
                "            \"nodeType\": \"multicast\"\n" +
                "        },\n" +
                "        \"esb_node_7\": {\n" +
                "            \"name\": \"crawler转换器\",\n" +
                "            \"value\": \"CrawlerProcessor0\",\n" +
                "            \"nodeType\": \"processor\"\n" +
                "        },\n" +
                "        \"esb_node_8\": {\n" +
                "            \"name\": \"crawler转换器\",\n" +
                "            \"value\": \"CrawlerProcessor0\",\n" +
                "            \"nodeType\": \"processor\"\n" +
                "        },\n" +
                "        \"esb_node_9\": {\n" +
                "            \"name\": \"crawler转换器\",\n" +
                "            \"value\": \"CrawlerProcessor0\",\n" +
                "            \"nodeType\": \"processor\"\n" +
                "        },\n" +
                "        \"esb_node_10\": {\n" +
                "            \"name\": \"聚合\",\n" +
                "            \"value\": \"\",\n" +
                "            \"nodeType\": \"aggregate\"\n" +
                "        }\n" +
                "    },\n" +
                "    \"lines\": {\n" +
                "        \"esb_line_0\": {\n" +
                "            \"from\": \"esb_node_0\",\n" +
                "            \"to\": \"esb_node_1\",\n" +
                "            \"value\": \"\"\n" +
                "        },\n" +
                "        \"esb_line_1\": {\n" +
                "            \"from\": \"esb_node_1\",\n" +
                "            \"to\": \"esb_node_2\",\n" +
                "            \"value\": \"\"\n" +
                "        },\n" +
                "        \"esb_line_2\": {\n" +
                "            \"from\": \"esb_node_2\",\n" +
                "            \"to\": \"esb_node_3\",\n" +
                "            \"value\": \"correct\"\n" +
                "        },\n" +
                "        \"esb_line_3\": {\n" +
                "            \"from\": \"esb_node_3\",\n" +
                "            \"to\": \"esb_node_5\",\n" +
                "            \"value\": \"自定义内容\"\n" +
                "        },\n" +
                "        \"esb_line_4\": {\n" +
                "            \"from\": \"esb_node_3\",\n" +
                "            \"to\": \"esb_node_4\",\n" +
                "            \"value\": \"自定义内容\"\n" +
                "        },\n" +
                "        \"esb_line_5\": {\n" +
                "            \"from\": \"esb_node_2\",\n" +
                "            \"to\": \"esb_node_6\",\n" +
                "            \"value\": \"自定义内容\"\n" +
                "        },\n" +
                "        \"esb_line_6\": {\n" +
                "            \"from\": \"esb_node_6\",\n" +
                "            \"to\": \"esb_node_8\",\n" +
                "            \"value\": \"\"\n" +
                "        },\n" +
                "        \"esb_line_7\": {\n" +
                "            \"from\": \"esb_node_6\",\n" +
                "            \"to\": \"esb_node_7\",\n" +
                "            \"value\": \"\"\n" +
                "        },\n" +
                "        \"esb_line_8\": {\n" +
                "            \"from\": \"esb_node_6\",\n" +
                "            \"to\": \"esb_node_9\",\n" +
                "            \"value\": \"\"\n" +
                "        },\n" +
                "        \"esb_line_9\": {\n" +
                "            \"from\": \"esb_node_9\",\n" +
                "            \"to\": \"esb_node_10\",\n" +
                "            \"value\": \"\"\n" +
                "        }\n" +
                "    }\n" +
                "}";
//        generateFlow("crawler", "业务流程图", flowJsonStr);
    }

    public Integer generateFlow(String code, String name, String flowJsonStr) throws Exception {
        String root = "";
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode flowJson = objectMapper.readValue(flowJsonStr, JsonNode.class);
        //sort flow by lines

        JsonNode lines = flowJson.get("lines");
        Iterator<Map.Entry<String, JsonNode>> lineIterator = lines.fields();
        //get nodeMap by nodes
        JsonNode nodes = flowJson.get("nodes");
        Iterator<Map.Entry<String, JsonNode>> nodeIterator = nodes.fields();
        //for the java code import processor class
        Map<String, JsonNode> nodeMap = new HashMap<>();
        Map<String, JsonNode> lineMap = new HashMap<>();
        IDGraph<String> mDG = new DGraphImpl<String>();
        while (nodeIterator.hasNext()) {
            Map.Entry<String, JsonNode> map = nodeIterator.next();
            nodeMap.put(map.getKey(), map.getValue());
            String type = map.getValue().get("nodeType").asText();
            if (StringUtil.isEmpty(root) && type.equals("default")) {
                root = map.getKey();
            }
            mDG.add(map.getKey());
        }

        while (lineIterator.hasNext()) {
            Map.Entry<String, JsonNode> map = lineIterator.next();
            lineMap.put(map.getKey(), map.getValue());
            String nodeNameFrom = map.getValue().get("from").asText();
            String nodeNameTo = map.getValue().get("to").asText();
            mDG.add(new Edge<>(nodeNameFrom, nodeNameTo, map.getKey()));
        }
        ProcessEditor editor = new ProcessEditor();
        Iterator<String> nodeIt = mDG.iterator(root);
        editor.setCode(code);
        editor.setNodeIt(nodeIt);
        editor.setmDG(mDG);
        editor.setLineMap(lineMap);
        editor.setNodeMap(nodeMap);
        //generate the java code
        String javaName = toUpperCaseFirstOne(code)+"Route";
        String packageName = code+".route";

        String fileInfo = editor.generate(javaName, packageName);

//        Integer flowId = flowManager.sendAddRoute(code, name, javaName, packageName, fileInfo);
        return null;
    }

    //首字母转大写
    public static String toUpperCaseFirstOne(String s) {
        if(Character.isUpperCase(s.charAt(0)))
            return s;
        else
            return (new StringBuilder()).append(Character.toUpperCase(s.charAt(0))).append(s.substring(1)).toString();
    }
}