import {
  itemHeight,
  maxLevel,
  nodeWidth,
  titleTextX,
  handleLabelLength
} from './registerShape';
/**
 * 获取选中 label 的所有左关联边
 * @param edges node 的所有 edges
 * @param model node 的 model
 * @param sourceAnchor 选中的 label
 * @param leftActiveEdges 左关联边集合
 */
export const getLeftRelation = (
  edges: any[],
  model: any,
  sourceAnchor: any,
  leftActiveEdges: any[]
) => {
  const source = model['id']; // 当前节点
  const isClickField = model.attrs?.some(attr => attr.key === sourceAnchor);
  edges
    .filter((edge: any) => !leftActiveEdges.includes(edge))
    .forEach((edge: any) => {
      if (edge.getModel()['target'] === source && (isClickField ? edge.getModel()['targetAnchor'] === sourceAnchor : true)) {
        leftActiveEdges.push(edge);

        const currentNode = edge.getSource();
        const currentModel = currentNode.getModel();
        const currentEdges = currentNode.getInEdges();
        const currentSourceAnchor = edge.getModel()['sourceAnchor'];
        getLeftRelation(
          currentEdges,
          currentModel,
          currentSourceAnchor,
          leftActiveEdges
        );
      }
    });
};

/**
 * 获取选中 label 的所有右关联边
 * @param edges node 的所有 edges
 * @param model node 的 model
 * @param sourceAnchor 选中的 label
 * @param rightActiveEdges 右关联边集合
 */
export const getRightRelation = (
  edges: any[],
  model: any,
  sourceAnchor: any,
  rightActiveEdges: any[]
) => {
  const source = model['id']; // 当前节点
  const isClickField = model.attrs?.some(attr => attr.key === sourceAnchor);
  edges
    .filter((edge: any) => !rightActiveEdges.includes(edge))
    .forEach((edge: any) => {
      if (edge.getModel()['source'] === source && (isClickField ? edge.getModel()['sourceAnchor'] === sourceAnchor : true)) {
        rightActiveEdges.push(edge);

        const currentNode = edge.getTarget();
        const currentModel = currentNode.getModel();
        const currentEdges = currentNode.getOutEdges();
        const currentTargetAnchor = edge.getModel()['targetAnchor'];
        getRightRelation(
          currentEdges,
          currentModel,
          currentTargetAnchor,
          rightActiveEdges
        );
      }
    });
};

/**
 * 放大
 * @param graph
 */
