import request from '@/utils/request'

export interface Task {
  id?: number
  taskNo?: string
  title: string
  taskTypeId: number
  taskSubType?: string
  quantity?: number
  score?: number
  estimatedHours?: number
  brandId?: number
  categoryId?: number
  spuInfo?: string
  platformId?: number
  attachmentUrl?: string
  deliveryPath?: string
  publisherId?: number
  publisherDeptId?: number
  receiverId?: number
  receiverDeptId?: number
  receiverName?: string
  receiverDeptName?: string
  releaseType: string
  status?: string
  auditStatus?: string
  auditorId?: number
  auditorName?: string
  auditTime?: string
  auditComment?: string
  progress?: number
  startTime?: string
  deadline?: string
  completeTime?: string
  rating?: number
  reviewComment?: string
  rejectReason?: string
  isUrgent?: number
  isDelayed?: number
  createTime?: string
  updateTime?: string
  remark?: string
  // 流水线任务字段
  isPipeline?: number
  pipelineMode?: 'sequential' | 'parallel'
  // 两级审核字段
  approvalStatus?: string // pending_demand_approval/pending_receiving_approval/approved/rejected_by_demand/rejected_by_receiving
  currentApproverId?: number
  currentApproverRole?: string // demand_leader/receiving_leader
  currentApproverName?: string // 当前审核人姓名
  demandApprovalTime?: string
  receivingApprovalTime?: string
  // 关联字段（从后端查询返回）
  brandName?: string
  categoryName?: string
  platformName?: string
  publisherName?: string
  publisherDeptName?: string
}

// 任务子项（流水线任务）
export interface TaskItem {
  id?: number
  taskId: number
  itemNo?: string
  taskTypeId: number
  taskTypeName?: string
  quantity: number
  unitScore: number
  totalScore: number
  estimatedHours?: number
  receiverId?: number
  receiverName?: string
  status: string  // locked/pending/in_progress/completed/rejected
  progress?: number
  isLocked?: number
  prevItemId?: number
  deliveryPath?: string
  submitTime?: string
  completeTime?: string
  sortOrder: number
  createTime?: string
  updateTime?: string
  // 主任务信息
  mainTaskTitle?: string
  pipelineMode?: 'sequential' | 'parallel'
  totalItems?: number
  // 其他关联字段
  brandName?: string
  categoryName?: string
  platformName?: string
  publisherName?: string
  spuInfo?: string
  taskSubType?: string
  attachmentUrl?: string
}

// 创建流水线任务请求
export interface PipelineTaskRequest {
  title: string
  isPipeline: boolean
  pipelineMode: 'sequential' | 'parallel'
  items: Array<{
    taskTypeId: number
    quantity: number
    sortOrder: number
  }>
  brandId?: number
  categoryId?: number
  platformId?: number
  spuInfo?: string
  taskSubType?: string
  attachmentUrl?: string
  remark?: string
  priority?: string
}

export interface TaskAuditRequest {
  taskId: number
  result: 'pass' | 'reject'
  comment?: string
}

export interface TaskListParams {
  status?: string
  taskTypeId?: number
  page?: number
  pageSize?: number
}

export interface TaskHallParams {
  taskTypeId?: number
  demandTypeId?: number
  brandId?: number
  categoryId?: number
  platformId?: number
  taskSubType?: string
  minScore?: number
  maxScore?: number
  keyword?: string
  publisherName?: string
  timeRange?: 'today' | 'week' | 'month'
  sortBy?: 'latest' | 'score' | 'deadline' | 'hot'
  page?: number
  pageSize?: number
}

export interface MyTasksParams {
  role?: 'publisher' | 'receiver'
  status?: string
  page?: number
  pageSize?: number
}

/**
 * 创建任务
 */
export const createTask = (data: Task) => {
  return request.post<any>('/tasks', data)
}

/**
 * 获取任务列表
 */
export const getTaskList = (params: TaskListParams) => {
  return request.get<any>('/tasks', { params })
}

/**
 * 获取任务详情
 */
export const getTaskById = (id: number) => {
  return request.get<any>(`/tasks/${id}`)
}

/**
 * 更新任务
 */
export const updateTask = (id: number, data: Partial<Task>) => {
  return request.put<any>(`/tasks/${id}`, data)
}

/**
 * 抢单
 */
export const grabTask = (id: number) => {
  return request.post<any>(`/tasks/${id}/grab`)
}

/**
 * 提交任务
 */
export const submitTask = (id: number, deliveryPath: string) => {
  return request.post<any>(`/tasks/${id}/submit`, null, {
    params: { deliveryPath }
  })
}

/**
 * 审核任务
 */
