import {
  proxyActivities,
  defineSignal,
  defineQuery,
  setHandler,
  condition,
  sleep,
  workflowInfo,
} from '@temporalio/workflow';
import type * as activities from '../activities/approval.activities';

// ==================== 类型定义 ====================

// 从 Activities 导入类型
type ProcessModel = activities.ProcessModel;
type ProcessNode = activities.ProcessNode;
type ProcessEdge = activities.ProcessEdge;
type ProcessSettings = activities.ProcessSettings;
type NodeHook = activities.NodeHook;
type NodeValidator = activities.NodeValidator;

// 工作流状态
interface WorkflowState {
  instanceId: string;
  processModel: ProcessModel;
  settings: ProcessSettings;
  variables: Record<string, any>;
  initiatorId: string;
  businessType: string;
  businessId: string;
  businessKey?: string;
  callbackUrl?: string;
  
  // 运行状态
  status: InstanceStatus;
  currentNodeId: string | null;
  
  // 执行历史
  history: ApprovalHistoryItem[];
  
  // 循环保护计数
  nodeExecutionCounts: Record<string, number>;
  totalNodeExecutions: number;
  
  // Signal 队列
  pendingSignals: PendingSignal[];
  
  // 终止标志
  shouldTerminate: boolean;
  terminateReason: string | null;
  terminateType: 'WITHDRAWN' | 'ADMIN_TERMINATE' | null; // ⭐ 明确标识终止类型（移除 'OTHER'）
  
  // ⭐ 新增：立即同步标志（用于需要即时更新数据库的场景）
  needsImmediateSync?: boolean;

  // ERR-20260501-004：审批人解析失败时挂起，管理员通过 resumeWithApprovers 信号注入审批人
  resumedApprovers?: string[];
}

interface PendingSignal {
  type: SignalType;
  data: any;
  receivedAt: number;
}

type SignalType =
  | 'approve'
  | 'reject'
  | 'return'
  | 'forward'
  | 'withdraw'
  | 'approverWithdraw'
  | 'addSign'
  | 'claim'
  | 'unclaim'
  | 'remind'
  | 'adminTerminate'
  | 'execute';

interface ApprovalHistoryItem {
  nodeId: string;
  nodeName: string;
  action: string;
  operatorId: string;
  comment?: string;
  actionTime: number;
}

type InstanceStatus = 'RUNNING' | 'SUSPENDED' | 'APPROVED' | 'REJECTED' | 'WITHDRAWN' | 'TERMINATED' | 'FAILED';

type NodeExecutionResult =
  | { type: 'NEXT'; nextNodeId: string }
  | { type: 'END'; endStatus?: InstanceStatus }
  | { type: 'RETURN'; returnNodeId: string }
  | { type: 'TERMINATE'; reason?: string };

// ==================== Activity 代理 ====================

const {
  createNodeInstance,
  completeNodeInstance,
  skipNodeInstance,
  suspendInstanceForUnresolvedApprovers,
  resumeInstanceFromSuspension,
  failNodeInstance,
  updateProcessStatus,
  failProcess,
  onProcessCompleted,
  createApprovalTask,
  createAutoApprovedTask,
  completeTask,
  cancelTask,
  getTask,
  escalateTask,
  forwardTask,
  resolveApprovers,
  resolveManagerChain,
  sendReminder,
  sendNotification,
  scheduleReminder,
  callbackFormEngine,
  callbackBusinessSystem,
  addToRetryQueue,
  createActionLog,
  executeHook,
  executeHooks,
  validateNode,
  checkDelegation,
  resolveDelegateUser,
  executeDelegation,
  // TD-6: 业务数据集成
  syncBusinessDataChanges,
  getBusinessDataForCondition,
} = proxyActivities<typeof activities>({
  startToCloseTimeout: '60s',
  retry: {
    maximumAttempts: 3,
    initialInterval: '1s',
    backoffCoefficient: 2,
  },
});

// ==================== Signal 定义 ====================

export const approveSignal = defineSignal<[{
  taskId: string;
  operatorId: string;
  comment?: string;
  formData?: any;
  attachments?: any;
  isAdminAction?: boolean;
}]>('approve');

export const rejectSignal = defineSignal<[{
  taskId: string;
  operatorId: string;
  comment: string;
  rejectCode?: string;
  attachments?: any;
  isAdminAction?: boolean;
}]>('reject');

export const returnSignal = defineSignal<[{
  taskId: string;
  operatorId: string;
  targetNodeId: string;
  comment: string;
}]>('return');

export const forwardSignal = defineSignal<[{
  taskId: string;
  operatorId: string;
  toUserId: string;
  comment?: string;
}]>('forward');

export const withdrawSignal = defineSignal<[{
  operatorId: string;
  reason?: string;
}]>('withdraw');

export const approverWithdrawSignal = defineSignal<[{
  taskId: string;
  operatorId: string;
  reason: string;
}]>('approverWithdraw');

export const addSignSignal = defineSignal<[{
  taskId: string;
  operatorId: string;
  userIds: string[];
  type: 'BEFORE' | 'AFTER' | 'PARALLEL';
  comment?: string;
}]>('addSign');

