import store from '@/store';
import { refPublish } from '@/api/appRes';

export const handelEventNodeList = (newRevertedData) => {
  const { appRuntimeData, currentAppData } = store.getState().ideContainer;
  const current = appRuntimeData[currentAppData.id];
  const deleteEventSendNodeList = [];
  const deleteEventlisteneList = [];
  // 处理流程接口后的数据,这里是原始数据的依据
  const currentEventSendNodeList = current.eventSendNodeList;
  const currentEventlisteneList = current.eventlisteneList;
  // 画布数据
  const nodeEntries: [string, any][] = Object.entries(newRevertedData);

  // 分类事件节点 [{nodeId:topic}]
  const eventSendNodes = [];
  const eventListenerNodes = [];

  // 从nodeEntries中提取事件节点
  nodeEntries.forEach(([nodeId, nodeConfig]) => {
    if (nodeConfig.component?.type === 'EVENTSEND') {
      try {
        const customDef = JSON.parse(nodeConfig.component.customDef);
        eventSendNodes.push({ nodeId, topic: customDef.topic });
      } catch (e) {
        eventSendNodes.push({ nodeId, topic: nodeConfig.component.customDef.topic });
      }
    }
    else if (nodeConfig.component?.type === 'EVENTLISTENE') {
      try {
        const customDef = JSON.parse(nodeConfig.component.customDef);
        eventListenerNodes.push({ nodeId, topic: customDef.topic });
      } catch (e) {
        eventListenerNodes.push({ nodeId, topic: nodeConfig.component.customDef.topic });
      }
    }
  });

  // 处理EVENTSEND节点
  // 1. 原始数据中有但新数据中没有的节点，直接加入删除列表（节点被删除）
  currentEventSendNodeList.forEach((eventNode) => {
    const nodeId = Object.keys(eventNode)[0];
    const nodeInCanvas = eventSendNodes.find(node => node.nodeId === nodeId);

    if (!nodeInCanvas) {
      // 画布数据中没有该节点，说明节点被删除了，直接加入删除列表
      deleteEventSendNodeList.push(eventNode[nodeId]);
    }
  });

  // 2. 遍历新数据中的每个事件节点
  eventSendNodes.forEach((newNode) => {
    const newNodeId = newNode.nodeId;
    // nodeId格式为"节点类型-时间戳"
    const newNodeParts = newNodeId.split('-');
    const newNodeTimestamp = parseInt(newNodeParts[newNodeParts.length - 1]) || 0;

    // 在原始数据中查找相同类型的节点
    const sameTypeNodes = currentEventSendNodeList.filter(node => {
      const nodeIdKey = Object.keys(node)[0];
      const nodeIdParts = nodeIdKey.split('-');
      // 比较节点类型部分（除了时间戳）
      return nodeIdParts.slice(0, -1).join('-') === newNodeParts.slice(0, -1).join('-');
    });

    if (sameTypeNodes.length > 0) {
      // 获取这些同类型节点中的最大时间戳
      const maxTimestamp = Math.max(...sameTypeNodes.map(node => {
        const nodeIdKey = Object.keys(node)[0];
        return parseInt(nodeIdKey.split('-')[nodeIdKey.split('-').length - 1]) || 0;
      }));

      // 查找新节点在原始数据中的对应项
      const correspondingNode = currentEventSendNodeList.find(node => {
        const nodeIdKey = Object.keys(node)[0];
        return nodeIdKey === newNodeId;
      });

      // 如果找到了对应的节点
      if (correspondingNode) {
        const correspondingNodeId = Object.keys(correspondingNode)[0];
        const correspondingTopic = correspondingNode[correspondingNodeId];

        // 比较topic是否一致
        if (newNode.topic !== correspondingTopic) {
          // topic不一致，将原始数据的topic加入删除列表
          deleteEventSendNodeList.push(correspondingTopic);
        }
      }
      // 如果新节点的时间戳小于最大时间戳，则说明它是一个旧版本，应该被删除
      else if (newNodeTimestamp < maxTimestamp) {
        // 查找该节点在currentEventSendNodeList中的完整对象
        const nodeToDelete = currentEventSendNodeList.find(node => {
          const nodeIdKey = Object.keys(node)[0];
          return nodeIdKey === newNodeId;
        });

        if (nodeToDelete) {
          const nodeIdKey = Object.keys(nodeToDelete)[0];
          deleteEventSendNodeList.push(nodeToDelete[nodeIdKey]);
        }
      }
    }
    // 如果sameTypeNodes为空，说明这是一个全新的节点类型，不需要处理
  });

  // 处理EVENTLISTENE节点
  // 1. 原始数据中有但新数据中没有的节点，直接加入删除列表（节点被删除）
  currentEventlisteneList.forEach((eventNode) => {
    const nodeId = Object.keys(eventNode)[0];
    const nodeInCanvas = eventListenerNodes.find(node => node.nodeId === nodeId);

    if (!nodeInCanvas) {
      // 画布数据中没有该节点，说明节点被删除了，直接加入删除列表
      deleteEventlisteneList.push(eventNode[nodeId]);
    }
  });

  // 2. 遍历新数据中的每个事件节点
  eventListenerNodes.forEach((newNode) => {
    const newNodeId = newNode.nodeId;
    // nodeId格式为"节点类型-时间戳"
    const newNodeParts = newNodeId.split('-');
    const newNodeTimestamp = parseInt(newNodeParts[newNodeParts.length - 1]) || 0;

    // 在原始数据中查找相同类型的节点
    const sameTypeNodes = currentEventlisteneList.filter(node => {
      const nodeIdKey = Object.keys(node)[0];
      const nodeIdParts = nodeIdKey.split('-');
      // 比较节点类型部分（除了时间戳）
      return nodeIdParts.slice(0, -1).join('-') === newNodeParts.slice(0, -1).join('-');
    });

    if (sameTypeNodes.length > 0) {
      // 获取这些同类型节点中的最大时间戳
      const maxTimestamp = Math.max(...sameTypeNodes.map(node => {
        const nodeIdKey = Object.keys(node)[0];
        return parseInt(nodeIdKey.split('-')[nodeIdKey.split('-').length - 1]) || 0;
      }));

      // 查找新节点在原始数据中的对应项
      const correspondingNode = currentEventlisteneList.find(node => {
        const nodeIdKey = Object.keys(node)[0];
        return nodeIdKey === newNodeId;
      });

      // 如果找到了对应的节点
      if (correspondingNode) {
        const correspondingNodeId = Object.keys(correspondingNode)[0];
        const correspondingTopic = correspondingNode[correspondingNodeId];

        // 比较topic是否一致
        if (newNode.topic !== correspondingTopic) {
          // topic不一致，将原始数据的topic加入删除列表
          deleteEventlisteneList.push(correspondingTopic);
        }
      }
      // 如果新节点的时间戳小于最大时间戳，则说明它是一个旧版本，应该被删除
      else if (newNodeTimestamp < maxTimestamp) {
        // 查找该节点在currentEventlisteneList中的完整对象
        const nodeToDelete = currentEventlisteneList.find(node => {
          const nodeIdKey = Object.keys(node)[0];
          return nodeIdKey === newNodeId;
        });

        if (nodeToDelete) {
          const nodeIdKey = Object.keys(nodeToDelete)[0];
          deleteEventlisteneList.push(nodeToDelete[nodeIdKey]);
        }
      }
    }
    // 如果sameTypeNodes为空，说明这是一个全新的节点类型，不需要处理
  });

  return {
    deleteEventSendNodeList,
    deleteEventlisteneList
  };
};

