import { PrismaService } from '@core/database/prisma/prisma.service';
import { FormInstanceStatus } from '@prisma/client';
import { Logger } from '@nestjs/common';
import { Injectable } from '@nestjs/common';
import { NotificationService } from '@core/messaging/notification/notification.service';
import { TemporalLoggerService } from '@core/observability/logging/services/temporal-logger.service';
import { 
  BusinessTypeRegistry, 
  DataChanges,
  ApprovalResult,
} from '../../business-type-registry.service';

const logger = new Logger('ApprovalActivities');

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

export interface ProcessModel {
  nodes: ProcessNode[];
  edges: ProcessEdge[];
}

export interface ProcessNode {
  id: string;
  type: NodeType;
  name: string;
  position?: { x: number; y: number };
  size?: { width: number; height: number };
  
  // USER_TASK 配置
  assignees?: string[];
  approvalMode?: 'COUNTERSIGN' | 'OR_SIGN' | 'SEQUENTIAL';
  candidateUsers?: string[];
  candidateGroups?: string[];
  allowAddSign?: boolean;
  allowReturn?: boolean;
  allowForward?: boolean;
  editableFields?: string[];
  
  // ⭐ 新增：审批人配置（用于动态审批人计算）
  config?: {
    approverType?: 'INITIATOR_MANAGER' | 'MANAGER_CHAIN' | 'FIXED_USER' | 'ROLE' | 'DEPARTMENT' | 'DEPT_MANAGER' | 'FORM_FIELD' | 'CUSTOM';
    approvers?: string[];  // 指定人员 ID 列表
    managerLevel?: number;  // 上级层级
    chainConfig?: {
      stopCondition?: 'deptHead' | 'topLevel' | 'manualStop';
      maxLevels?: number;
    };
    approverConfig?: {
      roles?: string[];  // 角色列表
      formField?: string;  // 表单字段名
      departmentId?: string;  // 部门 ID
    };
    approvalMode?: 'AND' | 'OR';  // 会签/或签
    approverDetails?: Array<{  // 实际审批人详情
      id: string;
      name: string;
      avatar?: string;
    }>;
  };
  
  // 超时配置
  timeoutConfig?: {
    timeoutHours: number;
    reminderHours?: number;
    reminderCount?: number;
    timeoutAction?: 'REMIND' | 'ESCALATE' | 'AUTO_APPROVE' | 'AUTO_REJECT';
    escalateTo?: string;
  };
  
  // 委托配置
  delegationConfig?: DelegationConfig;
  
  // 条件验证器
  validators?: NodeValidator[];
  
  // 钩子配置
  beforeEnterHooks?: NodeHook[];
  afterCompleteHooks?: NodeHook[];
  
  // GATEWAY 配置
  conditions?: GatewayCondition[];
  defaultTarget?: string;
  
  // SERVICE_TASK 配置
  serviceType?: string;
  serviceConfig?: Record<string, any>;
}

export interface ProcessEdge {
  id: string;
  source: string;
  target: string;
  label?: string;
  condition?: string;
}

export interface NodeHook {
  id: string;
  type: HookType;
  config: Record<string, any>;
  condition?: string;
  errorStrategy?: 'CONTINUE' | 'FAIL_PROCESS';
  retryConfig?: {
    maxAttempts: number;
    initialIntervalMs: number;
  };
}

export interface NodeValidator {
  id: string;
  type: ValidatorType;
  config: Record<string, any>;
  message?: string;
}

export interface DelegationConfig {
  enabled: boolean;
  trigger: DelegationTrigger;
  delegateTo: string;
  notifyDelegatee: boolean;
  notifyOriginalAssignee: boolean;
}

export interface GatewayCondition {
  target: string;
  expression: string;
}

export type NodeType = 'START' | 'END' | 'USER_TASK' | 'SERVICE_TASK' | 'GATEWAY' | 'EXCLUSIVE_GATEWAY' | 'PARALLEL_GATEWAY' | 'INCLUSIVE_GATEWAY';
export type HookType = 'SEND_EMAIL' | 'SEND_DINGTALK' | 'SEND_FEISHU' | 'SEND_WEBHOOK' | 'CREATE_TASK' | 'UPDATE_RECORD' | 'CALL_API' | 'SET_VARIABLE' | 'LOG' | 'CUSTOM';
export type ValidatorType = 'FIELD_REQUIRED' | 'FIELD_MODIFIED' | 'FIELD_VALUE' | 'FIELD_PATTERN' | 'CONDITION' | 'ATTACHMENT_REQUIRED' | 'ATTACHMENT_COUNT' | 'COMMENT_REQUIRED' | 'COMMENT_MIN_LENGTH' | 'CUSTOM';
export type DelegationTrigger = 'USER_ON_LEAVE' | 'USER_INACTIVE' | 'USER_UNAVAILABLE' | 'TIME_RANGE' | 'HOLIDAY' | 'WORKING_HOURS' | 'TASK_TIMEOUT' | 'CUSTOM';

export interface ProcessSettings {
  callbackUrl?: string;
  maxNodeExecutions?: number;
  maxTotalNodeExecutions?: number;
  maxReturnCount?: number;
  enableAutoApprove?: boolean;
  autoApproveMode?: 'none' | 'sameApprover' | 'initiator' | 'both';
}

export interface UserInfo {
  id: string;
  name: string;
  avatar?: string;
  department?: string;
  position?: string;
  managerId?: string;
  departmentHeadId?: string;
}

// ==================== Activity 实现 ====================

@Injectable()
export class ApprovalActivities {
  private businessTypeRegistry?: BusinessTypeRegistry;

  constructor(
    private readonly prisma: PrismaService,
    private readonly notificationService: NotificationService,
    private readonly temporalLogger: TemporalLoggerService,
  ) {}

  /**
   * 设置 BusinessTypeRegistry（延迟注入，避免循环依赖）
   */
  setBusinessTypeRegistry(registry: BusinessTypeRegistry): void {
    this.businessTypeRegistry = registry;
  }

  // ==================== 节点管理 ====================

  async createNodeInstance(params: {
    instanceId: string;
    nodeId: string;
    nodeName: string;
    nodeType: string;
    assignees?: string[];
    approvalMode?: string;
  }): Promise<string> {
    const activityId = `create-node-${params.nodeId}`;
    const startTime = Date.now();

    // 记录 Activity 开始
    this.temporalLogger.logActivityStart({
      workflowId: `approval-${params.instanceId}`,
      workflowType: 'ApprovalWorkflow',
      activityId,
      activityType: 'CreateNodeInstance',
      businessKey: params.instanceId,
      metadata: {
        nodeId: params.nodeId,
        nodeName: params.nodeName,
        nodeType: params.nodeType,
      },
    });

    try {
      logger.log(`Creating node instance: ${params.nodeId} for instance ${params.instanceId}`);

      const nodeInstance = await this.prisma.approvalNodeInstance.create({
        data: {
          instanceId: params.instanceId,
          nodeId: params.nodeId,
          nodeName: params.nodeName,
          nodeType: params.nodeType,
          status: 'ACTIVE',
          assignees: params.assignees || [],
          approvalMode: params.approvalMode,
        },
      });

      // 更新流程实例当前节点
      await this.prisma.approvalInstance.update({
        where: { id: params.instanceId },
        data: {
          currentNodeId: params.nodeId,
          totalNodeExecutions: { increment: 1 },
        },
      });

      // 记录 Activity 完成
      this.temporalLogger.logActivityComplete({
        workflowId: `approval-${params.instanceId}`,
        workflowType: 'ApprovalWorkflow',
        activityId,
        activityType: 'CreateNodeInstance',
        businessKey: params.instanceId,
        durationMs: Date.now() - startTime,
        metadata: {
          nodeInstanceId: nodeInstance.id,
        },
      });

      return nodeInstance.id;
    } catch (error) {
      // 记录 Activity 失败
      this.temporalLogger.logActivityFailed({
        workflowId: `approval-${params.instanceId}`,
        workflowType: 'ApprovalWorkflow',
        activityId,
        activityType: 'CreateNodeInstance',
        businessKey: params.instanceId,
        error: {
          type: error.name,
          message: error.message,
        },
      });
      throw error;
    }
  }