export const claimSignal = defineSignal<[{
  taskId: string;
  operatorId: string;
}]>('claim');

export const remindSignal = defineSignal<[{
  taskId: string;
  operatorId: string;
  message?: string;
}]>('remind');

export const adminTerminateSignal = defineSignal<[{
  operatorId: string;
  reason: string;
}]>('adminTerminate');

export const executeSignal = defineSignal<[{
  taskId: string;
  operatorId: string;
  formData: any;
  comment?: string;
  attachments?: any;
}]>('execute');

/**
 * ERR-20260501-004 配套：节点审批人无法解析时 workflow 挂起，管理员通过此 signal 提供
 * 审批人列表恢复流程。signal payload 是直接的 user id 数组（不走 expression 解析）。
 */
export const resumeWithApproversSignal = defineSignal<[{
  approverIds: string[];
  resolvedBy: string;
}]>('resumeWithApprovers');

// ==================== Query 定义 ====================

export const statusQuery = defineQuery<InstanceStatus>('status');
export const currentNodeQuery = defineQuery<string | null>('currentNode');
export const historyQuery = defineQuery<ApprovalHistoryItem[]>('history');
export const pendingTasksQuery = defineQuery<string[]>('pendingTasks');

// ==================== 工作流输入 ====================

export interface ApprovalWorkflowInput {
  instanceId: string;
  processModel: ProcessModel;
  settings: ProcessSettings;
  variables: Record<string, any>;
  initiatorId: string;
  businessType: string;
  businessId: string;
  businessKey?: string;
  callbackUrl?: string;
}

// ==================== 主工作流 ====================

export async function genericApprovalWorkflow(input: ApprovalWorkflowInput): Promise<void> {
  // 初始化状态
  const state: WorkflowState = {
    instanceId: input.instanceId,
    processModel: input.processModel,
    settings: input.settings,
    variables: input.variables,
    initiatorId: input.initiatorId,
    businessType: input.businessType,
    businessId: input.businessId,
    businessKey: input.businessKey,
    callbackUrl: input.callbackUrl,
    status: 'RUNNING',
    currentNodeId: null,
    history: [],
    nodeExecutionCounts: {},
    totalNodeExecutions: 0,
    pendingSignals: [],
    shouldTerminate: false,
    terminateReason: null,
    terminateType: null, // ⭐ 初始化终止类型
  };

  // 设置 Signal 处理器
  setupSignalHandlers(state);

  // 设置 Query 处理器
  setupQueryHandlers(state);

  try {
    // 找到开始节点
    const startNode = findStartNode(state.processModel);
    if (!startNode) {
      throw new Error('Process model has no START node');
    }

    // 执行流程
    let currentNodeId = startNode.id;
    
    while (currentNodeId && !state.shouldTerminate) {
      state.currentNodeId = currentNodeId;
      
      const node = findNode(state.processModel, currentNodeId);
      if (!node) {
        throw new Error(`Node not found: ${currentNodeId}`);
      }

      // 循环保护检查
      const loopProtectionResult = checkLoopProtection(state, currentNodeId);
      if (!loopProtectionResult.allowed) {
        await failProcess({
          instanceId: state.instanceId,
          error: loopProtectionResult.reason!,
        });
        state.status = 'FAILED';
        break;
      }

      // 执行节点
      const result = await executeNode(state, node);

      // 处理执行结果
      if (result.type === 'NEXT') {
        currentNodeId = result.nextNodeId;
      } else if (result.type === 'END') {
        state.status = result.endStatus || 'APPROVED'; // ⭐ 修复：使用 APPROVED 而不是 COMPLETED
        break;
      } else if (result.type === 'RETURN') {
        currentNodeId = result.returnNodeId;
      } else if (result.type === 'TERMINATE') {
        state.status = 'TERMINATED';
        state.terminateReason = result.reason || null;  // ⭐ 无原因时设置为 null
        break;
      }
    }

    // 处理终止
    if (state.shouldTerminate) {
      // ⭐ 使用 terminateType 明确区分不同的终止原因
      if (state.terminateType === 'WITHDRAWN') {
        state.status = 'WITHDRAWN';
      } else if (state.terminateType === 'ADMIN_TERMINATE') {
        state.status = 'TERMINATED';
      } else if (state.terminateReason === 'REJECTED') {
        // ⭐ 拒绝的状态已经在 endStatus 中正确设置，不要覆盖
        // 保持 state.status 不变（应该是 REJECTED）
      } else if (!state.terminateType && state.terminateReason?.includes('Withdrawn')) {
        // ⭐ 兼容性处理：旧 workflow 实例（没有 terminateType 字段）使用字符串匹配
        state.status = 'WITHDRAWN';
      } else {
        state.status = 'TERMINATED';
      }
      
      // ⚠️ 注意：撤回/管理员终止等流程操作已经创建了独立的操作节点
      // 不再需要执行 END 节点，避免审批历史中出现冗余的"结束"节点
      // 
      // 参考钉钉/飞书：撤回后只显示"发起 → 审批中 → 撤回"
      // 不显示单独的"结束"节点
    }

    // 更新最终状态
    await updateProcessStatus({
      instanceId: state.instanceId,
      status: state.status,
      endReason: state.terminateReason || undefined,
    });

    // 流程完成回调
    await onProcessCompleted({
      instanceId: state.instanceId,
      status: state.status,
      callbackUrl: state.callbackUrl,
    });

    // 回调表单引擎
    await callbackFormEngine({
      instanceId: state.instanceId,
      status: state.status,
      businessType: state.businessType,
      businessId: state.businessId,
    });

  } catch (error: any) {
    // 处理错误
    await failProcess({
      instanceId: state.instanceId,
      error: error.message || 'Unknown error',
    });
    state.status = 'FAILED';
    throw error;
  }
}