export const handleZoomOut = (graph: any) => {
    if (!graph) return;
    const current = graph.getZoom();
    const canvas = graph.get('canvas');
    
    const point = canvas.getPointByClient(
      canvas.get('width') / 2,
      canvas.get('height') / 2
    );
    const pixelRatio = canvas.get('pixelRatio') || 1;
    const ratio = 1 + 0.05 * 5;
    if (ratio * current > 5) {
      return;
    }
    graph.zoom(ratio, {
      x: point.x / pixelRatio,
      y: point.y / pixelRatio,
    });
    graph.fitCenter();
    return {
      text: `${Math.round(ratio * current * 100)}%`,
      ratio: ratio * current,
    };
  };
  
  /**
   * 缩小
   * @param graph
   */
  export const handleZoomIn = (graph: any) => {
    if (!graph) return;
    const current = graph.getZoom();
    const canvas = graph.get('canvas');
    const point = canvas.getPointByClient(
      canvas.get('width') / 2,
      canvas.get('height') / 2
    );
    const pixelRatio = canvas.get('pixelRatio') || 1;
    console.log(pixelRatio)
    const ratio = 1 - 0.05 * 5;
    if (current < 0.1) {
      return;
    }
    graph.zoom(ratio, {
      x: point.x / pixelRatio,
      y: point.y / pixelRatio,
    });
    graph.fitCenter();
    return {
      text: `${Math.round(ratio * current * 100)}%`,
      ratio: ratio * current,
    };
  };
  
  /**
   * 实际大小
   * @param graph
   */
  export const handleRealZoom = (graph: any) => {
    if (!graph) return;
    const current = graph.getZoom();
    graph.zoom(1 / current);
    graph.fitCenter();
    return {
      text: '100%',
      ratio: 1,
    };
  };

  /**
   * 自适应canvas大小
   */
  export const handleAutoZoom = (graph: any) => {
    if (!graph) return;
    const nodes = graph.getNodes();
    if (nodes.length > 0) {
      graph.setMinZoom(0.35);
     graph.setMaxZoom(0.5);
      graph.fitView(40, { direction: 'both' });
      graph.fitCenter();
      graph.setMinZoom(0.1);
      graph.setMaxZoom(4);
    }
    const current = graph.getZoom();
    return {
      text: `${Math.round(current * 100)}%`,
      ratio: current,
    };
  };
  
  /**
   * 推拽后恢复布局
   * @param graph
   */
  export const handleRefreshLayout = (graph: any) => {
    if (!graph) return;
    graph.layout();
  };
  // 中英文切换
  /**
   * 下载图片
   * @param graph
   */
  export const handleDownloadImage = (graph: any) => {
    if (!graph) return;
    graph.downloadFullImage('open-lineage', 'image/png', {
      backgroundColor:"#f7f7f9",
      padding:40
    });
  };
  export const handleDownLoadImgUrl = (graph: any,fn)=>{
    if (!graph) return;
    graph.toFullDataURL(fn,'open-lineage', 'image/png');
  }
  /**
   * 全屏查看
   */
  export const handleEnterFullscreen = (container: any) => {
    if (container.requestFullscreen) {
      container.requestFullscreen();
    } else if (container.mozRequestFullScreen) {
      // Firefox
      container.mozRequestFullScreen();
    } else if (container.webkitRequestFullscreen) {
      // Chrome, Safari and Opera
      container.webkitRequestFullscreen();
    } else if (container.msRequestFullscreen) {
      // IE/Edge
      container.msRequestFullscreen();
    }
  };
  
  /**
   * 退出全屏
   */
  export const handleExitFullscreen = () => {
    if (document.exitFullscreen) {
      document.exitFullscreen();
      // @ts-ignore
    } else if (document.mozCancelFullScreen) {
      // @ts-ignore Firefox
      document.mozCancelFullScreen();
      // @ts-ignore
    } else if (document.webkitExitFullscreen) {
      // @ts-ignore Chrome, Safari and Opera
      document.webkitExitFullscreen();
      // @ts-ignore
    } else if (document.msExitFullscreen) {
      // @ts-ignore IE/Edge
      document.msExitFullscreen();
    }
  };
  
  /**
   * 渲染视图
   */
  export const renderGraph = (graph: any, lineageData: any) => {
    if (!graph || !lineageData) return;
    graph.setMinZoom(0.3);
    graph.setMaxZoom(0.5);
   // graph.setMaxZoom(1);
    graph.data(lineageData);
    graph.render();
    
    graph.fitView(40, { direction: 'both' });
    graph.fitCenter();

  };
  
  /**
   * 设置连线高亮颜色
   * @param graph
   * @param color
   */
  export const handleHighlightColor = (graph: any, color: string) => {
    if (!graph) return;
    // 查询所有选中的元素
    const edges = graph.findAll('edge', (item: any) => {
      return (
        item.getStates().length !== 0 &&
        item.getStates()[0].startsWith('highlight')
      );
    });
    if (edges) {
      edges.forEach((edge: any) =>
        graph.setItemState(edge, `highlight-${color}`, true)
      );
    }
  };
  
  /**
   * 清除状态
   */
  export const clearAllStats = (graph: any) => {
    if (!graph) return;
    graph.setAutoPaint(false);
    // 清除节点状态
    graph.getNodes().forEach(function (node: any) {
      graph.clearItemStates(node);
    });
    // 清除边状态
    graph.getEdges().forEach(function (edge: any) {
      graph.clearItemStates(edge);
    });
    //清除combo状态。
    graph.getCombos().forEach(function (combo: any) {
      combo.getEdges().forEach((edge: any) => {
        graph.clearItemStates(edge);
      });
      graph.clearItemStates(combo);
    });
    graph.paint();
    graph.setAutoPaint(true);
  };
  
  /**
   * 设置左边关联节点及边状态
   * @param edges 边
   */
  export const setLeftStats = (
    graph: any,
    edges: any[],
    color: string,
    name: string
  ) => {
    if (!graph) return;
    edges.forEach(function (edge: any) {
      graph.setItemState(edge, `tableHighlight-${color}`, true);
      edge.toFront();
  
      const sourceAnchor = edge.getModel()['sourceAnchor'];
      const isClickField = edge.getSource().getModel().attrs?.some(attr => attr.key === sourceAnchor);
      graph.setItemState(edge.getSource(), isClickField ? ('fieldHighlight' + '-' + sourceAnchor) : (name + '-' + sourceAnchor), true);
    });
  };
  
  /**
   * 设置右边关联节点及边状态
   * @param edges 边
   */
  export const setRightStats = (
    graph: any,
    edges: any[],
    color: string,
    name: string
  ) => {
    if (!graph) return;
    edges.forEach(function (edge: any) {
      graph.setItemState(edge, `tableHighlight-${color}`, true);
      edge.toFront();
  
      const targetAnchor = edge.getModel()['targetAnchor'];
      const isClickField = edge.getTarget().getModel().attrs?.some(attr => attr.key === targetAnchor);
      graph.setItemState(edge.getTarget(), isClickField ? ('fieldHighlight' + '-' + targetAnchor) : (name + '-' + targetAnchor), true);
    });
  };