  async completeNodeInstance(params: {
    nodeInstanceId: string;
    result?: any;
  }): Promise<void> {
    const activityId = `complete-node-${params.nodeInstanceId}`;
    const startTime = Date.now();

    try {
      // 获取节点信息用于日志
      const nodeInstance = await this.prisma.approvalNodeInstance.findUnique({
        where: { id: params.nodeInstanceId },
        select: { instanceId: true, nodeId: true },
      });

      // 记录 Activity 开始
      if (nodeInstance) {
        this.temporalLogger.logActivityStart({
          workflowId: `approval-${nodeInstance.instanceId}`,
          workflowType: 'ApprovalWorkflow',
          activityId,
          activityType: 'CompleteNodeInstance',
          businessKey: nodeInstance.instanceId,
          metadata: {
            nodeInstanceId: params.nodeInstanceId,
            nodeId: nodeInstance.nodeId,
          },
        });
      }

      logger.log(`Completing node instance: ${params.nodeInstanceId}`);

      await this.prisma.approvalNodeInstance.update({
        where: { id: params.nodeInstanceId },
        data: {
          status: 'COMPLETED',
          result: params.result,
          endTime: new Date(),
        },
      });

      // 记录 Activity 完成
      if (nodeInstance) {
        this.temporalLogger.logActivityComplete({
          workflowId: `approval-${nodeInstance.instanceId}`,
          workflowType: 'ApprovalWorkflow',
          activityId,
          activityType: 'CompleteNodeInstance',
          businessKey: nodeInstance.instanceId,
          durationMs: Date.now() - startTime,
        });
      }
    } catch (error) {
      this.temporalLogger.logActivityFailed({
        workflowId: 'unknown',
        workflowType: 'ApprovalWorkflow',
        activityId,
        activityType: 'CompleteNodeInstance',
        error: {
          type: error.name,
          message: error.message,
        },
      });
      throw error;
    }
  }

  async skipNodeInstance(params: {
    nodeInstanceId: string;
    reason: string;
  }): Promise<void> {
    logger.log(`Skipping node instance: ${params.nodeInstanceId}, reason: ${params.reason}`);

    await this.prisma.approvalNodeInstance.update({
      where: { id: params.nodeInstanceId },
      data: {
        status: 'SKIPPED',
        result: { reason: params.reason },
        endTime: new Date(),
      },
    });
  }

  /**
   * 审批人解析失败时挂起整个流程并通知管理员（ERR-20260501-004 修复）。
   *
   * 之前行为：approvers.length === 0 时静默 skipNodeInstance，整流程一路到 END 标 APPROVED
   *  → "无人审批 = 自动通过"，违反业务约束。
   *
   * 现行为：节点 status=PENDING（保留可恢复），ApprovalInstance status=SUSPENDED + endReason 标记，
   * 通知所有 Administrator；workflow 等待 resumeWithApprovers 信号或 adminTerminate。
   */
  async suspendInstanceForUnresolvedApprovers(params: {
    instanceId: string;
    nodeInstanceId: string;
    nodeName: string;
    initiatorId: string;
  }): Promise<void> {
    logger.warn(
      `Suspending instance ${params.instanceId} — node "${params.nodeName}" has no resolvable approvers`,
    );

    await this.prisma.$transaction(async (tx) => {
      await tx.approvalInstance.update({
        where: { id: params.instanceId },
        data: {
          status: 'SUSPENDED',
          endReason: 'APPROVER_UNRESOLVED',
          endComment: `节点 "${params.nodeName}" 审批人解析失败，等待管理员介入`,
          // 不设 endTime —— SUSPENDED 不算终态，可恢复
        },
      });
      await tx.approvalNodeInstance.update({
        where: { id: params.nodeInstanceId },
        data: { status: 'PENDING', result: { reason: 'APPROVER_UNRESOLVED' } },
      });
      // 同步 FormInstance.approvalStatus 镜像字段（admin 列表通过此字段过滤 SUSPENDED 实例）
      await tx.formInstance.updateMany({
        where: { approvalInstanceId: params.instanceId },
        data: { approvalStatus: 'SUSPENDED' },
      });
    });

    // 通知所有 Administrator（IN_APP），带 instanceId / nodeInstanceId 让管理员能定位介入
    const admins = await this.prisma.user.findMany({
      where: {
        roles: {
          some: { role: { code: { in: ['Administrator', 'ADMIN'] } } },
        },
        status: 'ACTIVE',
      },
      select: { id: true },
    });

    for (const admin of admins) {
      await this.notificationService
        .send({
          channel: 'IN_APP' as any,
          to: admin.id,
          subject: '审批流程需要管理员介入',
          content: `审批实例 ${params.instanceId} 的节点 "${params.nodeName}" 无法解析审批人，流程已挂起。请指定审批人后恢复或终止流程。`,
          variables: {
            instanceId: params.instanceId,
            nodeInstanceId: params.nodeInstanceId,
            initiatorId: params.initiatorId,
          },
        })
        .catch((e) =>
          logger.error(`Failed to notify admin ${admin.id} about suspended instance: ${e.message}`),
        );
    }
  }

  /**
   * 管理员介入恢复挂起的流程（ERR-20260501-004 配套）。
   * 流程从 SUSPENDED 回到 RUNNING，新审批人由 workflow 用收到的 resumedApprovers 取代未解析的列表。
   */
  async resumeInstanceFromSuspension(params: {
    instanceId: string;
  }): Promise<void> {
    logger.log(`Resuming suspended instance ${params.instanceId}`);
    await this.prisma.$transaction(async (tx) => {
      await tx.approvalInstance.update({
        where: { id: params.instanceId },
        data: {
          status: 'RUNNING',
          endReason: null,
          endComment: null,
        },
      });
      // 同步 FormInstance.approvalStatus 回 RUNNING（与 suspendInstanceForUnresolvedApprovers 配套）
      await tx.formInstance.updateMany({
        where: { approvalInstanceId: params.instanceId },
        data: { approvalStatus: 'RUNNING' },
      });
    });
  }

  async failNodeInstance(params: {
    nodeInstanceId: string;
    error: string;
  }): Promise<void> {
    logger.log(`Failing node instance: ${params.nodeInstanceId}, error: ${params.error}`);

    await this.prisma.approvalNodeInstance.update({
      where: { id: params.nodeInstanceId },
      data: {
        status: 'FAILED',
        result: { error: params.error },
        endTime: new Date(),
      },
    });
  }

