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

import { markRaw } from 'vue'
import { api } from '@/shared/api/common'
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 {
    // 使用 Jingrow RPC 调用后端 whitelist 函数
    const res = await api.call('jingrow.ai.utils.jlocal.get_all_node_metadata')
    
    // Jingrow whitelist 函数返回值被包装在 message 字段中
    const result = res?.message || res
    
    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 isLoading = false
let loadPromise = null

// 初始化/重新加载节点元数据（每次调用都会重新加载，确保获取最新数据）
async function initializeNodeMetadata() {
  // 如果正在加载，返回同一个 Promise，避免重复请求
  if (isLoading && loadPromise) {
    return loadPromise
  }
  
  isLoading = true
  loadPromise = (async () => {
    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_type)
        }
      })
      
      // 自动生成节点分组
      NODE_GROUPS = generateNodeGroups(NODE_METADATA_MAP)
      return NODE_METADATA_MAP
    } catch (error) {
      console.error('加载节点元数据失败:', error)
      NODE_METADATA_MAP = {}
      NODE_GROUPS = []
      return {}
    } finally {
      isLoading = false
      loadPromise = null
    }
  })()
  
  return loadPromise
}

// 导出函数（保持同步接口）
export function getNodeMetadataByType(type) {
  // 如果数据为空，可能还在加载中，返回null让组件处理
  if (Object.keys(NODE_METADATA_MAP).length === 0) {
    return null
  }
  return NODE_METADATA_MAP[type]
}

export function getAllNodeTypes() {
  return Object.values(NODE_METADATA_MAP)
}

export function getNodeGroups() {
  return NODE_GROUPS
}

export function getNodeComponents() {
  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 }