export interface LineageData {
  /** 来源 */
  refFields: LineageItem;
  /** 目标 */
  targetField?: LineageItem;
  prop: LineageProp
}

export interface LineageItem {
  [x: string]: string | number | undefined;
  /** 表英文名称 */
  name: string;
  /** 表中文名称 */
  chName: string;
  /** 表guid，查看元数据详情时使用 */
  guid?: string;
  /** 库名称 + 表名称 +字段名称， 中间 "." 分隔*/
 // fieldName: string;
  /** 是否是层级最大的，即是否是最外层的 */
  final?: string;
  /** order， 同一列即同一level的上下位置，表0在最上方。 */
  index?: string;
  /** 层级, 表示在第几排，数字0从右边开始排列，左边数字大 */
  level?: string;
  /** 所在数据库 */
  database?: string;
  /** 所在数据库中文名 */
  databaseChName?: string;
  id: number,
  isCenter:number
}
export interface propItem {
  label:string;
  syncTaskGuid:string;
  syncTaskName:string;}
export type LineageProp =  Array<propItem>
// 自定义数据转换
export const transformData = (data: LineageData[], primaryTable: string, primaryDatabase: string,isCh:boolean,layputDagre:boolean) => {
  const nodes: any[] = [];
  // 用 map 实现对象去重
  const edgeMap: Map<string, any> = new Map();
  // 用 set 实现表名去重
  const tableFields: Map<string, any> = new Map();
  // 用set实现数据库去重。
  const databaseMap: Set<any> = new Set();
  /** 数据库key为英文名+表英文名，值为中文名。 */
  const databaseNameMap: Map<string, any> = new Map();
  /** 数据库key为英文名+表英文名，值为中文名 */
  const databaseEnNameMap: Map<string, any> = new Map();

  data.forEach((item: LineageData) => {
    const prop = item.prop
    const targetField = item.targetField || item.refFields;
    const tableField = targetField && handleTableField(targetField);
    tableField && tableFields.set(tableField, targetField);
    targetField && databaseMap.add(targetField.database + '-' + targetField.name);
    item.refFields && databaseMap.add(item.refFields.database + '-' + item.refFields.name);
    targetField && databaseNameMap.set((targetField.database + '-' + targetField.name) || '', targetField.databaseChName || targetField.databaseName);
    targetField && databaseEnNameMap.set((targetField.database + '-' + targetField.name) || '', targetField.database);
    item.refFields && databaseNameMap.set((item.refFields.database + '-' + item.refFields.name) || '', item.refFields.databaseChName ||item.refFields.databaseName);
    item.refFields && databaseEnNameMap.set((item.refFields.database + '-' + item.refFields.name) || '', item.refFields.database);
    if (item.refFields) {
      tableField && createEdge(edgeMap, tableFields, targetField, [item.refFields], prop,layputDagre);
    }
  });

  createNode(nodes, tableFields, primaryTable,isCh,layputDagre);
  const edges = Array.from(edgeMap.values());
  const combos = Array.from(databaseMap).map(ds => {
    let isPrimary = (primaryDatabase + '-' + primaryTable) == ds;
    return {
      id: ds,
      label:isCh ?databaseEnNameMap.get(ds) : databaseNameMap.get(ds)?databaseNameMap.get(ds):databaseEnNameMap.get(ds) ,
      expand: true,
      database:databaseEnNameMap.get(ds),
      databaseChName:databaseNameMap.get(ds),
      isPrimary: isPrimary,
      layputDagre:layputDagre,
      isFieldLineage: false,
      style: {
        stroke: '#E0EFFF',
        fill: isPrimary ? '#276FF5' : '#E0EFFF',
        radius: 10
      },
      labelCfg: {
        refX: titleTextX,
        refY: 30,
        style: {
          fill: isPrimary ? '#fff' : '#216ED1', // 文本标签的颜色
          fontSize: 32, // 文本标签的字体大小
          fontWeight: 500,
        }
      }
    }
  });
  return {
    nodes,
    edges,
    combos
  };
};

