/**
 * 审批引擎 API Client
 * 基于 docs/modules/approval-engine/API.md
 */

import apiClient from '@/lib/api-client';

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

export type InstanceStatus = 'RUNNING' | 'SUSPENDED' | 'COMPLETED' | 'TERMINATED' | 'FAILED';
export type NodeStatus = 'PENDING' | 'ACTIVE' | 'COMPLETED' | 'CANCELLED' | 'FAILED' | 'SKIPPED';
export type TaskStatus = 'CREATED' | 'PENDING' | 'CLAIMED' | 'IN_PROGRESS' | 'COMPLETED' | 'CANCELLED' | 'WITHDRAWN';
export type TaskType = 'APPROVAL' | 'COUNTERSIGN' | 'OR_SIGN' | 'CC' | 'SEQUENTIAL';
export type NodeType = 'START' | 'END' | 'USER_TASK' | 'SERVICE_TASK' | 'EXCLUSIVE_GATEWAY' | 'PARALLEL_GATEWAY' | 'INCLUSIVE_GATEWAY' | 'SUB_PROCESS';
export type ApprovalMode = 'SINGLE' | 'AND' | 'OR' | 'SEQUENTIAL';
export type ApprovalAction = 'APPROVE' | 'REJECT' | 'RETURN' | 'FORWARD' | 'WITHDRAW' | 'APPROVER_WITHDRAW' | 'ADD_SIGN' | 'CLAIM' | 'AUTO_APPROVE' | 'ADMIN_APPROVE' | 'ADMIN_REJECT' | 'ADMIN_TERMINATE' | 'ADMIN_REASSIGN';
export type ProcessStatus = 'ACTIVE' | 'SUSPENDED' | 'ARCHIVED';
export type VersionStatus = 'DRAFT' | 'DEPLOYED' | 'SUPERSEDED' | 'ARCHIVED';
export type AdminExportStatus = 'PENDING' | 'PROCESSING' | 'SUCCESS' | 'FAILED' | 'EXPIRED';

export interface AdminAnalyticsQuery {
  formKey?: string;
  formDefinitionId?: string;
  businessType?: string;
  approvalRequired?: boolean;
  status?: string;
  timeFrom?: string;
  timeTo?: string;
  submitterId?: string;
  organizationId?: string;
  departmentId?: string;
  keyword?: string;
}

export interface AdminInstancesQuery extends AdminAnalyticsQuery {
  page?: number;
  limit?: number;
}

export interface AdminAnalyticsResponse {
  summary: {
    totalSubmissions: number;
    approvalRate: number;
    rejectRate: number;
    avgDurationMs: number;
    runningCount: number;
  };
  trends: Array<{
    date: string;
    submissions: number;
    approvals: number;
    rejections: number;
  }>;
  distribution: Array<{
    formKey: string;
    formName: string;
    count: number;
  }>;
}

export interface AdminInstanceItem {
  instanceId?: string;
  businessInstanceId: string;
  businessType: string;
  formKey?: string;
  formName?: string;
  submitter: UserInfo;
  status: string;
  currentNode?: string;
  submittedAt: string;
  durationMs?: number;
  approvalRequired: boolean;
}

export interface AdminExportItem {
  id: string;
  status: AdminExportStatus;
  format: string;
  fileName?: string;
  fileSize?: number;
  contentType?: string;
  downloadUrl?: string;
  createdAt: string;
  completedAt?: string;
  expiresAt?: string;
}

export interface AdminSettings {
  exportRetentionDays: number;
}

export interface UserInfo {
  id: string;
  name: string;
  displayName?: string;
  avatar?: string;
  department?: string;
  email?: string;
}

export interface Attachment {
  id: string;
  name: string;
  url: string;
  size: number;
  mimeType: string;
}

// ============================================
// 流程定义类型
// ============================================

export interface ProcessNode {
  id: string;
  type: NodeType;
  name: string;
  description?: string;
  position?: { x: number; y: number };
  