// ==================== Signal 处理器设置 ====================

function setupSignalHandlers(state: WorkflowState): void {
  setHandler(approveSignal, (data) => {
    // ⭐ Signal handler 只更新状态（轻量级，非阻塞）
    state.pendingSignals.push({
      type: 'approve',
      data,
      receivedAt: Date.now(),
    });
    
    // ⭐ 立即标记需要同步处理（关键改进）
    state.needsImmediateSync = true;
  });

  setHandler(rejectSignal, (data) => {
    state.pendingSignals.push({
      type: 'reject',
      data,
      receivedAt: Date.now(),
    });
    
    state.needsImmediateSync = true;
  });

  setHandler(returnSignal, (data) => {
    state.pendingSignals.push({
      type: 'return',
      data,
      receivedAt: Date.now(),
    });
  });

  setHandler(forwardSignal, (data) => {
    state.pendingSignals.push({
      type: 'forward',
      data,
      receivedAt: Date.now(),
    });
  });

  setHandler(withdrawSignal, (data) => {
    state.shouldTerminate = true;
    state.terminateReason = data.reason || null;  // ⭐ 无原因时设置为 null
    state.terminateType = 'WITHDRAWN'; // ⭐ 明确标识为撤回
  });

  setHandler(approverWithdrawSignal, (data) => {
    state.pendingSignals.push({
      type: 'approverWithdraw',
      data,
      receivedAt: Date.now(),
    });
  });

  setHandler(addSignSignal, (data) => {
    state.pendingSignals.push({
      type: 'addSign',
      data,
      receivedAt: Date.now(),
    });
  });

  setHandler(claimSignal, (data) => {
    state.pendingSignals.push({
      type: 'claim',
      data,
      receivedAt: Date.now(),
    });
  });

  setHandler(remindSignal, async (data) => {
    // 催办直接处理，不需要等待
    await sendReminder({
      taskId: data.taskId,
      userId: data.operatorId,
      message: data.message,
    });
  });

  setHandler(adminTerminateSignal, (data) => {
    state.shouldTerminate = true;
    state.terminateReason = data.reason;
    state.terminateType = 'ADMIN_TERMINATE'; // ⭐ 明确标识为管理员强制终止
  });

  setHandler(executeSignal, (data) => {
    state.pendingSignals.push({
      type: 'execute',
      data,
      receivedAt: Date.now(),
    });
  });

  // ERR-20260501-004：管理员通过此 signal 在审批人解析失败后注入审批人，恢复挂起的 workflow
  setHandler(resumeWithApproversSignal, (data) => {
    state.resumedApprovers = data.approverIds;
  });
}

// ==================== Query 处理器设置 ====================

function setupQueryHandlers(state: WorkflowState): void {
  setHandler(statusQuery, () => state.status);
  setHandler(currentNodeQuery, () => state.currentNodeId);
  setHandler(historyQuery, () => state.history);
  setHandler(pendingTasksQuery, () => {
    // 返回待处理的任务 ID 列表
    return state.pendingSignals
      .filter((s) => ['approve', 'reject'].includes(s.type))
      .map((s) => s.data.taskId);
  });
}

// ==================== 节点执行 ====================

