// 节点服务适配器
// 提供与原有API兼容的接口，但使用本地节点定义

import { 
  NODE_DEFINITIONS, 
  getNodeDefinition, 
  getNodesByCategory,
  getEnabledNodes,
  getNodesByCategories 
} from './definitions';
import { WorkflowNodeDefinition, NodeType, NodeCategory } from './types';

// 兼容原有的响应格式
export interface NodeDefinitionResponse {
  id: number;
  nodeCode: string;
  nodeName: string;
  nodeType: NodeType;
  category: NodeCategory;
  description?: string;
  panelVariablesSchema: any;
  uiVariables: any;
  localVariablesSchema?: any;
  formVariablesSchema?: any;
  panelVariables?: Record<string, any>;
  localVariables?: Record<string, any>;
  orderNum?: number;
  enabled?: boolean;
  createTime?: string;
  updateTime?: string;
  version?: number;
}

/**
 * 将节点定义转换为兼容的响应格式
 */
const convertToResponse = (node: WorkflowNodeDefinition, index: number): NodeDefinitionResponse => {
  return {
    id: index + 1, // 生成虚拟ID
    nodeCode: node.nodeCode,
    nodeName: node.nodeName,
    nodeType: node.nodeType,
    category: node.category,
    description: node.description,
    panelVariablesSchema: node.panelVariablesSchema,
    uiVariables: node.uiVariables,
    localVariablesSchema: node.localVariablesSchema,
    formVariablesSchema: node.formVariablesSchema,
    orderNum: node.orderNum || 0,
    enabled: node.enabled !== false,
    createTime: new Date().toISOString(),
    updateTime: new Date().toISOString(),
    version: 1
  };
};

/**
 * 获取节点定义列表（替代原有的API调用）
 * @returns Promise<NodeDefinitionResponse[]>
 */
export const getNodeDefinitionList = async (): Promise<NodeDefinitionResponse[]> => {
  // 模拟异步操作
  return new Promise((resolve) => {
    setTimeout(() => {
      const nodes = getEnabledNodes();
      const response = nodes.map((node, index) => convertToResponse(node, index));
      resolve(response);
    }, 10); // 很短的延迟，模拟网络请求
  });
};

/**
 * 根据节点类型获取节点定义
 * @param nodeType 节点类型
 * @returns Promise<NodeDefinitionResponse | null>
 */
export const getNodeDefinitionByType = async (nodeType: NodeType | string): Promise<NodeDefinitionResponse | null> => {
  return new Promise((resolve) => {
    setTimeout(() => {
      const node = getNodeDefinition(nodeType);
      if (node) {
        const index = NODE_DEFINITIONS.findIndex(n => n.nodeType === nodeType);
        resolve(convertToResponse(node, index));
      } else {
        resolve(null);
      }
    }, 10);
  });
};

/**
 * 获取按分类分组的节点定义
 * @returns Promise<Record<NodeCategory, NodeDefinitionResponse[]>>
 */
export const getNodeDefinitionsByCategories = async (): Promise<Record<NodeCategory, NodeDefinitionResponse[]>> => {
  return new Promise((resolve) => {
    setTimeout(() => {
      const grouped = getNodesByCategories();
      const result = {} as Record<NodeCategory, NodeDefinitionResponse[]>;
      
      Object.entries(grouped).forEach(([category, nodes]) => {
        result[category as NodeCategory] = nodes.map((node) => 
          convertToResponse(node, NODE_DEFINITIONS.findIndex(n => n.nodeCode === node.nodeCode))
        );
      });
      
      resolve(result);
    }, 10);
  });
};

/**
 * 根据分类获取节点定义列表
 * @param category 节点分类
 * @returns Promise<NodeDefinitionResponse[]>
 */
export const getNodeDefinitionsByCategory = async (category: NodeCategory): Promise<NodeDefinitionResponse[]> => {
  return new Promise((resolve) => {
    setTimeout(() => {
      const nodes = getNodesByCategory(category);
      const response = nodes.map((node) => 
        convertToResponse(node, NODE_DEFINITIONS.findIndex(n => n.nodeCode === node.nodeCode))
      );
      resolve(response);
    }, 10);
  });
};

/**
 * 验证节点配置
 * @param nodeType 节点类型
 * @param config 节点配置
 * @returns Promise<{ isValid: boolean; errors: string[] }>
 */
export const validateNodeConfig = async (
  nodeType: NodeType | string, 
  config: Record<string, any>
): Promise<{ isValid: boolean; errors: string[] }> => {
  return new Promise((resolve) => {
    setTimeout(() => {
      const node = getNodeDefinition(nodeType);
      if (!node) {
        resolve({ isValid: false, errors: ['未知的节点类型'] });
        return;
      }

      const errors: string[] = [];
      const required = node.panelVariablesSchema.required || [];
      
      // 验证必填字段
      required.forEach(field => {
        if (!config[field] || config[field] === '') {
          const property = node.panelVariablesSchema.properties[field];
          const title = property?.title || field;
          errors.push(`${title} 是必填字段`);
        }
      });

      resolve({ isValid: errors.length === 0, errors });
    }, 10);
  });
};

// 导出节点定义相关工具
export {
  NODE_DEFINITIONS,
  getNodeDefinition,
  getNodesByCategory,
  getEnabledNodes,
  getNodesByCategories
} from './definitions';

export type { WorkflowNodeDefinition, NodeType, NodeCategory } from './types';