/**
 * 自定义字段数据转换
 * 字段血缘还要处理临时表。
 */
export const transformFieldData = (data: LineageData[], primaryTable: string, primaryDatabase: string,isCh:boolean,layputDagre:boolean, primaryField: string) => {
  const nodes: any[] = [];
  // 用 map 实现对象去重
  const edgeMap: Map<string, any> = new Map();
  // 用 set 实现表名去重
  const tableFields: Map<string, any> = new Map();
  // 用set实现数据库去重。
  const databaseMap: Set<any> = new Set();
  /** 数据库key为英文名+表英文名，值为中文名。 */
  const databaseNameMap: Map<string, any> = new Map();
  /** 数据库key为英文名+表英文名，值为中文名 */
  const databaseEnNameMap: Map<string, any> = new Map();
   /** 库表key为英文名+表英文名，值为中文名。 */
   const tableNameMap: Map<string, any> = new Map();
   /** 库表key为英文名+表英文名，值为中文名 */
   const tableEnNameMap: Map<string, any> = new Map();
   /** 判断是否是临时表，只有字段血缘才有临时表的概念。 */
   const isSubByds: Map<string, any> = new Map();

  data.forEach((item: LineageData) => {
    const prop = item.prop
    const targetField = item.targetField || item.refFields;
    const tableField = targetField && handleTableFieldLineage(targetField);
    tableField && tableFields.set(tableField, targetField);
    targetField && databaseMap.add(targetField.database + '-' + targetField.table);
    item.refFields && databaseMap.add(item.refFields.database + '-' + item.refFields.table);
    targetField && databaseNameMap.set((targetField.database + '-' + targetField.table) || '', targetField.databaseChName || targetField.databaseName);
    targetField && databaseEnNameMap.set((targetField.database + '-' + targetField.table) || '', targetField.database);
    targetField && tableNameMap.set((targetField.database + '-' + targetField.table) || '', targetField.tableChName || targetField.table);
    targetField && tableEnNameMap.set((targetField.database + '-' + targetField.table) || '', targetField.table);
    targetField && isSubByds.set((targetField.database + '-' + targetField.table), targetField.isSub);
    item.refFields && databaseNameMap.set((item.refFields.database + '-' + item.refFields.table) || '', item.refFields.databaseChName ||item.refFields.databaseName);
    item.refFields && databaseEnNameMap.set((item.refFields.database + '-' + item.refFields.table) || '', item.refFields.database);
    item.refFields && tableNameMap.set((item.refFields.database + '-' + item.refFields.table) || '', item.refFields.tableChName  ||item.refFields.table);
    item.refFields && tableEnNameMap.set((item.refFields.database + '-' + item.refFields.table) || '', item.refFields.table);
    item.refFields && isSubByds.set(item.refFields.database + '-' + item.refFields.table, item.refFields.isSub);
    if (item.refFields) {
      tableField && createEdgeByField(edgeMap, tableFields, targetField, [item.refFields], prop,layputDagre);
    }
  });
  createNodeByField(nodes, tableFields, primaryField,isCh,layputDagre);
  const edges = Array.from(edgeMap.values());
  const combos = Array.from(databaseMap).map(ds => {
    let isPrimary = (primaryDatabase + '-' + primaryTable) == ds;
    let isSub = isSubByds.get(ds);
    return {
      id: ds,
      label: isSub ? (isCh ?tableEnNameMap.get(ds) : (tableNameMap.get(ds)?tableNameMap.get(ds) : tableNameMap.get(ds))) : (isCh ?databaseEnNameMap.get(ds) : (databaseNameMap.get(ds)?databaseNameMap.get(ds) : databaseEnNameMap.get(ds))),
      expand: true,
      database:databaseEnNameMap.get(ds),
      databaseChName:databaseNameMap.get(ds),
      isSub: isSub,
      tableChineseName: tableNameMap.get(ds) || tableEnNameMap.get(ds),
      tableChName: isCh ?tableEnNameMap.get(ds) : (tableNameMap.get(ds) || tableEnNameMap.get(ds)),
      table: tableEnNameMap.get(ds),
      isPrimary: isPrimary,
      isFieldLineage: true,
      layputDagre:layputDagre,
      style: {
        stroke: '#E0EFFF',
        fill: isPrimary ? '#276FF5' : '#E0EFFF',
        radius: 10
      },
      labelCfg: {
        refX: titleTextX,
        refY: 30,
        style: {
          fill: isPrimary ? '#fff' : '#216ED1', // 文本标签的颜色
          fontSize: 32, // 文本标签的字体大小
          fontWeight: 500,
        }
      }
    }
  });
  return {
    nodes,
    edges,
    combos
  };
}