  // 审批节点配置
  assignee?: string;
  approvalMode?: ApprovalMode;
  chainConfig?: {
    stopCondition?: string;
    includeTerminator?: boolean;
    skipSelf?: boolean;
    autoApprove?: 'none' | 'sameApprover' | 'initiator' | 'both';
    maxLevels?: number;
  };
  timeout?: {
    hours: number;
    remindBeforeHours?: number;
    action?: string;
  };
  
  // 表单字段权限
  editableFields?: string[];
  requiredFields?: string[];
  
  // 允许的操作
  allowedActions?: string[];
  
  // 网关条件
  condition?: string;
}

export interface ProcessEdge {
  id: string;
  source: string;
  target: string;
  sourceHandle?: string;
  targetHandle?: string;
  label?: string;
  condition?: string;
  priority?: number;
}

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

export interface ProcessSettings {
  withdraw?: {
    allowWithdraw: boolean;
    withdrawBeforeNode?: string[];
    withdrawReason: boolean;
  };
  approverWithdraw?: {
    enabled: boolean;
    timeLimit: number;
    requireReason: boolean;
    notifyInitiator: boolean;
  };
  defaultPriority?: number;
  maxNodeExecutions?: number;
  maxTotalNodeExecutions?: number;
  maxReturnCount?: number;
}

export interface ProcessDefinition {
  id: string;
  key: string;
  name: string;
  category: string;
  description?: string;
  status: ProcessStatus;
  latestVersion: number;
  organizationId?: string; // 归属组织 ID
  activeInstanceCount?: number;
  totalInstanceCount?: number;
  createdBy?: string;
  createdAt: string;
  updatedAt: string;
}

export interface ProcessVersion {
  id: string;
  definitionId: string;
  version: number;
  name: string;
  isDefault: boolean;
  processModel: ProcessModel;
  settings: ProcessSettings;
  status: VersionStatus;
  deployedAt?: string;
  deployedBy?: string;
  changeLog?: string;
  createdAt: string;
}

// ============================================
// 流程实例类型
// ============================================

export interface ApprovalTaskItem {
  taskId: string;
  instanceId: string;
  businessType: string;
  businessId: string;
  businessKey?: string;
  title?: string;
  status: TaskStatus;
  priority: number;
  initiator: UserInfo;
  nodeName: string;
  nodeType: string;
  approvalMode?: ApprovalMode;
  createTime: string;
  dueDate?: string;
  isOverdue: boolean;
  remainingHours?: number;
  isDelegated: boolean;
  delegatedFrom?: UserInfo;
  lastReminderTime?: string;
  reminderCount?: number;
  // 表单相关字段（从 variables 中提取，仅表单类型审批有值）
  formKey?: string;
  formDefinitionId?: string;
  formVersionId?: string;
}

export interface ProcessInstanceItem {
  id: string;
  businessType: string;
  businessId: string;
  businessKey?: string;
  title?: string;
  processDefinitionKey: string;
  processDefinitionName: string;
  status: InstanceStatus;
  currentNodeId?: string;
  currentNodeName?: string;
  currentAssignees: UserInfo[];
  startTime: string;
  endTime?: string;
  endReason?: string;
  priority: number;
}

export interface DiagramNode {
  id: string;
  type: string;
  position: { x: number; y: number };
  data: {
    label: string;
    nodeType: NodeType;
    status: NodeStatus;
    isCurrent: boolean;
    assignees?: UserInfo[];
    approvalMode?: ApprovalMode;
    history?: Array<{
      action: ApprovalAction;
      operator: UserInfo;
      comment?: string;
      actionTime: string;
    }>;
    isOverdue?: boolean;
    dueDate?: string;
  };
  style?: Record<string, any>;
}

export interface DiagramEdge {
  id: string;
  source: string;
  target: string;
  type: string;
  label?: string;
  animated: boolean;
  style?: Record<string, any>;
  data?: {
    condition?: string;
    isActive: boolean;
  };
}

export interface ProcessDiagramResponse {
  nodes: DiagramNode[];
  edges: DiagramEdge[];
  instance: {
    id: string;
    status: InstanceStatus;
    currentNodeId?: string;
    startTime: string;
    endTime?: string;
  };
  initiator: UserInfo;
}

