// 节点分类
export enum NodeCategory {
    EVENT = 'EVENT',
    TASK = 'TASK',
    GATEWAY = 'GATEWAY',
    CONTAINER = 'CONTAINER'
}

// 节点类型（完整定义，包含所有可能的类型）
export enum NodeType {
    START_EVENT = 'START_EVENT',
    END_EVENT = 'END_EVENT',
    USER_TASK = 'USER_TASK',
    SERVICE_TASK = 'SERVICE_TASK',
    SCRIPT_TASK = 'SCRIPT_TASK',
    DEPLOY_NODE = 'DEPLOY_NODE',
    JENKINS_BUILD = 'JENKINS_BUILD',
    NOTIFICATION = 'NOTIFICATION',
    APPROVAL = 'APPROVAL',
    GATEWAY_NODE = 'GATEWAY_NODE',
    SUB_PROCESS = 'SUB_PROCESS',
    CALL_ACTIVITY = 'CALL_ACTIVITY'
}

// 节点类型到分类的映射
export const NODE_CATEGORY_MAP: Record<NodeType, NodeCategory> = {
    [NodeType.START_EVENT]: NodeCategory.EVENT,
    [NodeType.END_EVENT]: NodeCategory.EVENT,
    [NodeType.USER_TASK]: NodeCategory.TASK,
    [NodeType.SERVICE_TASK]: NodeCategory.TASK,
    [NodeType.SCRIPT_TASK]: NodeCategory.TASK,
    [NodeType.DEPLOY_NODE]: NodeCategory.TASK,
    [NodeType.JENKINS_BUILD]: NodeCategory.TASK,
    [NodeType.NOTIFICATION]: NodeCategory.TASK,
    [NodeType.APPROVAL]: NodeCategory.TASK,
    [NodeType.GATEWAY_NODE]: NodeCategory.GATEWAY,
    [NodeType.SUB_PROCESS]: NodeCategory.CONTAINER,
    [NodeType.CALL_ACTIVITY]: NodeCategory.CONTAINER,
};

// 获取节点分类的工具函数
export const getNodeCategory = (nodeType: NodeType | string): NodeCategory => {
    return NODE_CATEGORY_MAP[nodeType as NodeType] || NodeCategory.TASK;
};

// JSON Schema 定义
/**
 * JSON Schema 接口 - 符合 JSON Schema Draft 7 标准
 * 用于定义节点配置和输入映射的表单结构
 */
export interface JSONSchema {
    type?: 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array';
    title?: string;
    description?: string;
    properties?: Record<string, JSONSchema>;
    required?: string[];
    default?: any;
    enum?: any[];
    format?: string;
    pattern?: string;
    minLength?: number;
    maxLength?: number;
    minimum?: number;
    maximum?: number;
    minItems?: number;
    maxItems?: number;
    'x-component'?: string;
    'x-component-props'?: Record<string, any>;
    'x-dataSource'?: string;
    [key: string]: any;  // 允许扩展属性
}

// ========== 输出字段定义 ==========

/**
 * 输出字段定义 - 描述节点执行后产生的数据
 * 用于在节点配置面板中展示，供下游节点引用
 */
export interface OutputField {
    name: string;                    // 字段名（用于表达式引用 ${upstream.buildNumber}）
    title: string;                   // 显示名称
    description: string;             // 详细说明
    type: 'string' | 'number' | 'boolean' | 'object' | 'array';  // 数据类型
    enum?: string[];                 // 枚举值（可选）
    example?: any;                   // 示例值
    required?: boolean;              // 是否必定产生（默认 true）
}

/**
 * 基础输出字段 - 所有节点都会产生的通用字段
 * 类似于 Java 中的继承，每个节点都会自动拥有这些字段
 */
export const BASE_OUTPUT_FIELDS: OutputField[] = [
    {
        name: "status",
        title: "执行状态",
        type: "string",
        enum: ["SUCCESS", "FAILURE"],
        description: "节点执行的最终状态",
        example: "SUCCESS",
        required: true
    }
];

/**
 * 工具函数：定义节点输出字段
 * 类似于 Java 的继承，自动合并基础字段和节点特有字段
 * 
 * @param customFields - 节点特有的输出字段
 * @returns 包含基础字段和自定义字段的完整输出列表
 * 
 * @example
 * ```typescript
 * outputs: defineNodeOutputs(
 *     {
 *         name: "buildNumber",
 *         title: "构建编号",
 *         type: "number",
 *         description: "Jenkins 构建编号",
 *         example: 123,
 *         required: true
 *     },
 *     {
 *         name: "buildUrl",
 *         title: "构建URL",
 *         type: "string",
 *         description: "Jenkins构建页面的访问地址",
 *         example: "http://jenkins.example.com/job/app/123/",
 *         required: true
 *     }
 * )
 * ```
 */
export const defineNodeOutputs = (...customFields: OutputField[]): OutputField[] => {
    return [...BASE_OUTPUT_FIELDS, ...customFields];
};

// ========== 渲染配置（配置驱动节点渲染） ==========

// 节点尺寸
export interface NodeSize {
    width: number;
    height: number;
}

// 节点形状
export type NodeShape = 'circle' | 'rounded-rect' | 'rect' | 'diamond' | 'ellipse';

// 图标配置
export interface IconConfig {
    type: 'emoji' | 'component';  // emoji 或 React 组件
    content: string;               // emoji: "🔨", component: "JenkinsIcon"
    size?: number;                 // 图标大小（默认 24）
}

// 颜色主题配置
export interface ThemeConfig {
    primary: string;              // 主色
    secondary: string;            // 次要色
    selectedBorder: string;       // 选中边框色
    hoverBorder: string;          // Hover 边框色
    gradient: [string, string];   // 背景渐变 [起始, 结束]
}

// 连接点配置
export interface HandlesConfig {
    input: boolean;               // 是否显示输入连接点
    output: boolean;              // 是否显示输出连接点
}

// 功能开关配置
export interface FeaturesConfig {
    showBadge: boolean;           // 是否显示配置徽章
    showHoverMenu: boolean;       // 是否显示 Hover 菜单
}

// 完整的渲染配置
export interface RenderConfig {
    shape: NodeShape;             // 节点形状
    size: NodeSize;               // 节点尺寸
    icon: IconConfig;             // 图标配置
    theme: ThemeConfig;           // 颜色主题
    handles: HandlesConfig;       // 连接点配置
    features: FeaturesConfig;     // 功能开关
}

// 基础节点定义（只有基本配置）
export interface BaseNodeDefinition {
    nodeCode: string;
    nodeName: string;
    nodeType: NodeType;
    category: NodeCategory;
    description: string;
    renderConfig: RenderConfig;         // ✨ 渲染配置（配置驱动）
}

// 可配置节点定义（有3个面板：基本配置、输入映射、输出能力）
export interface ConfigurableNodeDefinition extends BaseNodeDefinition {
    inputMappingSchema?: JSONSchema;   // 输入映射的Schema定义（用户配置）
    outputs?: OutputField[];           // 输出能力定义（只读展示）
}

// 工作流节点定义（联合类型）
export type WorkflowNodeDefinition = BaseNodeDefinition | ConfigurableNodeDefinition;

// 判断是否为可配置节点
export const isConfigurableNode = (def: WorkflowNodeDefinition): def is ConfigurableNodeDefinition => {
    return 'inputMappingSchema' in def || 'outputs' in def;
};