  // ==================== 流程管理 ====================

  async updateProcessStatus(params: {
    instanceId: string;
    status: string;
    endReason?: string;
  }): Promise<void> {
    logger.log(`Updating process status: ${params.instanceId} to ${params.status}`);

    await this.prisma.approvalInstance.update({
      where: { id: params.instanceId },
      data: {
        status: params.status as any,
        endTime: ['APPROVED', 'REJECTED', 'WITHDRAWN', 'TERMINATED', 'FAILED'].includes(params.status)
          ? new Date()
          : undefined,
        endReason: params.endReason,
      },
    });
  }

  async failProcess(params: {
    instanceId: string;
    error: string;
  }): Promise<void> {
    logger.log(`Failing process: ${params.instanceId}, error: ${params.error}`);

    await this.prisma.approvalInstance.update({
      where: { id: params.instanceId },
      data: {
        status: 'FAILED',
        endTime: new Date(),
        endReason: params.error,
      },
    });

    // 取消所有待处理任务
    await this.prisma.approvalTask.updateMany({
      where: {
        instanceId: params.instanceId,
        status: { in: ['PENDING', 'CLAIMED', 'ASSIGNED'] },
      },
      data: {
        status: 'CANCELLED',
        endTime: new Date(),
      },
    });
  }

  async onProcessCompleted(params: {
    instanceId: string;
    status: string;
    callbackUrl?: string;
  }): Promise<void> {
    logger.log(`Process completed: ${params.instanceId} with status ${params.status}`);

    // 获取流程实例信息
    const instance = await this.prisma.approvalInstance.findUnique({
      where: { id: params.instanceId },
    });

    if (instance && this.businessTypeRegistry) {
      // TD-6: 通过 BusinessTypeRegistry 通知业务系统审批完成
      try {
        // 映射状态到 ApprovalResult
        // 注意：WITHDRAWN 必须保留 WITHDRAWN，区分"申请人主动撤回"与"系统/管理员取消"
        const resultMap: Record<string, ApprovalResult> = {
          APPROVED: 'APPROVED',
          REJECTED: 'REJECTED',
          WITHDRAWN: 'WITHDRAWN',
          TERMINATED: 'CANCELLED',
          FAILED: 'REJECTED',
        };
        const result = resultMap[params.status] || 'CANCELLED';

        await this.businessTypeRegistry.notifyApprovalComplete(
          instance.businessType,
          instance.businessId,
          result,
          instance.endComment || undefined,
        );
        logger.log(`Notified business system for ${instance.businessType}/${instance.businessId}: ${result}`);
      } catch (error) {
        logger.error(`Failed to notify business system: ${error.message}`);
        // 不抛出异常，避免影响流程完成
      }
    }

    // 回调业务系统（兼容旧的 callbackUrl 方式）
    if (params.callbackUrl) {
      await this.callbackBusinessSystem({
        instanceId: params.instanceId,
        callbackUrl: params.callbackUrl,
        status: params.status,
      });
    }
  }

  // ==================== 任务管理 ====================

  async createApprovalTask(params: {
    instanceId: string;
    nodeInstanceId: string;
    name: string;
    assignee?: string;
    candidateUsers?: string[];
    candidateGroups?: string[];
    priority?: number;
    dueDate?: Date;
    formData?: any;
  }): Promise<string> {
    const activityId = `create-task-${params.nodeInstanceId}`;
    const startTime = Date.now();

    // 记录 Activity 开始
    this.temporalLogger.logActivityStart({
      workflowId: `approval-${params.instanceId}`,
      workflowType: 'ApprovalWorkflow',
      activityId,
      activityType: 'CreateApprovalTask',
      businessKey: params.instanceId,
      metadata: {
        nodeInstanceId: params.nodeInstanceId,
        taskName: params.name,
        assignee: params.assignee,
        candidateCount: params.candidateUsers?.length || 0,
      },
    });

    try {
      logger.log(`Creating approval task for node instance: ${params.nodeInstanceId}`);

      const task = await this.prisma.approvalTask.create({
        data: {
          instanceId: params.instanceId,
          nodeInstanceId: params.nodeInstanceId,
          name: params.name,
          type: 'USER_TASK',
          assignee: params.assignee,
          candidateUsers: params.candidateUsers || [],
          candidateGroups: params.candidateGroups || [],
          status: params.assignee ? 'ASSIGNED' : 'PENDING',
          priority: params.priority || 0,
          dueDate: params.dueDate,
          formData: params.formData,
        },
      });

      // 记录 Activity 完成
      this.temporalLogger.logActivityComplete({
        workflowId: `approval-${params.instanceId}`,
        workflowType: 'ApprovalWorkflow',
        activityId,
        activityType: 'CreateApprovalTask',
        businessKey: params.instanceId,
        durationMs: Date.now() - startTime,
        metadata: {
          taskId: task.id,
          status: task.status,
        },
      });

      return task.id;
    } catch (error) {
      // 记录 Activity 失败
      this.temporalLogger.logActivityFailed({
        workflowId: `approval-${params.instanceId}`,
        workflowType: 'ApprovalWorkflow',
        activityId,
        activityType: 'CreateApprovalTask',
        businessKey: params.instanceId,
        error: {
          type: error.name,
          message: error.message,
        },
      });
      throw error;
    }
  }

  async createAutoApprovedTask(params: {
    instanceId: string;
    nodeInstanceId: string;
    name: string;
    assignee: string;
    reason: string;
  }): Promise<string> {
    logger.log(`Creating auto-approved task: ${params.name}, reason: ${params.reason}`);

    const task = await this.prisma.approvalTask.create({
      data: {
        instanceId: params.instanceId,
        nodeInstanceId: params.nodeInstanceId,
        name: params.name,
        type: 'USER_TASK',
        assignee: params.assignee,
        candidateUsers: [],
        candidateGroups: [],
        status: 'COMPLETED',
        autoApproved: true,
        autoApproveReason: params.reason,
        endTime: new Date(),
      },
    });

    // 创建自动通过日志
    await this.prisma.approvalTaskLog.create({
      data: {
        taskId: task.id,
        instanceId: params.instanceId,
        action: 'AUTO_APPROVE',
        operatorId: params.assignee,
        comment: params.reason,
      },
    });

    return task.id;
  }

  async completeTask(params: {
    taskId: string;
    action: string;
    operatorId: string;
    comment?: string;
    formData?: any;
  }): Promise<void> {
    logger.log(`Completing task: ${params.taskId} with action ${params.action}`);

    await this.prisma.approvalTask.update({
      where: { id: params.taskId },
      data: {
        status: 'COMPLETED',
        endTime: new Date(),
        formData: params.formData,
      },
    });
  }

  async cancelTask(params: {
    taskId: string;
    reason?: string;
  }): Promise<void> {
    logger.log(`Cancelling task: ${params.taskId}`);

    await this.prisma.approvalTask.update({
      where: { id: params.taskId },
      data: {
        status: 'CANCELLED',
        endTime: new Date(),
      },
    });
  }

  async getTask(taskId: string): Promise<any> {
    return this.prisma.approvalTask.findUnique({
      where: { id: taskId },
      include: {
        instance: true,
        nodeInstance: true,
      },
    });
  }