export interface PaginatedResponse<T> {
  items: T[];
  total: number;
  page: number;
  limit: number;
  totalPages: number;
  hasNext: boolean;
  hasPrev: boolean;
}

// ============================================
// 流程定义管理 API
// ============================================

export interface DefinitionsQueryDto {
  category?: string;
  status?: ProcessStatus;
  page?: number;
  limit?: number;
  keyword?: string;
}

export interface CreateDefinitionDto {
  key: string;
  name: string;
  category: string;
  description?: string;
  processModel: ProcessModel;
  settings?: ProcessSettings;
}

export interface UpdateDefinitionDto {
  name?: string;
  category?: string;
  description?: string;
  status?: ProcessStatus;
}

export interface CreateVersionDto {
  name: string;
  processModel: ProcessModel;
  settings?: ProcessSettings;
  changeLog?: string;
  setAsDefault?: boolean;
}

/** 获取流程定义列表 */
export async function getProcessDefinitions(params?: DefinitionsQueryDto): Promise<PaginatedResponse<ProcessDefinition>> {
  return apiClient.get('/approval/definitions', { params });
}

/** 获取流程定义详情 */
export async function getProcessDefinition(key: string): Promise<ProcessDefinition & { versions: ProcessVersion[] }> {
  return apiClient.get(`/approval/definitions/${key}`);
}

/** 创建流程定义 */
export async function createProcessDefinition(data: CreateDefinitionDto): Promise<ProcessDefinition> {
  return apiClient.post('/approval/definitions', data);
}

/** 更新流程定义 */
export async function updateProcessDefinition(key: string, data: UpdateDefinitionDto): Promise<ProcessDefinition> {
  return apiClient.patch(`/approval/definitions/${key}`, data);
}

/** 删除流程定义 */
export async function deleteProcessDefinition(key: string): Promise<{ deleted: boolean }> {
  return apiClient.delete(`/approval/definitions/${key}`);
}

/** 获取版本列表 */
export async function getProcessVersions(key: string): Promise<{ items: ProcessVersion[] }> {
  return apiClient.get(`/approval/definitions/${key}/versions`);
}

/** 获取版本详情 */
export async function getProcessVersion(key: string, version: number): Promise<ProcessVersion> {
  return apiClient.get(`/approval/definitions/${key}/versions/${version}`);
}

/** 创建新版本 */
export async function createProcessVersion(key: string, data: CreateVersionDto): Promise<ProcessVersion> {
  return apiClient.post(`/approval/definitions/${key}/versions`, data);
}

/** 部署版本 */
export async function deployProcessVersion(key: string, version: number): Promise<ProcessVersion> {
  return apiClient.post(`/approval/definitions/${key}/versions/${version}/deploy`);
}

// ============================================
// 流程启动与操作 API
// ============================================

export interface StartApprovalDto {
  processDefinitionKey: string;
  businessType: string;
  businessId: string;
  businessKey?: string;
  title?: string;
  variables?: Record<string, any>;
  priority?: number;
  dueDate?: string;
  version?: number;
}

export interface StartApprovalResponse {
  instanceId: string;
  workflowId: string;
  workflowRunId: string;
  status: InstanceStatus;
  currentNodeId?: string;
  startTime: string;
}

export interface ApprovalActionResponse {
  success: boolean;
  taskId: string;
  action: string;
  nextNodeId?: string;
  isProcessCompleted: boolean;
}

/** 启动审批流程 */
export async function startApproval(data: StartApprovalDto): Promise<StartApprovalResponse> {
  return apiClient.post('/approval/start', data);
}

/** 审批通过 */
export async function approveTask(
  instanceId: string,
  data: { taskId: string; comment?: string; formData?: Record<string, any>; attachments?: Attachment[] }
): Promise<ApprovalActionResponse> {
  return apiClient.post(`/approval/${instanceId}/approve`, data);
}

/** 审批驳回 */
export async function rejectTask(
  instanceId: string,
  data: { taskId: string; comment: string; rejectCode?: string }
): Promise<ApprovalActionResponse> {
  return apiClient.post(`/approval/${instanceId}/reject`, data);
}