export const reviewTask = (
  id: number,
  approved: boolean,
  comment?: string,
  rating?: number
) => {
  return request.post<any>(`/tasks/${id}/review`, null, {
    params: { approved, comment, rating }
  })
}

/**
 * 取消任务
 */
export const cancelTask = (id: number, reason: string) => {
  return request.post<any>(`/tasks/${id}/cancel`, null, {
    params: { reason }
  })
}

/**
 * 获取任务大厅
 */
export const getTaskHall = (params: TaskHallParams) => {
  return request.get<any>('/tasks/hall', { params })
}

/**
 * 获取已完成任务列表（根据角色权限）
 */
export const getCompletedTasks = (params: any) => {
  return request.get<any>('/tasks/completed', { params })
}

/**
 * 获取我的进行中任务列表
 */
export const getMyInProgressTasks = () => {
  return request.get<any>('/tasks/my-in-progress')
}

/**
 * 批量更新任务进度
 */
export const batchUpdateProgress = (updates: Array<{taskId: number, progress: number, remark?: string}>) => {
  return request.post<any>('/tasks/batch-update-progress', { updates })
}

/**
 * 获取我的任务
 */
export const getMyTasks = (params: MyTasksParams) => {
  return request.get<any>('/tasks/my', { params })
}

/**
 * 提交任务审核
 */
export const submitTaskAudit = (id: number) => {
  return request.post<any>(`/tasks/${id}/submit-audit`)
}

/**
 * 审核任务（部门负责人）
 */
export const auditTask = (data: TaskAuditRequest) => {
  return request.post<any>('/tasks/audit', data)
}

/**
 * 强制指派任务
 */
export const assignTask = (taskId: number, assigneeId: number, comment?: string) => {
  return request.post<any>('/tasks/assign', {
    taskId,
    assigneeId,
    assignType: 'force',
    comment
  })
}

/**
 * 获取负责人任务列表（需求部门负责人）
 */
export const getLeaderTaskList = (params: { auditStatus?: string; page?: number; pageSize?: number }) => {
  return request.get<any>('/tasks/leader/demand', { params })
}

/**
 * 获取接单部门负责人视图
 */
export const getLeaderReceivingTaskList = (params: { status?: string; page?: number; pageSize?: number }) => {
  return request.get<any>('/tasks/leader/receiving', { params })
}

/**
 * 工作台统计数据接口
 */
export interface DashboardStats {
  availableCount?: number
  publishedCount?: number // 发布的任务数（当前用户当月发布的任务总数）
  inProgressCount: number
  completedCount: number
  reviewCount: number
  totalScore: number
  todayStartedCount: number
  todayCompletedCount: number
  weekCompletedCount: number
  lastWeekCompletedCount: number
}

/**
 * 获取工作台统计数据
 */
export const getDashboardStats = (params?: { month?: string }) => {
  return request.get<DashboardStats>('/tasks/dashboard/stats', { params })
}

/**
 * 通用获取任务列表（支持状态筛选）
 */
export const getTasks = (params: any) => {
  return request.get<any>('/tasks', { params })
}

/**
 * 更新任务进度
 */
export const updateTaskProgress = (taskId: number, progress: number) => {
  return request.post<any>(`/tasks/${taskId}/progress`, { progress })
}

/**
 * 完结任务（提交审核）
 */
export const completeTask = (taskId: number, data: { deliveryPath: string }) => {
  return request.post<any>(`/tasks/${taskId}/complete`, data)
}

/**
 * 审核通过任务
 */
export const approveTask = (taskId: number) => {
  return request.post<any>(`/tasks/${taskId}/approve`)
}

/**
 * 驳回任务
 */
export const rejectTask = (taskId: number, data: { reason: string }) => {
  return request.post<any>(`/tasks/${taskId}/reject`, data)
}

// ==================== 流水线任务相关 API ====================

/**
 * 创建流水线任务
 */
export const createPipelineTask = (data: PipelineTaskRequest) => {
  return request.post<any>('/tasks/pipeline', data)
}

/**
 * 获取可接单的子任务列表
 */
export const getAvailableTaskItems = (params: {
  page?: number
  pageSize?: number
  taskTypeId?: number
  keyword?: string
}) => {
  return request.get<any>('/tasks/items/available', { params })
}

/**
 * 获取进行中的子任务列表
 */
export const getInProgressTaskItems = (params: {
  page?: number
  pageSize?: number
}) => {
  return request.get<any>('/tasks/items/in-progress', { params })
}

/**
 * 获取已完成的子任务列表
 */
export const getCompletedTaskItems = (params: {
  page?: number
  pageSize?: number
}) => {
  return request.get<any>('/tasks/items/completed', { params })
}