  async escalateTask(params: {
    taskId: string;
    escalateTo: string;
    reason: string;
  }): Promise<void> {
    logger.log(`Escalating task: ${params.taskId} to ${params.escalateTo}`);

    const task = await this.prisma.approvalTask.findUnique({
      where: { id: params.taskId },
    });

    if (!task) {
      throw new Error('Task not found');
    }

    // 更新任务分配
    await this.prisma.approvalTask.update({
      where: { id: params.taskId },
      data: {
        assignee: params.escalateTo,
        isDelegated: true,
        delegatedFrom: task.assignee,
        delegatedAt: new Date(),
        delegationReason: params.reason,
        delegationType: 'AUTO_TIMEOUT',
      },
    });

    // 创建升级日志
    await this.prisma.approvalTaskLog.create({
      data: {
        taskId: params.taskId,
        instanceId: task.instanceId,
        action: 'ESCALATE',
        operatorId: task.assignee || params.escalateTo,
        comment: params.reason,
        targetUserId: params.escalateTo,
      },
    });
  }

  async forwardTask(params: {
    taskId: string;
    fromUserId: string;
    toUserId: string;
    comment?: string;
  }): Promise<void> {
    logger.log(`Forwarding task: ${params.taskId} from ${params.fromUserId} to ${params.toUserId}`);

    await this.prisma.approvalTask.update({
      where: { id: params.taskId },
      data: {
        assignee: params.toUserId,
        owner: params.fromUserId,
        status: 'ASSIGNED',
      },
    });
  }

  // ==================== 审批人解析 ====================

  async resolveApprovers(params: {
    expression: string;
    instanceId: string;
    variables: Record<string, any>;
  }): Promise<string[]> {
    logger.log(`Resolving approvers: ${params.expression}`);

    const { expression, instanceId, variables } = params;

    // 获取流程实例
    const instance = await this.prisma.approvalInstance.findUnique({
      where: { id: instanceId },
      include: { initiator: true },
    });

    if (!instance) {
      throw new Error('Instance not found');
    }

    // 解析表达式
    if (expression.startsWith('user:')) {
      // 固定用户
      return [expression.replace('user:', '')];
    }

    if (expression.startsWith('role:')) {
      // 角色
      const roleCode = expression.replace('role:', '');
      const users = await this.prisma.user.findMany({
        where: {
          roles: {
            some: {
              role: { code: roleCode },
            },
          },
          status: 'ACTIVE',
        },
      });
      return users.map((u) => u.id);
    }

    if (expression.startsWith('department:')) {
      // 部门
      const deptId = expression.replace('department:', '');
      const userDepartments = await this.prisma.userDepartment.findMany({
        where: {
          departmentId: deptId,
          leftAt: null, // 只获取当前在职的
          user: {
            status: 'ACTIVE',
          },
        },
        select: {
          userId: true,
        },
      });
      return userDepartments.map((ud) => ud.userId);
    }

    if (expression === 'initiator:manager') {
      // 发起人直属上级 - 从主部门关系中获取
      const userDept = await this.prisma.userDepartment.findFirst({
        where: {
          userId: instance.initiatorId,
          isPrimary: true,
          leftAt: null,
        },
        select: {
          managerId: true,
        },
      });
      if (userDept?.managerId) {
        return [userDept.managerId];
      }
      return [];
    }

    // 支持 initiator:manager[N] 语法（固定层级上级）
    if (expression.startsWith('initiator:manager[')) {
      const match = expression.match(/^initiator:manager\[(\d+)\]$/);
      if (match) {
        const targetLevel = parseInt(match[1], 10);
        let currentUserId = instance.initiatorId;
        
        // 逐级向上查找到第 N 级上级
        for (let i = 0; i < targetLevel; i++) {
          const userDept = await this.prisma.userDepartment.findFirst({
            where: {
              userId: currentUserId,
              isPrimary: true,
              leftAt: null,
            },
            select: {
              managerId: true,
            },
          });
          
          if (!userDept?.managerId) {
            // 找不到上级，返回空
            logger.warn(
              `Cannot find manager at level ${i + 1} for user ${currentUserId}, expression: ${expression}`,
            );
            return [];
          }
          
          currentUserId = userDept.managerId;
        }
        
        logger.log(
          `Resolved initiator:manager[${targetLevel}] for user ${instance.initiatorId}: ${currentUserId}`,
        );
        return [currentUserId];
      }
    }

    if (expression.startsWith('initiator:managerChain')) {
      // 发起人连续上级
      return this.resolveManagerChain({
        userId: instance.initiatorId,
        expression,
        variables,
      });
    }

    if (expression.startsWith('variable:')) {
      // 从变量中获取
      const varName = expression.replace('variable:', '');
      const value = variables[varName];
      if (Array.isArray(value)) {
        return value;
      }
      return value ? [value] : [];
    }

    // 默认返回空
    return [];
  }

  async resolveManagerChain(params: {
    userId: string;
    expression: string;
    variables: Record<string, any>;
  }): Promise<string[]> {
    logger.log(`Resolving manager chain for user: ${params.userId}, expression: ${params.expression}`);

    const { userId, expression } = params;
    const managers: string[] = [];
    let currentUserId = userId;
    const maxLevel = 10; // 防止无限循环
    let level = 0;

    // 解析停止条件
    let stopCondition: 'deptHead' | 'role' | 'level' = 'deptHead';
    let stopValue: string | number = '';

    if (expression.includes(':role:')) {
      stopCondition = 'role';
      stopValue = expression.split(':role:')[1];
    } else if (expression.includes(':level:')) {
      stopCondition = 'level';
      stopValue = parseInt(expression.split(':level:')[1], 10);
    }

    while (level < maxLevel) {
      // 获取用户主部门关系
      const userDept = await this.prisma.userDepartment.findFirst({
        where: {
          userId: currentUserId,
          isPrimary: true,
          leftAt: null,
        },
        include: {
          department: true,
        },
      });

      if (!userDept || !userDept.managerId) {
        break;
      }

      const managerId = userDept.managerId;
      managers.push(managerId);
      level++;

      // 检查停止条件
      if (stopCondition === 'deptHead') {
        // 检查是否是部门负责人
        const dept = await this.prisma.department.findFirst({
          where: { headId: managerId },
        });
        if (dept) {
          break;
        }
      } else if (stopCondition === 'role') {
        // 检查是否有指定角色
        const managerWithRoles = await this.prisma.user.findUnique({
          where: { id: managerId },
          include: {
            roles: {
              include: { role: true },
            },
          },
        });
        if (managerWithRoles?.roles.some((r) => r.role.code === stopValue)) {
          break;
        }
      } else if (stopCondition === 'level') {
        if (level >= (stopValue as number)) {
          break;
        }
      }

      currentUserId = managerId;
    }

    return managers;
  }

  // ==================== 通知与催办 ====================

