import { useCallback, useState } from 'react';
import { message } from 'antd';
import * as definitionService from '../../Definition/service';
import type { FlowNode, FlowEdge } from '../types';
import { NodeType, isConfigurableNode } from '../nodes/types';

interface WorkflowSaveData {
    nodes: FlowNode[];
    edges: FlowEdge[];
    workflowId?: number;
    name?: string;
    description?: string;
    definitionData?: any;  // 原始工作流定义数据
}

/**
 * 简化的保存前验证 - 只检查必需的业务规则
 * 连接层面的验证已在 FlowCanvas 的 isValidConnection 中处理
 */
const validateBeforeSave = (nodes: FlowNode[]): { valid: boolean; message?: string } => {
    // 1. 检查是否为空
    if (nodes.length === 0) {
        return { valid: false, message: '流程图中没有任何节点，请至少添加一个节点' };
    }

    // 2. 检查必需的开始节点
    const hasStartNode = nodes.some(node => node.data.nodeType === NodeType.START_EVENT);
    if (!hasStartNode) {
        return { valid: false, message: '流程图中必须包含开始节点' };
    }

    // 3. 检查必需的结束节点
    const hasEndNode = nodes.some(node => node.data.nodeType === NodeType.END_EVENT);
    if (!hasEndNode) {
        return { valid: false, message: '流程图中必须包含结束节点' };
    }

    return { valid: true };
};

export const useWorkflowSave = () => {
    const [saving, setSaving] = useState(false);
    const [lastSaved, setLastSaved] = useState<Date | null>(null);
    const [hasUnsavedChanges, setHasUnsavedChanges] = useState(false);

    // 保存工作流数据
    const saveWorkflow = useCallback(async (data: WorkflowSaveData): Promise<boolean> => {
        // 保存前验证（只验证业务规则，连接验证在 isValidConnection 中）
        const validationResult = validateBeforeSave(data.nodes);
        if (!validationResult.valid) {
            message.error(validationResult.message || '工作流验证失败');
            return false;
        }
        
        setSaving(true);
        
        try {
            // 转换节点和边数据为后端格式
            const graph = {
                nodes: data.nodes.map(node => ({
                    id: node.id,                    // 使用React Flow的节点ID（UUID）
                    nodeCode: node.data.configs?.nodeCode || node.data.nodeType,  // ✅ 使用预定义的 nodeCode（如 "START_EVENT"）
                    nodeType: node.data.nodeType,
                    nodeName: node.data.label,
                    position: {
                        x: Math.round(node.position.x),
                        y: Math.round(node.position.y)
                    },
                    configs: node.data.configs || {},
                    inputMapping: node.data.inputMapping || {},
                    outputs: (node.data.nodeDefinition && isConfigurableNode(node.data.nodeDefinition)) 
                        ? node.data.nodeDefinition.outputs || []
                        : []  // ✅ 输出能力定义（直接从节点定义中获取）
                })),
                edges: data.edges.map(edge => ({
                    id: edge.id,
                    from: edge.source,               // 后端使用from字段
                    to: edge.target,                 // 后端使用to字段
                    name: edge.data?.label || "",    // 边的名称
                    config: {
                        type: "sequence",            // 固定为sequence类型
                        condition: edge.data?.condition  // 保存边条件
                    },
                    vertices: []                     // 暂时为空数组
                }))
            };

            // ✅ 透传模式：只传递业务字段，更新 graph
            const workflowData = {
                ...data.definitionData,  // 透传原始数据
                graph  // 只覆盖 graph 字段
            };

            // 只有更新操作（外层列表已创建草稿，这里只更新）
            await definitionService.updateDefinition(data.workflowId!, workflowData as any);
            message.success('工作流保存成功');

            setLastSaved(new Date());
            setHasUnsavedChanges(false);
            
            return true;
        } catch (error) {
            console.error('保存工作流失败:', error);
            message.error('保存工作流失败');
            return false;
        } finally {
            setSaving(false);
        }
    }, []);

    // 自动保存功能
    const autoSave = useCallback(async (data: WorkflowSaveData) => {
        if (!hasUnsavedChanges || !data.workflowId) return;
        
        try {
            await saveWorkflow(data);
            console.log('自动保存成功');
        } catch (error) {
            console.error('自动保存失败:', error);
        }
    }, [hasUnsavedChanges, saveWorkflow]);

    // 标记有未保存更改
    const markUnsaved = useCallback(() => {
        setHasUnsavedChanges(true);
    }, []);

    // 标记已保存
    const markSaved = useCallback(() => {
        setHasUnsavedChanges(false);
        setLastSaved(new Date());
    }, []);

    return {
        saving,
        lastSaved,
        hasUnsavedChanges,
        saveWorkflow,
        autoSave,
        markUnsaved,
        markSaved
    };
};