async function executeNode(state: WorkflowState, node: ProcessNode): Promise<NodeExecutionResult> {
  // 创建节点实例
  const nodeInstanceId = await createNodeInstance({
    instanceId: state.instanceId,
    nodeId: node.id,
    nodeName: node.name,
    nodeType: node.type,
    assignees: node.assignees,
    approvalMode: node.approvalMode,
  });

  // 执行前置钩子
  if (node.beforeEnterHooks?.length) {
    await executeHooks({
      hooks: node.beforeEnterHooks,
      context: {
        instanceId: state.instanceId,
        nodeId: node.id,
        variables: state.variables,
      },
    });
  }

  let result: NodeExecutionResult;

  try {
    switch (node.type) {
      case 'START':
        result = await executeStartNode(state, node);
        break;
      case 'END':
        result = await executeEndNode(state, node);
        break;
      case 'USER_TASK':
        result = await executeUserTaskNode(state, node, nodeInstanceId);
        break;
      case 'SERVICE_TASK':
        result = await executeServiceTaskNode(state, node);
        break;
      case 'GATEWAY':
      case 'EXCLUSIVE_GATEWAY':
        result = await executeGatewayNode(state, node);
        break;
      case 'PARALLEL_GATEWAY':
        result = await executeParallelGatewayNode(state, node);
        break;
      default:
        result = { type: 'NEXT', nextNodeId: findNextNode(state.processModel, node.id) || '' };
    }

    // ✅ 根据执行结果决定节点状态
    // 零技术债原则：流程终止时，未完成的节点应该标记为 SKIPPED，而不是 COMPLETED
    if (result.type === 'TERMINATE') {
      // 流程被终止（撤回、拒绝、管理员强制终止等）
      // 这些节点实际上没有被执行完成，应该标记为 SKIPPED
      await skipNodeInstance({
        nodeInstanceId,
        reason: result.reason || state.terminateReason || '',  // ⭐ 无原因时使用空字符串
      });
    } else {
      // 正常完成节点（NEXT、END、RETURN 等）
      await completeNodeInstance({ nodeInstanceId, result });
      
      // 执行后置钩子（仅在正常完成时执行）
      if (node.afterCompleteHooks?.length) {
        await executeHooks({
          hooks: node.afterCompleteHooks,
          context: {
            instanceId: state.instanceId,
            nodeId: node.id,
            variables: state.variables,
          },
        });
      }
    }

  } catch (error: any) {
    await failNodeInstance({
      nodeInstanceId,
      error: error.message,
    });
    throw error;
  }

  return result;
}

// ==================== 开始节点 ====================

async function executeStartNode(state: WorkflowState, node: ProcessNode): Promise<NodeExecutionResult> {
  const nextNodeId = findNextNode(state.processModel, node.id);
  if (!nextNodeId) {
    throw new Error('START node has no outgoing edge');
  }
  return { type: 'NEXT', nextNodeId };
}

// ==================== 结束节点 ====================

async function executeEndNode(state: WorkflowState, node: ProcessNode): Promise<NodeExecutionResult> {
  // 根据流程的终止原因决定最终状态
  // 如果是拒绝导致的结束，状态应该是REJECTED
  // 如果是正常审批完成，状态是APPROVED
  const endStatus = state.terminateReason === 'REJECTED' ? 'REJECTED' : 'APPROVED';
  return { type: 'END', endStatus };
}

// ==================== 用户任务节点 ====================