/**
 * 创建 Edge 即连线即字段之间的连线
 */
const createEdge = (
  edgeMap: Map<string, any>,
  tableFields: Map<string, LineageItem>,
  target: LineageItem,
  refFields: LineageItem[],
  prop:LineageProp,
  layputDagre:boolean
) => {
  const targetField = handleTableField(target);
  const targetInfo = targetField && getTableFieldName(targetField);
  const targetName = (<any>targetInfo)?.tableName;
  const targetAnchor = (<any>target)?.database;
  refFields.forEach((ref: any) => {
    const tableField = handleTableField(ref);
    tableFields.set(tableField, ref);

    const source = getTableFieldName(tableField);
    const sourceName = source.tableName;
    const sourceAnchor = ref.database;
    // 不能自连，防止绘制失败
    if (targetName === sourceName) {
      return;
    }
    
    const edge: any = {midPointColor: '#f00', quatileColor: '#f00'};
    edge.source = sourceName;
    edge.sourceAnchor = sourceAnchor;
    edge.target = targetName;
    edge.targetAnchor = targetAnchor;
    edge.label = ref.name;
    edge.prop = prop
    edge.layputDagre = layputDagre
    edge.isMount = true;
    edge.sourceInfo = ref;
    edge.targetInfo = target;
  
    let key = sourceName + sourceAnchor + '-' + targetName + targetAnchor;
    edgeMap.set(key, edge);
  });
};

const createEdgeByField = (
  edgeMap: Map<string, any>,
  tableFields: Map<string, LineageItem>,
  target: LineageItem,
  refFields: LineageItem[],
  prop:LineageProp,
  layputDagre:boolean
) => {
  const targetField = handleTableFieldLineage(target);
  const targetInfo = targetField && getTableFieldNameByFieldLineage(targetField);
  const targetName = (<any>targetInfo)?.tableField;
  const targetAnchor = (<any>target)?.database + '.' + target.table;
  refFields.forEach((ref: any) => {
    const tableField = handleTableFieldLineage(ref);
    tableFields.set(tableField, ref);

    const source = getTableFieldNameByFieldLineage(tableField);
    const sourceName = source.tableField;
    const sourceAnchor = ref.database + '.' + ref.table;
    // 不能自连，防止绘制失败
    if ((targetName + targetAnchor) === (sourceName + sourceAnchor)) {
      return;
    }
    
    const edge: any = {midPointColor: '#f00', quatileColor: '#f00'};
    edge.source = sourceName;
    edge.sourceAnchor = sourceAnchor;
    edge.target = targetName;
    edge.targetAnchor = targetAnchor;//anchor即数据库，不同数据库下的表名可能重复
    edge.label = ref.name;
    edge.prop = prop
    edge.layputDagre = layputDagre
    edge.isMount = true;
    edge.sourceInfo = ref;
    edge.targetInfo = target;
  
    let key = sourceName + sourceAnchor + '-' + targetName + targetAnchor;
    edgeMap.set(key, edge);
  });
};

/**
 * 拼接库名加表名。
 */
const handleTableField = (item: any) => {
  const fieldName = item.database + '.' + item.name;
  let tableField = '';
  if (item.final) {
    tableField = fieldName;
  } else {
    tableField = `${item.level}-${item.index}:${fieldName}`;
  }
  return tableField;
};

/** 拼接库名+表名+字段名 */
const handleTableFieldLineage = (item: any) => {
  const fieldName = item.database + '.' + item.table + '.' + item.name;
  let tableField = '';
  if (item.final) {
    tableField = fieldName;
  } else {
    tableField = `${item.level}-${item.index}:${fieldName}`;
  }
  return tableField;
}

/**
 * 拆分字符串获取表名称，字段名称
 */