  async sendReminder(params: {
    taskId: string;
    userId: string;
    message?: string;
  }): Promise<void> {
    const activityId = `send-reminder-${params.taskId}`;
    const startTime = Date.now();

    try {
      logger.log(`Sending reminder for task: ${params.taskId} to user: ${params.userId}`);

      const task = await this.prisma.approvalTask.findUnique({
        where: { id: params.taskId },
        include: {
          instance: {
            include: { initiator: true },
          },
        },
      });

      if (!task) {
        return;
      }

      // 记录 Activity 开始
      this.temporalLogger.logActivityStart({
        workflowId: `approval-${task.instanceId}`,
        workflowType: 'ApprovalWorkflow',
        activityId,
        activityType: 'SendReminder',
        businessKey: task.instanceId,
        metadata: {
          taskId: params.taskId,
          userId: params.userId,
          currentReminderCount: task.reminderCount,
        },
      });

      // 发送通知
      await this.notificationService.send({
        channel: 'IN_APP',
        to: params.userId,
        subject: '审批催办',
        content: params.message || `您有一个待处理的审批任务：${task.name}`,
        metadata: {
          taskId: params.taskId,
          instanceId: task.instanceId,
          businessType: task.instance.businessType,
          businessKey: task.instance.businessKey,
        },
      });

      // 更新催办计数
      await this.prisma.approvalTask.update({
        where: { id: params.taskId },
        data: {
          reminderCount: { increment: 1 },
          lastReminderAt: new Date(),
        },
      });

      // 记录 Activity 完成
      this.temporalLogger.logActivityComplete({
        workflowId: `approval-${task.instanceId}`,
        workflowType: 'ApprovalWorkflow',
        activityId,
        activityType: 'SendReminder',
        businessKey: task.instanceId,
        durationMs: Date.now() - startTime,
        metadata: {
          newReminderCount: task.reminderCount + 1,
        },
      });
    } catch (error) {
      // 记录 Activity 失败
      this.temporalLogger.logActivityFailed({
        workflowId: 'unknown',
        workflowType: 'ApprovalWorkflow',
        activityId,
        activityType: 'SendReminder',
        error: {
          type: error.name,
          message: error.message,
        },
      });
      throw error;
    }
  }

  async sendNotification(params: {
    userId: string;
    type: string;
    title: string;
    content: string;
    data?: any;
  }): Promise<void> {
    const activityId = `send-notification-${params.userId}-${Date.now()}`;
    const startTime = Date.now();
    const workflowId = params.data?.instanceId ? `approval-${params.data.instanceId}` : 'notification';

    // 记录 Activity 开始
    this.temporalLogger.logActivityStart({
      workflowId,
      workflowType: 'ApprovalWorkflow',
      activityId,
      activityType: 'SendNotification',
      businessKey: params.data?.instanceId,
      metadata: {
        userId: params.userId,
        notificationType: params.type,
        title: params.title,
      },
    });

    try {
      logger.log(`Sending notification to user: ${params.userId}, type: ${params.type}`);

      await this.notificationService.send({
        channel: 'IN_APP',
        to: params.userId,
        subject: params.title,
        content: params.content,
        metadata: params.data,
      });

      // 记录 Activity 完成
      this.temporalLogger.logActivityComplete({
        workflowId,
        workflowType: 'ApprovalWorkflow',
        activityId,
        activityType: 'SendNotification',
        businessKey: params.data?.instanceId,
        durationMs: Date.now() - startTime,
      });
    } catch (error) {
      // 记录 Activity 失败
      this.temporalLogger.logActivityFailed({
        workflowId,
        workflowType: 'ApprovalWorkflow',
        activityId,
        activityType: 'SendNotification',
        businessKey: params.data?.instanceId,
        error: {
          type: error.name,
          message: error.message,
        },
      });
      throw error;
    }
  }

  async scheduleReminder(params: {
    taskId: string;
    instanceId: string;
    scheduledAt: Date;
    reminderType: string;
    channels: string[];
  }): Promise<void> {
    logger.log(`Scheduling reminder for task: ${params.taskId} at ${params.scheduledAt}`);

    await this.prisma.reminderQueue.create({
      data: {
        taskId: params.taskId,
        instanceId: params.instanceId,
        reminderType: params.reminderType as any,
        channels: params.channels,
        scheduledAt: params.scheduledAt,
        status: 'SCHEDULED',
      },
    });
  }

  // ==================== 回调 ====================

  async callbackFormEngine(params: {
    instanceId: string;
    status: string;
    businessType: string;
    businessId: string;
  }): Promise<void> {
    const activityId = `callback-form-${params.businessId}`;
    const startTime = Date.now();

    // 记录 Activity 开始
    this.temporalLogger.logActivityStart({
      workflowId: `approval-${params.instanceId}`,
      workflowType: 'ApprovalWorkflow',
      activityId,
      activityType: 'CallbackFormEngine',
      businessKey: params.instanceId,
      metadata: {
        businessType: params.businessType,
        businessId: params.businessId,
        status: params.status,
      },
    });

    try {
      logger.log(`Callback to form engine: ${params.businessType}/${params.businessId} with status ${params.status}`);

      // 只有 FORM_INSTANCE 类型才更新表单实例状态
      if (params.businessType !== 'FORM_INSTANCE') {
        logger.log(`Skipping form engine callback for non-form businessType: ${params.businessType}`);
        
        // 记录 Activity 完成（跳过）
        this.temporalLogger.logActivityComplete({
          workflowId: `approval-${params.instanceId}`,
          workflowType: 'ApprovalWorkflow',
          activityId,
          activityType: 'CallbackFormEngine',
          businessKey: params.instanceId,
          durationMs: Date.now() - startTime,
          metadata: {
            skipped: true,
            reason: 'Not FORM_INSTANCE type',
          },
        });
        return;
      }

      // WITHDRAWN/REJECTED/CANCELLED 是不同终态，不能压成一个 REJECTED；
      // TERMINATED（管理员强制终止）落 CANCELLED，跟申请人主动撤回（WITHDRAWN）区分。
      const APPROVAL_TO_FORM_STATUS: Record<string, FormInstanceStatus> = {
        APPROVED: FormInstanceStatus.APPROVED,
        REJECTED: FormInstanceStatus.REJECTED,
        WITHDRAWN: FormInstanceStatus.WITHDRAWN,
        TERMINATED: FormInstanceStatus.CANCELLED,
      };
      const formStatus =
        APPROVAL_TO_FORM_STATUS[params.status] ?? FormInstanceStatus.PENDING_APPROVAL;
      const result = await this.prisma.formInstance.updateMany({
        where: {
          approvalInstanceId: params.instanceId,
        },
        data: {
          status: formStatus,
          approvalStatus: params.status,
        },
      });
      
      if (result.count > 0) {
        logger.log(`Updated ${result.count} form instance(s) with approval status: ${params.status}`);
      } else {
        logger.warn(`No form instances found with approvalInstanceId: ${params.instanceId}`);
      }

      // 记录 Activity 完成
      this.temporalLogger.logActivityComplete({
        workflowId: `approval-${params.instanceId}`,
        workflowType: 'ApprovalWorkflow',
        activityId,
        activityType: 'CallbackFormEngine',
        businessKey: params.instanceId,
        durationMs: Date.now() - startTime,
        metadata: {
          updatedCount: result.count,
        },
      });
    } catch (error) {
      // 记录 Activity 失败
      this.temporalLogger.logActivityFailed({
        workflowId: `approval-${params.instanceId}`,
        workflowType: 'ApprovalWorkflow',
        activityId,
        activityType: 'CallbackFormEngine',
        businessKey: params.instanceId,
        error: {
          type: error.name,
          message: error.message,
        },
      });
      logger.error(`Failed to callback form engine: ${error}`);
      throw error;
    }
  }