async function executeUserTaskNode(
  state: WorkflowState,
  node: ProcessNode,
  nodeInstanceId: string,
): Promise<NodeExecutionResult> {
  // 解析审批人
  let approvers: string[] = [];
  
  // ✅ 方案B：兼容性修复 - 如果 assignees 为空，尝试从 config.approverType 动态生成
  let assignees = node.assignees || [];
  
  if (!assignees.length && node.config?.approverType) {
    // 从 approverType 动态生成 assignees 表达式
    const approverType = node.config.approverType;
    const managerLevel = node.config.managerLevel || 1;
    
    switch (approverType) {
      case 'INITIATOR_MANAGER':
        if (managerLevel === 1) {
          assignees = ['initiator:manager'];
        } else {
          assignees = [`initiator:manager[${managerLevel}]`];
        }
        break;
      case 'DEPT_MANAGER':
        assignees = ['initiator:deptManager'];
        break;
      case 'MANAGER_CHAIN':
        const stopCondition = node.config.chainConfig?.stopCondition || 'deptHead';
        if (stopCondition === 'deptHead') {
          assignees = ['initiator:managerChain'];
        } else {
          assignees = [`initiator:managerChain:${stopCondition}`];
        }
        break;
      case 'FIXED_USER':
        if (node.config.approvers?.length) {
          assignees = node.config.approvers.map((id: string) => `user:${id}`);
        }
        break;
      case 'ROLE':
        if (node.config.approverConfig?.roles?.length) {
          assignees = node.config.approverConfig.roles.map((role: string) => `role:${role}`);
        }
        break;
      case 'FORM_FIELD':
        if (node.config.approverConfig?.formField) {
          assignees = [`formField:${node.config.approverConfig.formField}`];
        }
        break;
    }
  }
  
  if (assignees.length) {
    for (const expression of assignees) {
      if (expression.startsWith('initiator:managerChain')) {
        // 连续上级审批
        const managers = await resolveManagerChain({
          userId: state.initiatorId,
          expression,
          variables: state.variables,
        });
        approvers.push(...managers);
      } else {
        const resolved = await resolveApprovers({
          expression,
          instanceId: state.instanceId,
          variables: state.variables,
        });
        approvers.push(...resolved);
      }
    }
  }

  // 去重
  approvers = [...new Set(approvers)];

  if (approvers.length === 0) {
    // ERR-20260501-004：审批人解析失败 → 挂起流程等管理员介入
    // 之前行为是静默 skip 节点，整流程一路到 END 标 APPROVED ("无人审批 = 自动通过")，
    // 违反业务约束。
    await suspendInstanceForUnresolvedApprovers({
      instanceId: state.instanceId,
      nodeInstanceId,
      nodeName: node.name,
      initiatorId: state.initiatorId,
    });
    state.status = 'SUSPENDED';

    // 等待管理员通过 resumeWithApprovers 信号注入审批人，或通过 adminTerminate 信号终止
    await condition(
      () => (state.resumedApprovers && state.resumedApprovers.length > 0) || state.shouldTerminate,
    );

    if (state.shouldTerminate) {
      return {
        type: 'TERMINATE',
        reason: state.terminateReason || 'Admin terminated suspended workflow',
      };
    }

    // 管理员注入了审批人 → 用 resumed 列表替代未解析的，恢复 RUNNING 状态继续流程
    approvers = state.resumedApprovers!;
    state.resumedApprovers = undefined;
    state.status = 'RUNNING';
    await resumeInstanceFromSuspension({ instanceId: state.instanceId });
  }

  // 检查自动审批
  const autoApproveMode = state.settings.autoApproveMode || 'none';
  const filteredApprovers: string[] = [];
  const autoApprovedUsers: string[] = [];

  for (const approverId of approvers) {
    let shouldAutoApprove = false;
    let autoApproveReason = '';

    // 检查是否是发起人
    if (autoApproveMode === 'initiator' || autoApproveMode === 'both') {
      if (approverId === state.initiatorId) {
        shouldAutoApprove = true;
        autoApproveReason = '审批人与发起人相同，自动通过';
      }
    }

    // 检查是否是重复审批人
    if (autoApproveMode === 'sameApprover' || autoApproveMode === 'both') {
      const hasApproved = state.history.some(
        (h) => h.operatorId === approverId && h.action === 'APPROVE',
      );
      if (hasApproved) {
        shouldAutoApprove = true;
        autoApproveReason = '审批人已在之前节点审批过，自动通过';
      }
    }

    if (shouldAutoApprove) {
      autoApprovedUsers.push(approverId);
      // 创建自动通过任务
      await createAutoApprovedTask({
        instanceId: state.instanceId,
        nodeInstanceId,
        name: node.name,
        assignee: approverId,
        reason: autoApproveReason,
      });
      // 记录历史
      state.history.push({
        nodeId: node.id,
        nodeName: node.name,
        action: 'AUTO_APPROVE',
        operatorId: approverId,
        comment: autoApproveReason,
        actionTime: Date.now(),
      });
    } else {
      filteredApprovers.push(approverId);
    }
  }

  // 如果所有人都自动通过了
  if (filteredApprovers.length === 0) {
    return { type: 'NEXT', nextNodeId: findNextNode(state.processModel, node.id) || '' };
  }

  // 根据审批模式创建任务
  const approvalMode = node.approvalMode || 'OR_SIGN';
  const taskIds: string[] = [];

  if (approvalMode === 'SEQUENTIAL') {
    // 顺序审批：只创建第一个人的任务
    const taskId = await createTaskWithDelegationCheck(
      state,
      nodeInstanceId,
      node,
      filteredApprovers[0],
    );
    taskIds.push(taskId);
  } else {
    // 会签或或签：创建所有人的任务
    for (const approverId of filteredApprovers) {
      const taskId = await createTaskWithDelegationCheck(
        state,
        nodeInstanceId,
        node,
        approverId,
      );
      taskIds.push(taskId);
    }
  }

  // 等待审批完成
  const result = await waitForApproval(state, node, taskIds, filteredApprovers, approvalMode);

  return result;
}

// ==================== 创建任务（带委托检查） ====================

async function createTaskWithDelegationCheck(
  state: WorkflowState,
  nodeInstanceId: string,
  node: ProcessNode,
  assignee: string,
): Promise<string> {
  // 检查委托
  const delegation = await checkDelegation({
    userId: assignee,
    processKey: state.businessType,
  });

  let actualAssignee = assignee;
  let isDelegated = false;
  let delegatedFrom: string | undefined;
  let delegationReason: string | undefined;

  if (delegation.shouldDelegate && delegation.delegateTo) {
    actualAssignee = delegation.delegateTo;
    isDelegated = true;
    delegatedFrom = assignee;
    delegationReason = delegation.reason;
  }

  // 创建任务
  const taskId = await createApprovalTask({
    instanceId: state.instanceId,
    nodeInstanceId,
    name: node.name,
    assignee: actualAssignee,
    candidateUsers: node.candidateUsers,
    candidateGroups: node.candidateGroups,
    priority: 0,
    dueDate: node.timeoutConfig?.timeoutHours
      ? new Date(Date.now() + node.timeoutConfig.timeoutHours * 60 * 60 * 1000)
      : undefined,
  });

  // 如果有委托，更新任务
  if (isDelegated) {
    await executeDelegation({
      taskId,
      originalAssignee: delegatedFrom!,
      delegateTo: actualAssignee,
      reason: delegationReason!,
      delegationType: 'AUTO_ON_LEAVE',
    });
  }

  // 发送通知
  await sendNotification({
    userId: actualAssignee,
    type: 'APPROVAL_TASK',
    title: '您有新的审批任务',
    content: `请处理审批任务：${node.name}`,
    data: { taskId, instanceId: state.instanceId },
  });

  // 设置超时提醒
  if (node.timeoutConfig?.reminderHours) {
    await scheduleReminder({
      taskId,
      instanceId: state.instanceId,
      scheduledAt: new Date(Date.now() + node.timeoutConfig.reminderHours * 60 * 60 * 1000),
      reminderType: 'BEFORE_TIMEOUT',
      channels: ['EMAIL', 'NOTIFICATION'],
    });
  }

  return taskId;
}