const getTableFieldName = (item: string) => {
  const names: string[] = item.split(':');
  let tableName = '';
  let tableField = '';
  let ds = "";
  if (names.length === 1) {
    const array = names[0].split('.');
    tableName = array[1];
    tableField = array[2];
  } else {
    const array = names[1].split('.');
    tableName = array[1] + '_' + names[0];
    tableField = array[2];
    ds = array[0];
  }
  return { tableName, tableField, ds };
};

const getTableFieldNameByFieldLineage = (item: string) => {
  const names: string[] = item.split(':');
  let tableName = '';
  let tableField = '';
  let ds = "";
  if (names.length === 1) {
    const array = names[0].split('.');
    tableField = array[2];
    tableName = array[1];
  } else {
    const array = names[1].split('.');
    tableField = array[2] + '_' + names[0];
    tableName = array[1];
    ds = array[0];
  }
  return { tableName, tableField, ds };
};

/**
 * 获取表层级及order
 */
const getTableLevelAndOrder = (tableField: string) => {
  let level = maxLevel;
  let order = 0;
  const endIndex = tableField.lastIndexOf('-');
  if (endIndex !== -1) {
    const startIndex = tableField.lastIndexOf('_');
    level = Number(tableField.slice(startIndex + 1, endIndex));
    order = Number(tableField.slice(endIndex + 1, tableField.length));
  }
  return { level, order };
};

/**
 * 创建 Node 即节点即表
 */
const createNode = (nodes: any[], tableFields: Map<string, LineageItem>, primaryTable: string,isCh:boolean,layputDagre:boolean) => {
  tableFields.forEach((item: LineageItem, tableKey: any, map) => {
    const attrs: any[] = [];
    // 处理字段的
    // value.forEach((attr: any) => {
    //   attrs.push({
    //     nodeId: key,
    //     key: attr,
    //     type: '',
    //   });
    // });
    const table = getTableFieldName(tableKey);
    const key = table.tableName;

    const { level, order } = getTableLevelAndOrder(key);
    let defaultExpand = false;
    const height = itemHeight * ((defaultExpand ? attrs.length : 0) + 1);
    const value = handleLabelLength(isCh ?item.name:item.chName?item.chName:item.name)
    console.log(value,"value")
    const obj: any = {
      id: key,
      key: key,
      label: value,
      guid: item.guid,
      enName:item.name,
      chName:item.chName || item.name,
      tableName: item.name,
      tableChName: item.chName || item.name,
      databaseChName:item.databaseChName || item.database,
      database:item.database,
      x: 100,
      y: 100,
      anchorPoints:[
        [0, 0], 
        [1, 0], 
      ],
      level: level,
      order: order,
      isCenter:item.isCenter,
      vertexId:item.id,
      attrs1: attrs,
      attrs: [],
      expand: defaultExpand,
      layputDagre:layputDagre,
      isPrimary: item.isCenter===1 && item.name == primaryTable,
      size: [nodeWidth, height],
      draggable: false
    };
    obj.comboId = item.database + '-' + item.name;
    nodes.push(obj);
  });
};

const createNodeByField = (nodes: any[], tableFields: Map<string, LineageItem>, primaryTable: string,isCh:boolean,layputDagre:boolean) => {
  tableFields.forEach((item: LineageItem, tableKey: any, map) => {
    const attrs: any[] = [];
    const table = getTableFieldNameByFieldLineage(tableKey);
    const key = table.tableField;

    const { level, order } = getTableLevelAndOrder(key);
    let defaultExpand = false;
    const height = itemHeight * ((defaultExpand ? attrs.length : 0) + 1);
    const value = handleLabelLength(isCh ? item.name : (item.chName || item.name));
    const obj: any = {
      id: key,
      key: key,
      label: value,
      guid: item.guid,
      enName: item.name,
      chName: item.chName || item.name,
      tableName: item.table,
      tableChName: item.tableChName || item.table,
      tableGuid: item.tableGuid,
      isFieldLineage: true,
      databaseChName:item.databaseChName || item.database,
      database:item.database,
      isSub: item.isSub,
      x: 100,
      y: 100,
      anchorPoints:[
        [0, 0], 
        [1, 0], 
      ],
      level: level,
      order: order,
      isCenter:item.isCenter,
      vertexId:item.id,
      attrs: [],
      expand: defaultExpand,
      layputDagre:layputDagre,
      isPrimary: item.isCenter == 1 && item.name == primaryTable,
      size: [nodeWidth, height],
      draggable: false
    };
    obj.comboId = item.database + '-' + item.table;
    nodes.push(obj);
  });
};