  async callbackBusinessSystem(params: {
    instanceId: string;
    callbackUrl: string;
    status: string;
    data?: any;
  }): Promise<void> {
    logger.log(`Callback to business system: ${params.callbackUrl}`);

    try {
      const response = await fetch(params.callbackUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          instanceId: params.instanceId,
          status: params.status,
          data: params.data,
          timestamp: new Date().toISOString(),
        }),
      });

      if (!response.ok) {
        throw new Error(`Callback failed with status: ${response.status}`);
      }
    } catch (error) {
      logger.error(`Failed to callback business system: ${error}`);
      // 添加到重试队列
      await this.addToRetryQueue({
        instanceId: params.instanceId,
        callbackType: 'BUSINESS_CALLBACK',
        callbackUrl: params.callbackUrl,
        payload: {
          status: params.status,
          data: params.data,
        },
        error: String(error),
      });
      throw error;
    }
  }

  async addToRetryQueue(params: {
    instanceId: string;
    callbackType: string;
    callbackUrl?: string;
    payload: any;
    error: string;
  }): Promise<void> {
    logger.log(`Adding to retry queue: ${params.instanceId}`);

    await this.prisma.callbackRetryQueue.create({
      data: {
        instanceId: params.instanceId,
        callbackType: params.callbackType,
        callbackUrl: params.callbackUrl,
        payload: params.payload,
        lastError: params.error,
        nextRetryAt: new Date(Date.now() + 60 * 1000), // 1分钟后重试
        status: 'PENDING',
      },
    });
  }

  // ==================== 日志与审计 ====================

  async createActionLog(params: {
    taskId: string;
    instanceId: string;
    action: string;
    operatorId: string;
    comment?: string;
    targetUserId?: string;
    targetNodeId?: string;
    addSignUsers?: string[];
    formDataChanges?: any;
    attachments?: any;
  }): Promise<string> {
    logger.log(`Creating action log: ${params.action} for task ${params.taskId}`);

    const log = await this.prisma.approvalTaskLog.create({
      data: {
        taskId: params.taskId,
        instanceId: params.instanceId,
        action: params.action as any,
        operatorId: params.operatorId,
        comment: params.comment,
        targetUserId: params.targetUserId,
        targetNodeId: params.targetNodeId,
        addSignUsers: params.addSignUsers || [],
        formDataChanges: params.formDataChanges,
        attachments: params.attachments,
      },
    });

    return log.id;
  }

  // ==================== 钩子执行 ====================

  async executeHook(params: {
    hook: NodeHook;
    context: {
      instanceId: string;
      nodeId: string;
      variables: Record<string, any>;
    };
  }): Promise<void> {
    const { hook, context } = params;
    logger.log(`Executing hook: ${hook.id} of type ${hook.type}`);

    // 检查条件
    if (hook.condition) {
      const conditionMet = this.evaluateCondition(hook.condition, context.variables);
      if (!conditionMet) {
        logger.log(`Hook condition not met, skipping: ${hook.id}`);
        return;
      }
    }

    try {
      switch (hook.type) {
        case 'SEND_EMAIL':
          await this.sendEmailHook(hook.config, context);
          break;
        case 'SEND_WEBHOOK':
          await this.sendWebhookHook(hook.config, context);
          break;
        case 'CREATE_TASK':
          await this.createTaskHook(hook.config, context);
          break;
        case 'UPDATE_RECORD':
          await this.updateRecordHook(hook.config, context);
          break;
        case 'CALL_API':
          await this.callApiHook(hook.config, context);
          break;
        case 'SET_VARIABLE':
          await this.setVariableHook(hook.config, context);
          break;
        case 'LOG':
          logger.log(`Hook LOG: ${JSON.stringify(hook.config)}`);
          break;
        default:
          logger.warn(`Unknown hook type: ${hook.type}`);
      }
    } catch (error) {
      logger.error(`Hook execution failed: ${hook.id}, error: ${error}`);
      if (hook.errorStrategy === 'FAIL_PROCESS') {
        throw error;
      }
      // CONTINUE 策略：记录错误但不中断流程
    }
  }

  async executeHooks(params: {
    hooks: NodeHook[];
    context: {
      instanceId: string;
      nodeId: string;
      variables: Record<string, any>;
    };
  }): Promise<void> {
    for (const hook of params.hooks) {
      await this.executeHook({ hook, context: params.context });
    }
  }

  private async sendEmailHook(config: any, context: any): Promise<void> {
    // 实现邮件发送逻辑
    logger.log(`Sending email: ${JSON.stringify(config)}`);
  }

  private async sendWebhookHook(config: any, context: any): Promise<void> {
    const { url, method = 'POST', headers = {}, body } = config;
    
    const response = await fetch(url, {
      method,
      headers: {
        'Content-Type': 'application/json',
        ...headers,
      },
      body: JSON.stringify({
        ...body,
        instanceId: context.instanceId,
        nodeId: context.nodeId,
        variables: context.variables,
      }),
    });

    if (!response.ok) {
      throw new Error(`Webhook failed: ${response.status}`);
    }
  }

  private async createTaskHook(config: any, context: any): Promise<void> {
    // 实现创建任务逻辑
    logger.log(`Creating task: ${JSON.stringify(config)}`);
  }

  private async updateRecordHook(config: any, context: any): Promise<void> {
    // 实现更新记录逻辑
    logger.log(`Updating record: ${JSON.stringify(config)}`);
  }

  private async callApiHook(config: any, context: any): Promise<void> {
    const { url, method = 'POST', headers = {}, body } = config;
    
    await fetch(url, {
      method,
      headers: {
        'Content-Type': 'application/json',
        ...headers,
      },
      body: JSON.stringify(body),
    });
  }

  private async setVariableHook(config: any, context: any): Promise<void> {
    const { name, value } = config;
    
    await this.prisma.approvalInstance.update({
      where: { id: context.instanceId },
      data: {
        variables: {
          ...(await this.prisma.approvalInstance.findUnique({
            where: { id: context.instanceId },
            select: { variables: true },
          }))?.variables as any,
          [name]: value,
        },
      },
    });
  }

  // ==================== 验证器执行 ====================

  async validateNode(params: {
    validators: NodeValidator[];
    context: {
      taskId: string;
      operatorId: string;
      action: string;
      comment?: string;
      formData?: any;
      attachments?: any[];
    };
  }): Promise<{ valid: boolean; errors: string[] }> {
    const errors: string[] = [];

    for (const validator of params.validators) {
      const result = await this.executeValidator(validator, params.context);
      if (!result.valid) {
        errors.push(result.message || `Validation failed: ${validator.id}`);
      }
    }

    return {
      valid: errors.length === 0,
      errors,
    };
  }

  private async executeValidator(
    validator: NodeValidator,
    context: any,
  ): Promise<{ valid: boolean; message?: string }> {
    const { type, config, message } = validator;

    switch (type) {
      case 'FIELD_REQUIRED':
        const fieldValue = context.formData?.[config.field];
        if (fieldValue === undefined || fieldValue === null || fieldValue === '') {
          return { valid: false, message: message || `字段 ${config.field} 必填` };
        }
        break;

      case 'FIELD_MODIFIED':
        // 检查字段是否被修改
        // 需要比较原始数据和当前数据
        break;

      case 'FIELD_VALUE':
        const value = context.formData?.[config.field];
        if (!this.evaluateCondition(config.condition, { value })) {
          return { valid: false, message: message || `字段 ${config.field} 值不符合要求` };
        }
        break;

      case 'FIELD_PATTERN':
        const patternValue = context.formData?.[config.field];
        if (patternValue && !new RegExp(config.pattern).test(patternValue)) {
          return { valid: false, message: message || `字段 ${config.field} 格式不正确` };
        }
        break;

      case 'CONDITION':
        if (!this.evaluateCondition(config.expression, context.formData)) {
          return { valid: false, message: message || '条件验证失败' };
        }
        break;

      case 'ATTACHMENT_REQUIRED':
        if (!context.attachments || context.attachments.length === 0) {
          return { valid: false, message: message || '必须上传附件' };
        }
        break;

      case 'ATTACHMENT_COUNT':
        const count = context.attachments?.length || 0;
        if (config.min && count < config.min) {
          return { valid: false, message: message || `至少需要 ${config.min} 个附件` };
        }
        if (config.max && count > config.max) {
          return { valid: false, message: message || `最多只能 ${config.max} 个附件` };
        }
        break;

      case 'COMMENT_REQUIRED':
        if (!context.comment || context.comment.trim() === '') {
          return { valid: false, message: message || '必须填写审批意见' };
        }
        break;

      case 'COMMENT_MIN_LENGTH':
        if (!context.comment || context.comment.length < config.minLength) {
          return { valid: false, message: message || `审批意见至少 ${config.minLength} 个字符` };
        }
        break;

      default:
        logger.warn(`Unknown validator type: ${type}`);
    }

    return { valid: true };
  }

  // ==================== 委托处理 ====================

  async checkDelegation(params: {
    userId: string;
    processKey?: string;
  }): Promise<{ shouldDelegate: boolean; delegateTo?: string; reason?: string }> {
    logger.log(`Checking delegation for user: ${params.userId}`);

    // 检查用户委托设置
    const setting = await this.prisma.userDelegationSetting.findUnique({
      where: { userId: params.userId },
    });

    if (!setting || !setting.enabled) {
      return { shouldDelegate: false };
    }

    // 检查时间范围
    const now = new Date();
    if (setting.startTime && now < setting.startTime) {
      return { shouldDelegate: false };
    }
    if (setting.endTime && now > setting.endTime) {
      return { shouldDelegate: false };
    }

    // 检查流程范围
    if (setting.scope === 'SPECIFIC' && params.processKey) {
      if (!setting.processKeys.includes(params.processKey)) {
        return { shouldDelegate: false };
      }
    }

    return {
      shouldDelegate: true,
      delegateTo: setting.delegateUserId,
      reason: setting.reason || '用户已设置委托',
    };
  }

  async resolveDelegateUser(params: {
    delegateTo: string;
    instanceId: string;
    variables: Record<string, any>;
  }): Promise<string | null> {
    const { delegateTo, instanceId, variables } = params;

    if (delegateTo.startsWith('user:')) {
      return delegateTo.replace('user:', '');
    }

    if (delegateTo === 'initiator:manager') {
      const instance = await this.prisma.approvalInstance.findUnique({
        where: { id: instanceId },
        select: {
          initiatorId: true,
        },
      });
      
      if (!instance) {
        return null;
      }
      
      // 获取发起人主部门的直属上级
      const userDept = await this.prisma.userDepartment.findFirst({
        where: {
          userId: instance.initiatorId,
          isPrimary: true,
          leftAt: null,
        },
        select: {
          managerId: true,
        },
      });
      
      return userDept?.managerId || null;
    }

    if (delegateTo.startsWith('role:')) {
      const roleCode = delegateTo.replace('role:', '');
      const user = await this.prisma.user.findFirst({
        where: {
          roles: {
            some: {
              role: { code: roleCode },
            },
          },
          status: 'ACTIVE',
        },
      });
      return user?.id || null;
    }

    return null;
  }

  async executeDelegation(params: {
    taskId: string;
    originalAssignee: string;
    delegateTo: string;
    reason: string;
    delegationType: string;
  }): Promise<void> {
    logger.log(`Executing delegation for task: ${params.taskId} to ${params.delegateTo}`);

    await this.prisma.approvalTask.update({
      where: { id: params.taskId },
      data: {
        assignee: params.delegateTo,
        isDelegated: true,
        delegatedFrom: params.originalAssignee,
        delegatedAt: new Date(),
        delegationReason: params.reason,
        delegationType: params.delegationType as any,
      },
    });
  }

  async getUserDelegationSetting(userId: string): Promise<any> {
    return this.prisma.userDelegationSetting.findUnique({
      where: { userId },
    });
  }

  // ==================== Temporal 日志记录 ====================

  /**
   * 记录 Workflow 状态变化
   * 
   * 供 Workflow 代码调用，用于记录状态变化
   */
  async logWorkflowStateChange(params: {
    workflowId: string;
    workflowType: string;
    workflowRunId?: string;
    currentState: string;
    previousState?: string;
    trigger?: string;
    businessKey?: string;
    initiatorId?: string;
    error?: {
      type: string;
      message: string;
    };
  }): Promise<void> {
    this.temporalLogger.logWorkflowStateChange({
      workflowId: params.workflowId,
      workflowType: params.workflowType,
      workflowRunId: params.workflowRunId,
      currentState: params.currentState as any,
      previousState: params.previousState as any,
      trigger: params.trigger,
      businessKey: params.businessKey,
      initiatorId: params.initiatorId,
      error: params.error,
    });
  }

  // ==================== TD-6: 业务数据集成 ====================

  /**
   * 同步审批人对数据的修改到业务系统
   * 
   * 当审批人在审批过程中修改了可编辑字段时调用
   */
  async syncBusinessDataChanges(params: {
    instanceId: string;
    changes: DataChanges;
    operatorId: string;
  }): Promise<void> {
    if (!this.businessTypeRegistry) {
      logger.warn('BusinessTypeRegistry not available, skipping data sync');
      return;
    }

    const instance = await this.prisma.approvalInstance.findUnique({
      where: { id: params.instanceId },
    });

    if (!instance) {
      logger.error(`Instance not found for data sync: ${params.instanceId}`);
      return;
    }

    try {
      await this.businessTypeRegistry.syncDataChanges(
        instance.businessType,
        instance.businessId,
        params.changes,
        params.operatorId,
      );
      logger.log(`Synced data changes for ${instance.businessType}/${instance.businessId}`);
    } catch (error) {
      logger.error(`Failed to sync data changes: ${error.message}`);
      throw error;
    }
  }

  /**
   * 获取业务数据用于条件评估
   * 
   * TD-6: 审批引擎不存储业务数据副本，通过此方法实时获取
   */
  async getBusinessDataForCondition(params: {
    instanceId: string;
  }): Promise<Record<string, any>> {
    if (!this.businessTypeRegistry) {
      logger.warn('BusinessTypeRegistry not available, returning empty data');
      return {};
    }

    const instance = await this.prisma.approvalInstance.findUnique({
      where: { id: params.instanceId },
    });

    if (!instance) {
      logger.error(`Instance not found for condition evaluation: ${params.instanceId}`);
      return {};
    }

    try {
      return await this.businessTypeRegistry.getBusinessDataForCondition(
        instance.businessType,
        instance.businessId,
      );
    } catch (error) {
      logger.error(`Failed to get business data for condition: ${error.message}`);
      return {};
    }
  }

  // ==================== 辅助方法 ====================

  private evaluateCondition(expression: string, variables: Record<string, any>): boolean {
    try {
      // 简单的条件评估
      // 实际实现可能需要更复杂的表达式解析器
      const func = new Function(...Object.keys(variables), `return ${expression}`);
      return func(...Object.values(variables));
    } catch (error) {
      logger.error(`Failed to evaluate condition: ${expression}, error: ${error}`);
      return false;
    }
  }
}