/**
 * 根据主任务ID获取所有子任务
 */
export const getTaskItemsByTaskId = (taskId: number) => {
  return request.get<any>(`/tasks/items/task/${taskId}`)
}

/**
 * 获取子任务详情
 */
export const getTaskItemById = (itemId: number) => {
  return request.get<any>(`/tasks/items/${itemId}`)
}

/**
 * 抢单子任务
 */
export const grabTaskItem = (itemId: number) => {
  return request.post<any>(`/tasks/items/${itemId}/grab`)
}

/**
 * 更新子任务进度
 */
export const updateTaskItemProgress = (itemId: number, progress: number) => {
  return request.post<any>(`/tasks/items/${itemId}/progress`, null, {
    params: { progress }
  })
}

/**
 * 完结子任务
 */
export const completeTaskItem = (itemId: number, data: { deliveryPath: string }) => {
  return request.post<any>(`/tasks/items/${itemId}/complete`, data)
}

/**
 * 驳回子任务
 */
export const rejectTaskItem = (itemId: number, data: { reason: string }) => {
  return request.post<any>(`/tasks/items/${itemId}/reject`, data)
}

/**
 * 获取主任务进度统计
 */
export const getTaskItemsProgress = (taskId: number) => {
  return request.get<any>(`/tasks/items/task/${taskId}/progress`)
}

/**
 * 审核子任务组
 */
export const approveTaskItemGroup = (data: {
  taskId: number
  groupNo: number
  assignedReceiverId?: number
}) => {
  return request.post<any>('/tasks/items/groups/approve', data)
}

/**
 * 获取待审核的子任务组列表
 */
export const getPendingApprovalGroups = (deptId?: number) => {
  return request.get<any>('/tasks/items/groups/pending-approval', {
    params: deptId ? { deptId } : {}
  })
}

// ==================== 两级审核API ====================

/**
 * 任务审核DTO
 */
export interface TaskApprovalDTO {
  comment?: string // 审核意见
  taskUpdates?: TaskUpdateDTO // 任务修改（可选）
  assignedReceiverId?: number // 指定的接收人ID（用于接单部门审核时指定设计师）
}

/**
 * 任务更新DTO
 */
export interface TaskUpdateDTO {
  title?: string
  taskSubType?: string
  brandId?: number
  platformId?: number
  categoryId?: number
  spuInfo?: string
  remark?: string
  attachmentUrl?: string
  taskTypes?: Array<{
    taskTypeId: number
    quantity: number
  }>
}

/**
 * 获取待审核任务列表
 */
export const getPendingApprovalTasks = () => {
  return request.get<Task[]>('/tasks/pending-approval')
}

/**
 * 获取所有待审核任务（处于审批流程中的任务）
 */
export const getAllPendingApprovalTasks = (params?: { taskTypeId?: number; page?: number; pageSize?: number }) => {
  return request.get<any>('/tasks/pending-approval-all', { params })
}

/**
 * 需求部门负责人审核通过
 */
export const approveDemandLevel = (taskId: number, data: TaskApprovalDTO) => {
  return request.post<any>(`/tasks/${taskId}/approve-demand`, data)
}

/**
 * 需求部门负责人驳回
 */
export const rejectByDemandLeader = (taskId: number, reason: string) => {
  return request.post<any>(`/tasks/${taskId}/reject-demand`, { reason })
}

/**
 * 接单部门负责人审核通过
 */
export const approveReceivingLevel = (taskId: number, data: TaskApprovalDTO) => {
  return request.post<any>(`/tasks/${taskId}/approve-receiving`, data)
}

/**
 * 接单部门负责人驳回
 */
export const rejectByReceivingLeader = (taskId: number, reason: string) => {
  return request.post<any>(`/tasks/${taskId}/reject-receiving`, { reason })
}

// ==================== 子任务组审核相关 ====================

/**
 * 子任务组信息
 */
export interface TaskGroup {
  groupId: number
  mainTaskId: number
  mainTaskTitle: string
  mainTaskNo: string
  items: TaskItem[]
  totalScore: number
}

/**
 * 获取待审核的子任务组列表
 */
export const getPendingApprovalTaskGroups = () => {
  return request.get<TaskGroup[]>('/tasks/items/pending-approval-groups')
}

/**
 * 审核通过子任务组
 */
export const approveTaskGroup = (groupId: number, data: { assignedReceiverId?: number; comment?: string }) => {
  return request.post<any>(`/tasks/items/groups/${groupId}/approve`, data)
}

/**
 * 驳回子任务组
 */
export const rejectTaskGroup = (groupId: number, reason: string) => {
  return request.post<any>(`/tasks/items/groups/${groupId}/reject`, { reason })
}