/** 退回 */
export async function returnTask(
  instanceId: string,
  data: { taskId: string; targetNodeId: string; comment: string }
): Promise<ApprovalActionResponse> {
  return apiClient.post(`/approval/${instanceId}/return`, data);
}

/** 转发 */
export async function forwardTask(
  instanceId: string,
  data: { taskId: string; toUserId: string; comment?: string }
): Promise<ApprovalActionResponse> {
  return apiClient.post(`/approval/${instanceId}/forward`, data);
}

/** 发起人撤回 */
export async function withdrawApproval(
  instanceId: string,
  data?: { reason?: string }
): Promise<{ success: boolean; instanceId: string; status: 'WITHDRAWN'; endReason: 'WITHDRAWN' }> {
  return apiClient.post(`/approval/${instanceId}/withdraw`, data || {});
}

/** 审批人撤回 */
export async function approverWithdrawTask(
  instanceId: string,
  data: { taskId: string; reason: string }
): Promise<ApprovalActionResponse> {
  return apiClient.post(`/approval/${instanceId}/approver-withdraw`, data);
}

/** 加签 */
export async function addSignTask(
  instanceId: string,
  data: {
    taskId: string;
    userIds: string[];
    type: 'BEFORE' | 'AFTER' | 'PARALLEL';
    comment?: string;
  }
): Promise<ApprovalActionResponse> {
  return apiClient.post(`/approval/${instanceId}/add-sign`, data);
}

/** 认领任务 */
export async function claimTask(
  instanceId: string,
  data: { taskId: string }
): Promise<ApprovalActionResponse> {
  return apiClient.post(`/approval/${instanceId}/claim`, data);
}

/** 取消认领 */
export async function unclaimTask(
  instanceId: string,
  data: { taskId: string }
): Promise<ApprovalActionResponse> {
  return apiClient.post(`/approval/${instanceId}/unclaim`, data);
}

// ============================================
// 任务查询 API
// ============================================

export interface PendingTasksQuery {
  page?: number;
  limit?: number;
  businessType?: string;
  processKey?: string;
  priority?: number;
  keyword?: string;
  isDelegated?: boolean;
  sortBy?: 'createTime' | 'dueDate' | 'priority' | 'remainingHours';
  sortOrder?: 'asc' | 'desc';
}

export interface InitiatedQuery {
  page?: number;
  limit?: number;
  status?: InstanceStatus;
  businessType?: string;
  processKey?: string;
  startTimeFrom?: string;
  startTimeTo?: string;
  keyword?: string;
}

/** 获取我的待办 */
export async function getMyPendingTasks(params?: PendingTasksQuery): Promise<PaginatedResponse<ApprovalTaskItem>> {
  return apiClient.get('/approval/my/pending', { params });
}

/** 获取我发起的 */
export async function getMyInitiatedProcesses(params?: InitiatedQuery): Promise<PaginatedResponse<ApprovalTaskItem>> {
  return apiClient.get('/approval/my/initiated', { params });
}

/**
 * 管理员获取所有流程实例
 */
export async function getAdminInstances(params?: AdminInstancesQuery): Promise<PaginatedResponse<AdminInstanceItem>> {
  return apiClient.get('/approval/admin/instances', { params });
}

export async function getAdminAnalytics(params?: AdminAnalyticsQuery): Promise<AdminAnalyticsResponse> {
  return apiClient.get('/approval/admin/analytics', { params });
}

export async function exportAdminInstances(data: AdminAnalyticsQuery & { format?: 'xlsx' | 'csv' }): Promise<{ taskId: string }> {
  return apiClient.post('/approval/admin/instances/export', data);
}

export async function getAdminExports(): Promise<AdminExportItem[]> {
  return apiClient.get('/approval/admin/exports');
}

export async function getAdminExportStatus(taskId: string): Promise<AdminExportItem> {
  return apiClient.get(`/approval/admin/exports/${taskId}`);
}

export async function getAdminSettings(): Promise<AdminSettings> {
  return apiClient.get('/approval/admin/settings');
}

export async function updateAdminSettings(data: AdminSettings): Promise<AdminSettings> {
  return apiClient.put('/approval/admin/settings', data);
}