// ==================== 等待审批 ====================

async function waitForApproval(
  state: WorkflowState,
  node: ProcessNode,
  taskIds: string[],
  approvers: string[],
  approvalMode: string,
): Promise<NodeExecutionResult> {
  const completedTasks: Map<string, { action: string; operatorId: string }> = new Map();
  let currentApproverIndex = 0;
  const timeoutMs = node.timeoutConfig?.timeoutHours
    ? node.timeoutConfig.timeoutHours * 60 * 60 * 1000
    : undefined;

  while (!state.shouldTerminate) {
    // 等待 Signal 或超时
    const hasSignal = await condition(
      () => state.pendingSignals.length > 0 || state.shouldTerminate,
      timeoutMs ? Math.min(timeoutMs, 60000) : 60000,
    );

    // 检查终止
    if (state.shouldTerminate) {
      // 取消所有待处理任务
      for (const taskId of taskIds) {
        if (!completedTasks.has(taskId)) {
          await cancelTask({ taskId });
        }
      }
      return { type: 'TERMINATE', reason: state.terminateReason || undefined };
    }

    // 处理 Signal
    while (state.pendingSignals.length > 0) {
      const signal = state.pendingSignals.shift()!;
      
      // 检查是否是当前任务的 Signal
      if (!taskIds.includes(signal.data.taskId)) {
        continue;
      }

      // 执行验证器
      if (node.validators?.length && ['approve', 'reject'].includes(signal.type)) {
        const validationResult = await validateNode({
          validators: node.validators,
          context: {
            taskId: signal.data.taskId,
            operatorId: signal.data.operatorId,
            action: signal.type.toUpperCase(),
            comment: signal.data.comment,
            formData: signal.data.formData,
            attachments: signal.data.attachments,
          },
        });

        if (!validationResult.valid) {
          // 验证失败，发送通知
          await sendNotification({
            userId: signal.data.operatorId,
            type: 'VALIDATION_ERROR',
            title: '审批验证失败',
            content: validationResult.errors.join('; '),
            data: { taskId: signal.data.taskId },
          });
          continue;
        }
      }

      switch (signal.type) {
        case 'approve':
          await handleApprove(state, node, signal.data, completedTasks);
          break;
        case 'reject':
          await handleReject(state, node, signal.data);
          // ⭐ 设置终止原因为REJECTED
          state.terminateReason = 'REJECTED';
          // ⭐ 拒绝是审批节点的正常决策结果，需要执行 END 节点
          // 与撤回不同：拒绝是流程正常终点，撤回是人为中断
          const endNodeForReject = state.processModel.nodes.find(n => n.type === 'END');
          if (endNodeForReject) {
            await executeNode(state, endNodeForReject);
          }
          return { type: 'END', endStatus: 'REJECTED' };
        case 'return':
          await handleReturn(state, node, signal.data);
          return { type: 'RETURN', returnNodeId: signal.data.targetNodeId };
        case 'forward':
          await handleForward(state, node, signal.data);
          break;
        case 'execute':
          await handleExecute(state, node, signal.data, completedTasks);
          break;
      }
    }

    // 检查是否完成
    const completionResult = checkApprovalCompletion(
      approvalMode,
      taskIds,
      completedTasks,
      approvers.length,
    );

    if (completionResult.completed) {
      if (completionResult.approved) {
        // 顺序审批：检查是否还有下一个审批人
        if (approvalMode === 'SEQUENTIAL' && currentApproverIndex < approvers.length - 1) {
          currentApproverIndex++;
          const nextTaskId = await createTaskWithDelegationCheck(
            state,
            '', // nodeInstanceId 需要从上下文获取
            node,
            approvers[currentApproverIndex],
          );
          taskIds.push(nextTaskId);
          continue;
        }
        return { type: 'NEXT', nextNodeId: findNextNode(state.processModel, node.id) || '' };
      } else {
        return { type: 'END', endStatus: 'TERMINATED' };
      }
    }

    // 超时处理
    if (timeoutMs) {
      // 检查是否超时
      // 这里简化处理，实际应该根据任务创建时间判断
    }
  }

  return { type: 'TERMINATE', reason: state.terminateReason || undefined };
}

// ==================== 审批操作处理 ====================