export const updateEvent = (revertedData, appid) => {
  // 初始化参数对象
  const params: any = {
    eventListenes: [],
    eventSends: []
  };

  // 遍历所有节点，查找事件相关节点
  Object.entries(revertedData).forEach(([nodeId, nodeConfig]: [string, any]) => {
    // 检查节点是否有component属性和type定义
    if (nodeConfig.component?.type) {
      const nodeType = nodeConfig.component.type;
      const customDef = nodeConfig.component.customDef;

      // 解析customDef，可能是字符串也可能是对象
      let eventConfig;
      if (typeof customDef === 'string') {
        try {
          eventConfig = JSON.parse(customDef);
        } catch (e) {
          console.error('Failed to parse customDef:', e);
          return;
        }
      }
      else {
        eventConfig = customDef;
      }

      // 根据节点类型处理事件节点
      if (nodeType === 'EVENTLISTENE') {
        // 事件接收节点
        params.eventListenes.push({
          nodeName: nodeConfig.nodeName || '',
          eventId: eventConfig?.eventId || null,
          topic: eventConfig?.topic || '',
          eventName: eventConfig?.name || '',
          dataOuts: nodeConfig.dataOuts || [],
          nodeId: nodeConfig.nodeId
        });
      }
      else if (nodeType === 'EVENTSEND') {
        // 事件发送节点
        params.eventSends.push({
          nodeName: nodeConfig.nodeName || '',
          eventId: eventConfig?.eventId || null,
          topic: eventConfig?.topic || '',
          eventName: eventConfig?.name || '',
          dataIns: nodeConfig.dataIns || [],
          nodeId: nodeConfig.nodeId
        });
      }
    }
  });
  // 调用更新事件的API
  if (params.eventListenes.length > 0 || params.eventSends.length > 0) {
    return params;
  }
  else return null;
};
export const upDatePublish = async (revertedData) => {
  const { currentAppData } = store.getState().ideContainer;
  const params = {
    appId: currentAppData.id,
    publishAppId: []
  };
  revertedData.forEach(item => {
    if (item?.component && item.component.type === 'SUB' && !item.component.customDef) params.publishAppId.push(item.component.compId); // 复合组件的这个compId实际上就是flowHousVO里面的id
  });
  if (params.publishAppId.length > 0) {
    const res: any = await refPublish(params);
    if (res.code === 200) return res.data;
    else return {};
  }
  else return {};
};