// 节点元数据统一管理文件
// 从JSON文件的metadata字段动态加载节点元数据

import { markRaw } from 'vue'
import GenericNode from '../components/Nodes/GenericNode.vue'
import MultiOutputNode from '../components/Nodes/MultiOutputNode.vue'

// 组件映射（直接使用文件名）
const COMPONENT_MAP = {
  GenericNode,
  MultiOutputNode
}

// 根据组件类型解析Vue组件
function resolveComponent(componentType) {
  return COMPONENT_MAP[componentType] || GenericNode
}

// 发现所有节点的元数据（从API获取）
async function discoverNodeMetadata() {
  try {
    const response = await fetch('/jingrow/node-definitions/metadata');
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    
    const result = await response.json();
    
    if (result.success && result.data) {
      return result.data;
    } else {
      console.warn('获取节点元数据失败:', result);
      return {};
    }
  } catch (error) {
    console.error('获取节点元数据失败:', error);
    return {};
  }
}

// 自动生成节点分组
function generateNodeGroups(metadataMap) {
  const groupMap = {}
  
  Object.values(metadataMap).forEach(metadata => {
    const group = metadata.group || '其他'
    if (!groupMap[group]) {
      groupMap[group] = {
        group: group,
        label: group,
        types: []
      }
    }
    groupMap[group].types.push(metadata.type)
  })
  
  return Object.values(groupMap)
}

// 节点元数据映射（异步初始化）
let NODE_METADATA_MAP = {}
let NODE_GROUPS = []
let isInitialized = false

// 初始化节点元数据
async function initializeNodeMetadata() {
  if (isInitialized) return
  
  try {
    const LOCAL_METADATA = await discoverNodeMetadata()
    
    // 构建最终的元数据映射
    NODE_METADATA_MAP = {}
    Object.keys(LOCAL_METADATA).forEach(type => {
      const metadata = LOCAL_METADATA[type]
      NODE_METADATA_MAP[type] = {
        ...metadata,
        component: resolveComponent(metadata.component)
      }
    })
    
    // 自动生成节点分组
    NODE_GROUPS = generateNodeGroups(NODE_METADATA_MAP)
    isInitialized = true
  } catch (error) {
    console.error('初始化节点元数据失败:', error)
    NODE_METADATA_MAP = {}
    NODE_GROUPS = []
  }
}

// 导出函数（保持同步接口）
export function getNodeMetadataByType(type) {
  if (!isInitialized) {
    // 如果还没初始化，返回null，组件会处理这种情况
    return null
  }
  return NODE_METADATA_MAP[type]
}

export function getAllNodeTypes() {
  if (!isInitialized) {
    return []
  }
  return Object.values(NODE_METADATA_MAP)
}

export function getNodeGroups() {
  if (!isInitialized) {
    return []
  }
  return NODE_GROUPS
}

export function getNodeComponents() {
  if (!isInitialized) {
    return {}
  }
  const components = {}
  Object.keys(NODE_METADATA_MAP).forEach(type => {
    if (NODE_METADATA_MAP[type].component) {
      components[type] = NODE_METADATA_MAP[type].component
    }
  })
  return components
}

// 预加载函数
export async function preloadNodeMetadata() {
  await initializeNodeMetadata()
}

// 导出常量
export { NODE_METADATA_MAP, NODE_GROUPS }