async function handleApprove(
  state: WorkflowState,
  node: ProcessNode,
  data: any,
  completedTasks: Map<string, { action: string; operatorId: string }>,
): Promise<void> {
  await completeTask({
    taskId: data.taskId,
    action: 'APPROVE',
    operatorId: data.operatorId,
    comment: data.comment,
    formData: data.formData,
  });

  // ⭐ 管理员操作不创建 action log（已在 AdminApprovalService 中创建 audit log）
  if (!data.isAdminAction) {
    await createActionLog({
      taskId: data.taskId,
      instanceId: state.instanceId,
      action: 'APPROVE',
      operatorId: data.operatorId,
      comment: data.comment,
      formDataChanges: data.formData,
      attachments: data.attachments,
    });
  }

  completedTasks.set(data.taskId, {
    action: 'APPROVE',
    operatorId: data.operatorId,
  });

  state.history.push({
    nodeId: node.id,
    nodeName: node.name,
    action: 'APPROVE',
    operatorId: data.operatorId,
    comment: data.comment,
    actionTime: Date.now(),
  });

  // TD-6: 同步表单数据变更到业务系统
  // 审批引擎不存储业务数据副本，通过 BusinessDataProvider 同步
  if (data.formData && Object.keys(data.formData).length > 0) {
    try {
      // 将 formData 转换为 DataChanges 格式
      // 注意：这里简化处理，实际可能需要获取原始值来计算 diff
      const changes: Record<string, { old: any; new: any }> = {};
      for (const [key, value] of Object.entries(data.formData)) {
        changes[key] = {
          old: state.variables[key], // 尝试从 variables 获取旧值
          new: value,
        };
      }

      await syncBusinessDataChanges({
        instanceId: state.instanceId,
        changes,
        operatorId: data.operatorId,
      });
    } catch (error) {
      // 数据同步失败不影响审批流程继续
      // 错误已在 Activity 中记录
    }
  }
}

async function handleReject(
  state: WorkflowState,
  node: ProcessNode,
  data: any,
): Promise<void> {
  await completeTask({
    taskId: data.taskId,
    action: 'REJECT',
    operatorId: data.operatorId,
    comment: data.comment,
  });

  // ⭐ 管理员操作不创建 action log（已在 AdminApprovalService 中创建 audit log）
  if (!data.isAdminAction) {
    await createActionLog({
      taskId: data.taskId,
      instanceId: state.instanceId,
      action: 'REJECT',
      operatorId: data.operatorId,
      comment: data.comment,
      attachments: data.attachments,
    });
  }

  state.history.push({
    nodeId: node.id,
    nodeName: node.name,
    action: 'REJECT',
    operatorId: data.operatorId,
    comment: data.comment,
    actionTime: Date.now(),
  });

  // 通知发起人
  await sendNotification({
    userId: state.initiatorId,
    type: 'APPROVAL_REJECTED',
    title: '审批被驳回',
    content: `您的申请被驳回：${data.comment}`,
    data: { instanceId: state.instanceId },
  });
}

async function handleReturn(
  state: WorkflowState,
  node: ProcessNode,
  data: any,
): Promise<void> {
  await completeTask({
    taskId: data.taskId,
    action: 'RETURN',
    operatorId: data.operatorId,
    comment: data.comment,
  });

  await createActionLog({
    taskId: data.taskId,
    instanceId: state.instanceId,
    action: 'RETURN',
    operatorId: data.operatorId,
    comment: data.comment,
    targetNodeId: data.targetNodeId,
  });

  state.history.push({
    nodeId: node.id,
    nodeName: node.name,
    action: 'RETURN',
    operatorId: data.operatorId,
    comment: data.comment,
    actionTime: Date.now(),
  });
}

async function handleForward(
  state: WorkflowState,
  node: ProcessNode,
  data: any,
): Promise<void> {
  await forwardTask({
    taskId: data.taskId,
    fromUserId: data.operatorId,
    toUserId: data.toUserId,
    comment: data.comment,
  });

  await createActionLog({
    taskId: data.taskId,
    instanceId: state.instanceId,
    action: 'FORWARD',
    operatorId: data.operatorId,
    comment: data.comment,
    targetUserId: data.toUserId,
  });

  state.history.push({
    nodeId: node.id,
    nodeName: node.name,
    action: 'FORWARD',
    operatorId: data.operatorId,
    comment: data.comment,
    actionTime: Date.now(),
  });

  // 通知新审批人
  await sendNotification({
    userId: data.toUserId,
    type: 'APPROVAL_FORWARDED',
    title: '您收到一个转发的审批任务',
    content: `${node.name}`,
    data: { taskId: data.taskId, instanceId: state.instanceId },
  });
}

async function handleExecute(
  state: WorkflowState,
  node: ProcessNode,
  data: any,
  completedTasks: Map<string, { action: string; operatorId: string }>,
): Promise<void> {
  await completeTask({
    taskId: data.taskId,
    action: 'EXECUTE',
    operatorId: data.operatorId,
    comment: data.comment,
    formData: data.formData,
  });

  await createActionLog({
    taskId: data.taskId,
    instanceId: state.instanceId,
    action: 'EXECUTE',
    operatorId: data.operatorId,
    comment: data.comment,
    formDataChanges: data.formData,
    attachments: data.attachments,
  });

  completedTasks.set(data.taskId, {
    action: 'EXECUTE',
    operatorId: data.operatorId,
  });

  state.history.push({
    nodeId: node.id,
    nodeName: node.name,
    action: 'EXECUTE',
    operatorId: data.operatorId,
    comment: data.comment,
    actionTime: Date.now(),
  });

  // 更新变量
  if (data.formData) {
    state.variables = { ...state.variables, ...data.formData };
  }
}