/** 获取我已处理的 */
export async function getMyProcessedTasks(params?: {
  page?: number;
  limit?: number;
  businessType?: string;
  action?: ApprovalAction;
}): Promise<PaginatedResponse<ApprovalTaskItem>> {
  return apiClient.get('/approval/my/processed', { params });
}

/** 获取审批统计 */
export async function getApprovalStats(): Promise<{
  pendingCount: number;
  urgentCount: number;
  overdueCount: number;
  initiatedCount: number;
  processedToday: number;
  processedThisWeek: number;
  ccUnreadCount: number;
}> {
  return apiClient.get('/approval/my/stats');
}

/** 获取抄送我的任务 */
export async function getMyCCTasks(params?: {
  page?: number;
  limit?: number;
  businessType?: string;
  unreadOnly?: boolean;
}): Promise<PaginatedResponse<{
  id: string;
  instanceId: string;
  businessType: string;
  businessId: string;
  businessKey?: string;
  title?: string;
  nodeName: string;
  initiator: UserInfo;
  ccTime: string;
  isRead: boolean;
  readTime?: string;
  processStatus: InstanceStatus;
}>> {
  return apiClient.get('/approval/my/cc', { params });
}

/** 标记抄送已读 */
export async function markCCAsRead(ccId: string): Promise<{ success: boolean }> {
  return apiClient.post(`/approval/my/cc/${ccId}/read`);
}

/** 批量标记抄送已读 */
export async function batchMarkCCAsRead(ccIds: string[]): Promise<{ success: boolean; marked: number }> {
  return apiClient.post('/approval/my/cc/batch-read', { ccIds });
}

// ============================================
// 流程查询 API
// ============================================

/** 获取流程详情 */
export async function getProcessInstance(instanceId: string): Promise<ProcessInstanceItem & {
  processDefinition: ProcessDefinition;
  processVersion: ProcessVersion;
  variables: Record<string, any>;
  nodeInstances: any[];
  pendingTasks: ApprovalTaskItem[];
}> {
  return apiClient.get(`/approval/${instanceId}`);
}

/** 获取流程状态 */
export async function getProcessStatus(instanceId: string): Promise<{
  id: string;
  status: InstanceStatus;
  currentNodeId?: string;
  currentNodeName?: string;
  currentAssignees: UserInfo[];
  startTime: string;
  endTime?: string;
  endReason?: string;
  progress: number;
}> {
  return apiClient.get(`/approval/${instanceId}/status`);
}

/** 获取审批历史 */
export async function getApprovalHistory(instanceId: string): Promise<{
  items: Array<{
    nodeId: string;
    nodeName: string;
    nodeType: NodeType;
    status: NodeStatus;
    startTime: string;
    endTime?: string;
    tasks: Array<{
      id: string;
      assignee?: UserInfo;
      status: TaskStatus;
      autoApproved: boolean;
      autoApproveReason?: string;
      actions: Array<{
        id: string;
        action: ApprovalAction;
        operator: UserInfo;
        comment?: string;
        actionTime: string;
      }>;
    }>;
  }>;
  status?: string;  // ⭐ 新增：流程实例的最新状态
  endReason?: string;  // ⭐ 新增：流程终止原因
}> {
  return apiClient.get(`/approval/${instanceId}/history`);
}

/** 通过业务查询流程 */
export async function getProcessByBusiness(
  businessType: string,
  businessId: string
): Promise<{ instance?: ProcessInstanceItem; exists: boolean }> {
  return apiClient.get(`/approval/by-business/${businessType}/${businessId}`);
}

// ============================================
// 流程图数据 API
// ============================================

/** 获取流程图数据（基于实例） */
export async function getProcessDiagram(instanceId: string): Promise<ProcessDiagramResponse> {
  return apiClient.get(`/approval/${instanceId}/diagram`);
}

/** 通过业务获取流程图 */
export async function getProcessDiagramByBusiness(
  businessType: string,
  businessId: string
): Promise<ProcessDiagramResponse> {
  return apiClient.get(`/approval/diagram/${businessType}/${businessId}`);
}

// ============================================
// 管理员审批处理 API
// ============================================