// ==================== 导出 Activity 函数 ====================

let activitiesInstance: ApprovalActivities;

/**
 * 初始化 Activities
 * 
 * @param prisma - Prisma 服务
 * @param notificationService - 通知服务
 * @param temporalLogger - Temporal 日志服务
 * @param businessTypeRegistry - 业务类型注册表（可选，用于 TD-6 业务数据集成）
 */
export function initializeActivities(
  prisma: PrismaService, 
  notificationService: NotificationService,
  temporalLogger: TemporalLoggerService,
  businessTypeRegistry?: BusinessTypeRegistry,
) {
  activitiesInstance = new ApprovalActivities(prisma, notificationService, temporalLogger);
  if (businessTypeRegistry) {
    activitiesInstance.setBusinessTypeRegistry(businessTypeRegistry);
  }
}

/**
 * 获取 Activities 实例（用于后续注入 BusinessTypeRegistry）
 */
export function getActivitiesInstance(): ApprovalActivities | undefined {
  return activitiesInstance;
}

// 导出所有 Activity 函数供 Temporal Worker 使用
export const createNodeInstance = (params: Parameters<ApprovalActivities['createNodeInstance']>[0]) =>
  activitiesInstance.createNodeInstance(params);

export const completeNodeInstance = (params: Parameters<ApprovalActivities['completeNodeInstance']>[0]) =>
  activitiesInstance.completeNodeInstance(params);

