"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var function_1 = require("./function");
/**
 * construct
 * 将提供的节点/边信息，构造成可供Netflix Conductor服务编排框架的JSON树
 * @param source
 * @param config
 */
function construct(source, config) {
    var nodes = source.nodes; // 节点
    var edges = source.edges; // 边
    // 中间层节点构造函数
    var MiddleLayerNode = function (id) {
        var node = nodes.find(function (item) {
            return item.id === id;
        });
        this.id = node.id;
        this.label = node.label;
        // 出入
        this.out = [];
        this.in = [];
    };
    /**
     * 一、for of 循环遍历边，寻找边的源节点与目标节点，构造一个统计节点上下游的集合，是一个中间层节点数组
     *
     * 如果存在，则 直接获取 并告诉它它的上一个节点和下一个节点是谁，记录在 in 和 out
     * 如果不存在，则 创建后 再告诉它它的上一个节点和下一个节点是谁，记录在 in 和 out
     *
     * 整个循环下来，我们可以知道所有节点的上一个节点和下一个节点是谁
     * 其中上一个节点是谁记录在in，下一个节点是谁记录在ouyt，类似链表
     */
    var nodeMap = {};
    for (var _i = 0, edges_1 = edges; _i < edges_1.length; _i++) {
        var edge = edges_1[_i];
        var sourceNodeId = edge.source; // 源节点ID
        var targetNodeId = edge.target; // 目标节点ID
        var sourceNode = // 记录边的源节点
         void 0; // 记录边的源节点
        var targetNode = // 记录边的源节点
         void 0; // 记录边的源节点
        // 先判断集合中是否已存在当前边的源节点/目标节点，
        // 存在，则直接取
        // 不存在，则实例化一个中间层节点，并放入集合中，以便后续遍历匹配时可直接取
        if (nodeMap[sourceNodeId]) {
            sourceNode = nodeMap[sourceNodeId];
        }
        else {
            // sourceNode = new MiddleLayerNode(sourceNodeId);
            nodeMap[sourceNodeId] = sourceNode = new MiddleLayerNode(sourceNodeId);
        }
        if (nodeMap[targetNodeId]) {
            targetNode = nodeMap[targetNodeId];
        }
        else {
            // targetNode = new MiddleLayerNode(targetNodeId);
            nodeMap[targetNodeId] = targetNode = new MiddleLayerNode(targetNodeId);
        }
        // 边联系源节点和目标节点，说明源节点的下游输出是目标节点、目标节点的上游输入是源节点
        // 以此记录节点上下游，遍历结束则完成构造一个统计节点上下游的集合
        sourceNode.out.push({
            edge: edge,
            target: targetNode
        });
        targetNode.in.push({
            edge: edge,
            source: sourceNode
        });
    }
    /**
     * 二、寻找开始节点和结束节点
     *
     * 如果无上一节点，则说明是开始节点
     * 如果无下一节点，则说明是结束节点
     */
    var startNode = null;
    var endNode = null;
    for (var _a = 0, _b = Object.keys(nodeMap); _a < _b.length; _a++) {
        var item = _b[_a];
        // 开始节点（无上游输入）
        if (nodeMap[item].in.length === 0) {
            startNode = nodeMap[item];
        }
        // 结束节点（无下游输出）
        if (nodeMap[item].out.length === 0) {
            endNode = nodeMap[item];
        }
    }
    /**
     * 三、定义输出结果结构
     */
    var result = {
        // 开始节点信息
        label: "",
        // 执行步骤
        steps: [],
        // 结束节点信息（输出参数）
        outputParams: {}
    };
    result.label = startNode.label;
    result.steps = [];
    // 开始组装
    for (var _c = 0, _d = startNode.out; _c < _d.length; _c++) {
        var item = _d[_c];
        if (item.target.out.length === 1) {
            // 服务节点
            function_1.serviceNodeHandle(item.target, result.steps);
        }
        else if (item.target.out.length > 1) {
            // 条件节点
            result.steps.push(function_1.conditionNodeHandle(item.target));
        }
    }
    return result;
}
exports.construct = construct;
// 拆解
function destruct() { }
exports.destruct = destruct;

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/**
 * 服务节点处理函数
 * @param node    节点
 * @param context 上下文
 */
function serviceNodeHandle(node, context) {
    var res = {
        label: node.label,
        type: "service"
    };
    context.push(res);
    var nextNode = node.out[0].target;
    // 服务节点
    if (nextNode.out.length === 1) {
        serviceNodeHandle(nextNode, context);
    }
    // 条件节点
    if (nextNode.out.length > 1) {
        context.push(conditionNodeHandle(nextNode));
    }
}
exports.serviceNodeHandle = serviceNodeHandle;
/**
 * 条件节点处理函数
 * @param node
 */
function conditionNodeHandle(node) {
    var res = {
        label: node.label,
        type: "condition",
        decisionCases: {}
    };
    for (var _i = 0, _a = node.out; _i < _a.length; _i++) {
        var next = _a[_i];
        res.decisionCases[next.edge.label] = [];
        // 服务节点
        if (next.target.out.length === 1) {
            serviceNodeHandle(next.target, res.decisionCases[next.edge.label]);
        }
        // 条件节点
        if (next.target.out.length > 1) {
            res.decisionCases[next.edge.label].push(conditionNodeHandle(next.target));
        }
    }
    return res;
}
exports.conditionNodeHandle = conditionNodeHandle;