export interface AdminAuditLogItem {
  id: string;
  action: 'ADMIN_TERMINATE' | 'ADMIN_APPROVE' | 'ADMIN_REJECT' | 'ADMIN_REASSIGN';
  riskLevel: 'HIGH' | 'MEDIUM' | 'LOW';
  operator: UserInfo;
  instanceId: string;
  taskId?: string;
  reason: string;
  comment?: string;
  createdAt: string;
}

/** 管理员强制结束流程 */
export async function adminTerminateProcess(
  instanceId: string,
  data: { reason: string }
): Promise<{
  success: boolean;
  instanceId: string;
  action: string;
  message: string;
  auditLogId: string;
}> {
  return apiClient.post(`/approval/admin/${instanceId}/terminate`, data, {
    headers: {
      'X-Admin-Reason': data.reason
    }
  });
}

/**
 * 管理员介入恢复挂起的审批流程（ERR-20260501-004 配套）
 * 节点审批人解析失败时 workflow 进入 SUSPENDED 状态，管理员通过此接口指定审批人列表恢复流程。
 */
export async function adminResumeWithApprovers(
  instanceId: string,
  data: { approverIds: string[]; reason: string }
): Promise<{
  success: boolean;
  instanceId: string;
  action: string;
  status: string;
  message: string;
  auditLogId: string;
}> {
  return apiClient.post(`/approval/admin/${instanceId}/resume-with-approvers`, data, {
    headers: {
      'X-Admin-Reason': data.reason,
    },
  });
}

/** 管理员代审批通过 */
export async function adminApproveTask(
  instanceId: string,
  data: { taskId: string; reason: string; comment?: string }
): Promise<{
  success: boolean;
  instanceId: string;
  taskId: string;
  action: string;
  message: string;
  auditLogId: string;
}> {
  return apiClient.post(`/approval/admin/${instanceId}/approve`, data, {
    headers: {
      'X-Admin-Reason': data.reason
    }
  });
}

/** 管理员代审批驳回 */
export async function adminRejectTask(
  instanceId: string,
  data: { taskId: string; reason: string; comment?: string }
): Promise<{
  success: boolean;
  instanceId: string;
  taskId: string;
  action: string;
  message: string;
  auditLogId: string;
}> {
  return apiClient.post(`/approval/admin/${instanceId}/reject`, data, {
    headers: {
      'X-Admin-Reason': data.reason
    }
  });
}

/** 管理员重新分配任务 */
export async function adminReassignTask(
  instanceId: string,
  data: { taskId: string; targetUserId: string; reason: string }
): Promise<{
  success: boolean;
  instanceId: string;
  taskId: string;
  action: string;
  message: string;
  auditLogId: string;
}> {
  // ⚠️ 后端期望的字段名是 newAssigneeId，不是 targetUserId
  return apiClient.post(`/approval/admin/${instanceId}/reassign`, {
    taskId: data.taskId,
    newAssigneeId: data.targetUserId,
    reason: data.reason
  }, {
    headers: {
      'X-Admin-Reason': data.reason
    }
  });
}

/** 查询管理员审计日志 */
export async function getAdminAuditLogs(params: {
  page: number;
  limit: number;
  action?: string;
  operatorId?: string;
  startTime?: string;
  endTime?: string;
}): Promise<{
  items: AdminAuditLogItem[];
  total: number;
  page: number;
  limit: number;
}> {
  return apiClient.get('/approval/admin/audit-logs', { params });
}

// ============================================
// 管理员 API
// ============================================

/** 同步流程配置 */
export async function syncProcessConfig(data?: { keys?: string[]; force?: boolean }): Promise<{
  results: {
    created: number;
    updated: number;
    skipped: number;
    errors: Array<{ key: string; error: string }>;
  };
}> {
  return apiClient.post('/approval/admin/sync', data || {});
}

/** 强制结束流程 */
export async function terminateProcess(
  instanceId: string,
  data: { reason: string }
): Promise<{ success: boolean; instanceId: string; status: 'TERMINATED'; endReason: 'ADMIN_TERMINATED' }> {
  return apiClient.post(`/approval/admin/${instanceId}/terminate`, data);
}