// ==================== 审批完成检查 ====================

function checkApprovalCompletion(
  approvalMode: string,
  taskIds: string[],
  completedTasks: Map<string, { action: string; operatorId: string }>,
  totalApprovers: number,
): { completed: boolean; approved: boolean } {
  const completedCount = completedTasks.size;
  const approvedCount = Array.from(completedTasks.values()).filter(
    (t) => t.action === 'APPROVE' || t.action === 'EXECUTE',
  ).length;

  switch (approvalMode) {
    case 'COUNTERSIGN':
      // 会签：所有人都需要通过
      if (completedCount === totalApprovers) {
        return { completed: true, approved: approvedCount === totalApprovers };
      }
      break;
    case 'OR_SIGN':
      // 或签：任一人通过即可
      if (approvedCount > 0) {
        return { completed: true, approved: true };
      }
      if (completedCount === totalApprovers) {
        return { completed: true, approved: false };
      }
      break;
    case 'SEQUENTIAL':
      // 顺序审批：当前任务完成即可
      if (completedCount > 0) {
        const lastCompleted = Array.from(completedTasks.values()).pop();
        return {
          completed: true,
          approved: lastCompleted?.action === 'APPROVE' || lastCompleted?.action === 'EXECUTE',
        };
      }
      break;
  }

  return { completed: false, approved: false };
}

// ==================== 服务任务节点 ====================

async function executeServiceTaskNode(
  state: WorkflowState,
  node: ProcessNode,
): Promise<NodeExecutionResult> {
  // 执行服务任务
  // 根据 serviceType 和 serviceConfig 执行相应逻辑
  
  const nextNodeId = findNextNode(state.processModel, node.id);
  return { type: 'NEXT', nextNodeId: nextNodeId || '' };
}

// ==================== 网关节点 ====================

async function executeGatewayNode(
  state: WorkflowState,
  node: ProcessNode,
): Promise<NodeExecutionResult> {
  // 排他网关：根据条件选择一个分支
  if (node.conditions?.length) {
    // TD-6: 获取业务数据用于条件评估
    // 审批引擎不存储业务数据副本，通过 Activity 实时获取
    let businessData: Record<string, any> = {};
    try {
      businessData = await getBusinessDataForCondition({
        instanceId: state.instanceId,
      });
    } catch (error) {
      // 获取业务数据失败，使用空对象继续
    }

    // 合并流程变量和业务数据
    const evaluationContext = {
      ...state.variables,    // 流程元数据
      ...businessData,       // 业务数据（实时获取）
    };

    for (const condition of node.conditions) {
      if (evaluateCondition(condition.expression, evaluationContext)) {
        return { type: 'NEXT', nextNodeId: condition.target };
      }
    }
  }

  // 使用默认分支
  if (node.defaultTarget) {
    return { type: 'NEXT', nextNodeId: node.defaultTarget };
  }

  // 找第一个出边
  const nextNodeId = findNextNode(state.processModel, node.id);
  return { type: 'NEXT', nextNodeId: nextNodeId || '' };
}

async function executeParallelGatewayNode(
  state: WorkflowState,
  node: ProcessNode,
): Promise<NodeExecutionResult> {
  // 并行网关：暂时简化处理，只走第一个分支
  const nextNodeId = findNextNode(state.processModel, node.id);
  return { type: 'NEXT', nextNodeId: nextNodeId || '' };
}

// ==================== 辅助函数 ====================

function findStartNode(processModel: ProcessModel): ProcessNode | undefined {
  return processModel.nodes.find((n) => n.type === 'START');
}

function findNode(processModel: ProcessModel, nodeId: string): ProcessNode | undefined {
  return processModel.nodes.find((n) => n.id === nodeId);
}

function findNextNode(processModel: ProcessModel, currentNodeId: string): string | undefined {
  const edge = processModel.edges.find((e) => e.source === currentNodeId);
  return edge?.target;
}

function evaluateCondition(expression: string, variables: Record<string, any>): boolean {
  try {
    const func = new Function(...Object.keys(variables), `return ${expression}`);
    return func(...Object.values(variables));
  } catch {
    return false;
  }
}

function checkLoopProtection(
  state: WorkflowState,
  nodeId: string,
): { allowed: boolean; reason?: string } {
  const maxNodeExecutions = state.settings.maxNodeExecutions || 10;
  const maxTotalNodeExecutions = state.settings.maxTotalNodeExecutions || 100;

  // 检查单节点执行次数
  const nodeCount = (state.nodeExecutionCounts[nodeId] || 0) + 1;
  state.nodeExecutionCounts[nodeId] = nodeCount;

  if (nodeCount > maxNodeExecutions) {
    return {
      allowed: false,
      reason: `Node ${nodeId} exceeded maximum execution count (${maxNodeExecutions})`,
    };
  }

  // 检查总执行次数
  state.totalNodeExecutions++;
  if (state.totalNodeExecutions > maxTotalNodeExecutions) {
    return {
      allowed: false,
      reason: `Total node executions exceeded maximum (${maxTotalNodeExecutions})`,
    };
  }

  return { allowed: true };
}