export const skipNodeInstance = (params: Parameters<ApprovalActivities['skipNodeInstance']>[0]) =>
  activitiesInstance.skipNodeInstance(params);

export const suspendInstanceForUnresolvedApprovers = (
  params: Parameters<ApprovalActivities['suspendInstanceForUnresolvedApprovers']>[0],
) => activitiesInstance.suspendInstanceForUnresolvedApprovers(params);

export const resumeInstanceFromSuspension = (
  params: Parameters<ApprovalActivities['resumeInstanceFromSuspension']>[0],
) => activitiesInstance.resumeInstanceFromSuspension(params);

export const failNodeInstance = (params: Parameters<ApprovalActivities['failNodeInstance']>[0]) =>
  activitiesInstance.failNodeInstance(params);

export const updateProcessStatus = (params: Parameters<ApprovalActivities['updateProcessStatus']>[0]) =>
  activitiesInstance.updateProcessStatus(params);

export const failProcess = (params: Parameters<ApprovalActivities['failProcess']>[0]) =>
  activitiesInstance.failProcess(params);

export const onProcessCompleted = (params: Parameters<ApprovalActivities['onProcessCompleted']>[0]) =>
  activitiesInstance.onProcessCompleted(params);

export const createApprovalTask = (params: Parameters<ApprovalActivities['createApprovalTask']>[0]) =>
  activitiesInstance.createApprovalTask(params);

export const createAutoApprovedTask = (params: Parameters<ApprovalActivities['createAutoApprovedTask']>[0]) =>
  activitiesInstance.createAutoApprovedTask(params);

export const completeTask = (params: Parameters<ApprovalActivities['completeTask']>[0]) =>
  activitiesInstance.completeTask(params);

export const cancelTask = (params: Parameters<ApprovalActivities['cancelTask']>[0]) =>
  activitiesInstance.cancelTask(params);

export const getTask = (taskId: string) =>
  activitiesInstance.getTask(taskId);

export const escalateTask = (params: Parameters<ApprovalActivities['escalateTask']>[0]) =>
  activitiesInstance.escalateTask(params);

export const forwardTask = (params: Parameters<ApprovalActivities['forwardTask']>[0]) =>
  activitiesInstance.forwardTask(params);

export const resolveApprovers = (params: Parameters<ApprovalActivities['resolveApprovers']>[0]) =>
  activitiesInstance.resolveApprovers(params);

export const resolveManagerChain = (params: Parameters<ApprovalActivities['resolveManagerChain']>[0]) =>
  activitiesInstance.resolveManagerChain(params);

export const sendReminder = (params: Parameters<ApprovalActivities['sendReminder']>[0]) =>
  activitiesInstance.sendReminder(params);

export const sendNotification = (params: Parameters<ApprovalActivities['sendNotification']>[0]) =>
  activitiesInstance.sendNotification(params);

export const scheduleReminder = (params: Parameters<ApprovalActivities['scheduleReminder']>[0]) =>
  activitiesInstance.scheduleReminder(params);

export const callbackFormEngine = (params: Parameters<ApprovalActivities['callbackFormEngine']>[0]) =>
  activitiesInstance.callbackFormEngine(params);

export const callbackBusinessSystem = (params: Parameters<ApprovalActivities['callbackBusinessSystem']>[0]) =>
  activitiesInstance.callbackBusinessSystem(params);

export const addToRetryQueue = (params: Parameters<ApprovalActivities['addToRetryQueue']>[0]) =>
  activitiesInstance.addToRetryQueue(params);

export const createActionLog = (params: Parameters<ApprovalActivities['createActionLog']>[0]) =>
  activitiesInstance.createActionLog(params);

export const executeHook = (params: Parameters<ApprovalActivities['executeHook']>[0]) =>
  activitiesInstance.executeHook(params);

export const executeHooks = (params: Parameters<ApprovalActivities['executeHooks']>[0]) =>
  activitiesInstance.executeHooks(params);

export const validateNode = (params: Parameters<ApprovalActivities['validateNode']>[0]) =>
  activitiesInstance.validateNode(params);

export const checkDelegation = (params: Parameters<ApprovalActivities['checkDelegation']>[0]) =>
  activitiesInstance.checkDelegation(params);

export const resolveDelegateUser = (params: Parameters<ApprovalActivities['resolveDelegateUser']>[0]) =>
  activitiesInstance.resolveDelegateUser(params);

export const executeDelegation = (params: Parameters<ApprovalActivities['executeDelegation']>[0]) =>
  activitiesInstance.executeDelegation(params);

export const getUserDelegationSetting = (userId: string) =>
  activitiesInstance.getUserDelegationSetting(userId);

// Temporal 日志记录
export const logWorkflowStateChange = (params: Parameters<ApprovalActivities['logWorkflowStateChange']>[0]) =>
  activitiesInstance.logWorkflowStateChange(params);

// TD-6: 业务数据集成
export const syncBusinessDataChanges = (params: Parameters<ApprovalActivities['syncBusinessDataChanges']>[0]) =>
  activitiesInstance.syncBusinessDataChanges(params);

export const getBusinessDataForCondition = (params: Parameters<ApprovalActivities['getBusinessDataForCondition']>[0]) =>
  activitiesInstance.getBusinessDataForCondition(params);