import { buildClaimUrl, buildConfiguredClaimUrl } from '../claim/claim-service.js'
import { buildClaimIdentityAdminSummary } from '../claim/claim-identity.js'
import { getClaimTokenById } from '../../repositories/claim-token-repo.js'
import {
  listOrderItemsByOrderId,
  listOrderItemsByOrderIds,
} from '../../repositories/order-item-repo.js'
import { getOrderById, listOrders } from '../../repositories/order-repo.js'
import { listOrderRefunds } from '../finance/order-refund-service.js'
import { getManualFulfillmentCountsByOrderIds } from '../finance/manual-fulfillment-service.js'
import {
  getTaskById,
  listTasks,
  listTasksByOrderId,
  listTasksByOrderIds,
} from '../../repositories/task-repo.js'
import { listTaskEventsByTaskId } from '../../repositories/task-event-repo.js'
import type { JsonRecord } from '../../types/json.js'
import {
  listKuaishouIndustryVouchersByOid,
  listKuaishouIndustryVouchersByOids,
  listKuaishouIndustryVouchersByTaskId,
} from '../../repositories/kuaishou-industry-voucher-repo.js'

import { createHttpError } from '../../utils/http.js'
import { formatFenToAmount, normalizeFen } from '../../utils/money.js'
import {
  normalizeDateQuery,
  normalizeDateString,
  normalizePage,
  normalizePageSize,
  safeParseJson,
} from './admin-query-utils.js'
import {
  canCompleteManualDispatchTaskStatus,
  canMarkManualReviewTaskStatus,
  canRetryTaskStatus,
} from '../../domain/task-status.js'
import { getAffiliateDashConfig } from '../platforms/affiliate-dash/config.js'
import { getDouyinMashidaSourceConfig } from '../platforms/douyin-mashida/source-config-service.js'
import { isDouyinMashidaProvider } from '../platforms/douyin-mashida/order-mapper.js'
import {
  mergeAffiliateDashSkuMapping,
  resolveAffiliateDashDisplayProductName,
} from '../platforms/affiliate-dash/sku-mapping.js'
import {
  canViewerCloseTask,
  canRegenerateClaimLinkForViewer,
  createAdminViewerContext,
  getTaskPrimaryClaimTokenId,
  isManualDispatchTask,
  mapKuaishouCloudFulfillmentContext,
  mapKuaishouCloudTaskStateProjection,
  mapManualDispatchContext,
  mapRedeemResolutionContext,
  parseTaskContext,
  parseTaskState,
  resolveAdminTaskScreenshotUrl,
  resolveDisplayShopName,
  resolveOrderItemDeliveryMode,
  resolveOrderItemMatchSku,
  resolveOrderItemSkuNick,
  resolveOrderItemTitle,
} from './admin-read-shared-helpers.js'
import { isRetiredFulfillmentExecutor } from '../fulfillment/executors/types.js'
import {
  mapAdminOrderListItem,
  normalizeOrderItemFulfillmentMode,
  resolveOrderFulfillmentSummary,
  summarizeOrderItems,
} from './admin-order-read-helpers.js'
import {
  listWorkOrdersByOrderId,
  listWorkOrdersByOrderIds,
} from '../../repositories/worker-platform/work-order-query-repo.js'
import {
  buildOrderFulfillmentProgress,
  getRequiredTask,
  mapAdminTaskEvent,
  mapAdminTaskListItem,
  mapAdminTaskSummary,
} from './admin-task-read-helpers.js'

import type {
  AdminOrderListResponse,
  AdminTaskListResponse,
} from '../../types/admin/read-models.js'
import type { AdminTaskDetailView } from '../../types/admin/task-detail.js'
import type {
  AdminEntityIdInput,
  AdminOrderListQueryInput,
  AdminTaskListQueryInput,
  AdminViewerSessionInput,
} from '../../types/admin/read-inputs.js'
import type { KuaishouIndustryVoucherRow, OrderRow, TaskRow } from '../../types/repository/rows.js'

export async function getAdminOrders(
  query: AdminOrderListQueryInput = {},
): Promise<AdminOrderListResponse> {
  const page = normalizePage(query.page)
  const pageSize = normalizePageSize(query.pageSize)
  const { items, total } = await listOrders({
    page,
    pageSize,
    keyword: String(query.keyword || '').trim(),
    provider: String(query.provider || '').trim(),
    executorKey: String(query.executorKey || '').trim(),
    fulfillmentMode: normalizeOrderFulfillmentModeFilter(query.fulfillmentMode),
    platformOrderId: String(query.platformOrderId || '').trim(),
    payStatus: String(query.payStatus || '').trim(),
    taskStatus: String(query.taskStatus || '').trim(),
    skuCode: String(query.skuCode || '').trim(),
    dateFrom: normalizeDateString(query.dateFrom),
    dateTo: normalizeDateString(query.dateTo),
  })

  const orderIds = items.map((item) => Number(item.id)).filter((id) => id > 0)
  const oids = items.map((item) => item.platform_order_id).filter(Boolean)
  const [orderItems, tasks, vouchers, workOrders, manualCounts] = await Promise.all([
    listOrderItemsByOrderIds(orderIds),
    listTasksByOrderIds(orderIds),
    listKuaishouIndustryVouchersByOids(oids),
    listWorkOrdersByOrderIds(orderIds),
    getManualFulfillmentCountsByOrderIds(orderIds),
  ])
  const orderItemsByOrderId = groupRowsByOrderId(orderItems)
  const tasksByOrderId = groupRowsByOrderId(tasks)
  const vouchersByOid = groupRowsByOid(vouchers)
  const workOrdersByOrderId = groupRowsByOrderId(workOrders)

  return {
    items: items.map((item) => {
      const orderId = Number(item.id)
      const orderTasks = tasksByOrderId.get(orderId) || []
      const orderVouchers = vouchersByOid.get(item.platform_order_id) || []
      const orderWorkOrders = workOrdersByOrderId.get(orderId) || []
      return mapAdminOrderListItem(item, {
        orderItems: orderItemsByOrderId.get(orderId) || [],
        tasks: orderTasks,
        vouchers: orderVouchers,
        workOrderCount: orderWorkOrders.length,
        manualConfig: manualCounts.get(orderId) || { pending: 0, unconfigured: 0 },
      })
    }),
    pagination: { page, pageSize, total },
  }
}

const ADMIN_ORDER_FULFILLMENT_MODES = new Set([
  'work_order',
  'affiliate_dash',
  'legacy_platform',
  'manual',
  'mixed',
  'pending',
])

function normalizeOrderFulfillmentModeFilter(value: unknown): string {
  const mode = String(value || '')
    .trim()
    .toLowerCase()
  return ADMIN_ORDER_FULFILLMENT_MODES.has(mode) ? mode : ''
}

function groupRowsByOrderId<T extends { order_id?: number | string | null }>(
  rows: T[],
): Map<number, T[]> {
  const grouped = new Map<number, T[]>()
  for (const row of rows) {
    // pg BIGINT 常以 string 返回；统一 Number 键，避免列表挂不上 order_items →「商品 0」。
    const orderId = Number(row.order_id)
    if (!Number.isFinite(orderId) || orderId <= 0) {
      continue
    }
    const group = grouped.get(orderId) || []
    group.push(row)
    grouped.set(orderId, group)
  }
  return grouped
}

function groupRowsByOid<T extends { oid: string }>(rows: T[]): Map<string, T[]> {
  const grouped = new Map<string, T[]>()
  for (const row of rows) {
    const group = grouped.get(row.oid) || []
    group.push(row)
    grouped.set(row.oid, group)
  }
  return grouped
}

export async function getAdminOrderDetail(
  orderId: AdminEntityIdInput,
  session: AdminViewerSessionInput | null = null,
): Promise<JsonRecord> {
  const order = await getOrderById(Number(orderId))

  if (!order) {
    throw createHttpError('订单不存在', {
      statusCode: 404,
      errorCode: 'admin_order_not_found',
    })
  }

  const [items, tasks, workOrders, refunds, manualCounts] = await Promise.all([
    listOrderItemsByOrderId(order.id),
    listTasksByOrderId(order.id),
    listWorkOrdersByOrderId(order.id),
    listOrderRefunds(order.id),
    getManualFulfillmentCountsByOrderIds([order.id]),
  ])
  const manualConfig = manualCounts.get(Number(order.id)) || { pending: 0, unconfigured: 0 }
  const kuaishouIndustryVouchers = await listKuaishouIndustryVouchersByOid(order.platform_order_id)
  const itemSummary = summarizeOrderItems(items, order, kuaishouIndustryVouchers)
  const orderItemTitle = resolveOrderItemTitle(items[0], order, kuaishouIndustryVouchers)
  const orderSkuNick = resolveOrderItemSkuNick(items[0], order, kuaishouIndustryVouchers)
  const viewerContext = createAdminViewerContext(session)
  const fulfillment = resolveOrderFulfillmentSummary({
    items,
    tasks,
    workOrderCount: workOrders.length,
    vouchers: kuaishouIndustryVouchers,
  })

  return {
    order: {
      orderId: order.id,
      provider: order.provider || '',
      platform: order.platform,
      shopId: order.shop_id || '',
      shopName: resolveDisplayShopName(order.provider, order.shop_id, order.shop_name),
      platformOrderId: order.platform_order_id,
      orderStatus: order.order_status,
      payStatus: order.pay_status,
      buyerId: order.buyer_id,
      buyerName: order.buyer_name,
      receiverContact: order.receiver_contact,
      totalAmount: formatFenToAmount(order.total_amount),
      totalAmountFen: normalizeFen(order.total_amount),
      currency: order.currency,
      paidAt: order.paid_at,
      createdAt: order.created_at,
      updatedAt: order.updated_at,
      itemSummary,
      itemTitle: orderItemTitle,
      skuNick: orderSkuNick,
      rawPayload:
        order.raw_payload_json && typeof order.raw_payload_json === 'object'
          ? order.raw_payload_json
          : JSON.parse(String(order.raw_payload_json || '{}')),
      fulfillmentProgress: buildOrderFulfillmentProgress(tasks),
      claimStatus: order.claim_status || 'active',
      claimStatusReason: order.claim_status_reason || '',
      claimStatusUpdatedAt: order.claim_status_updated_at || null,
      fulfillmentMode: fulfillment.fulfillmentMode,
      manualItemCount: fulfillment.manualItemCount,
      pendingItemCount: fulfillment.pendingItemCount,
      manualPendingCount: manualConfig.pending,
      manualUnconfiguredCount: manualConfig.unconfigured,
      hasVoucher: fulfillment.hasVoucher,
      voucherState: fulfillment.voucherState,
      workOrderCount: workOrders.length,
      canClaimH5: fulfillment.canClaimH5,
    },
    items: items.map((item) => {
      const revenueFen = Math.max(0, Number(item.revenue_amount_fen || 0))
      const refundedFen = refunds
        .filter((refund) => refund.status === 'confirmed' && refund.orderItemId === Number(item.id))
        .reduce((sum, refund) => sum + refund.amountFen, 0)
      return {
        orderItemId: Number(item.id),
        skuCode: item.sku_code,
        skuName: item.sku_name,
        itemTitle: resolveOrderItemTitle(item, order, kuaishouIndustryVouchers),
        skuNick: resolveOrderItemSkuNick(item, order, kuaishouIndustryVouchers),
        matchSku: resolveOrderItemMatchSku(item, order, kuaishouIndustryVouchers),
        quantity: item.quantity,
        revenueFen,
        refundedFen,
        refundableFen: Math.max(0, revenueFen - refundedFen),
        fulfillmentMode: normalizeOrderItemFulfillmentMode(item.fulfillment_mode),
        deliveryMode: resolveOrderItemDeliveryMode(tasks, item.id),
        spec:
          item.spec_json && typeof item.spec_json === 'object'
            ? item.spec_json
            : JSON.parse(String(item.spec_json || '{}')),
      }
    }),
    refunds,
    tasks: tasks.map((task) => mapAdminTaskSummary(task)),
    kuaishouIndustryVouchers: kuaishouIndustryVouchers.map(mapAdminKuaishouIndustryVoucher),
    operations: {
      canResendKuaishouIndustryVoucherCode:
        viewerContext.canOperateKuaishouIndustryVoucher && kuaishouIndustryVouchers.length > 0,
    },
  }
}

function mapAdminKuaishouIndustryVoucher(voucher: {
  voucher_code?: unknown
  oid?: unknown
  unit_index?: unknown
  status?: unknown
  send_callback_status?: unknown
  send_callback_attempt_count?: unknown
  send_callback_last_error?: unknown
  send_callback_sent_at?: unknown
  consume_serial_num?: unknown
  consume_details_json?: unknown
  consumed_at?: unknown
  destroyed_at?: unknown
}) {
  return {
    oid: String(voucher.oid || '').trim(),
    voucherCode: String(voucher.voucher_code || '').trim(),
    unitIndex: Number(voucher.unit_index || 0) || 0,
    status: String(voucher.status || '').trim(),
    sendCallbackStatus: String(voucher.send_callback_status || '').trim(),
    sendCallbackAttemptCount: Number(voucher.send_callback_attempt_count || 0) || 0,
    sendCallbackLastError: String(voucher.send_callback_last_error || '').trim(),
    sendCallbackSentAt: voucher.send_callback_sent_at || null,
    consumeSerialNum: String(voucher.consume_serial_num || '').trim(),
    consumeDetails: normalizeAdminJsonArray(voucher.consume_details_json),
    consumedAt: voucher.consumed_at || null,
    destroyedAt: voucher.destroyed_at || null,
  }
}

export async function getAdminTasks(
  query: AdminTaskListQueryInput = {},
  session: AdminViewerSessionInput | null = null,
): Promise<AdminTaskListResponse> {
  const page = normalizePage(query.page)
  const pageSize = normalizePageSize(query.pageSize)
  const { items, total } = await listTasks({
    page,
    pageSize,
    keyword: String(query.keyword || '').trim(),
    executorKey: String(query.executorKey || '').trim(),
    status: String(query.status || '').trim(),
    platformOrderId: String(query.platformOrderId || '').trim(),
    taskNo: String(query.taskNo || '').trim(),
    skuCode: String(query.skuCode || '').trim(),
    roleId: String(query.roleId || '').trim(),
    dateFrom: normalizeDateQuery(query.dateFrom),
    dateTo: normalizeDateQuery(query.dateTo, true),
  })
  const viewerContext = createAdminViewerContext(session)

  return {
    items: items.map((item) => mapAdminTaskListItem(item, viewerContext)),
    pagination: { page, pageSize, total },
  }
}

export async function getAdminTaskDetail(
  taskId: AdminEntityIdInput,
  session: AdminViewerSessionInput | null = null,
): Promise<AdminTaskDetailView> {
  const task = await getTaskById(Number(taskId))

  if (!task) {
    throw createHttpError('任务不存在', {
      statusCode: 404,
      errorCode: 'admin_task_not_found',
    })
  }

  const primaryClaimTokenId = getTaskPrimaryClaimTokenId(task)
  const [order, claimToken, taskEvents, taskKuaishouIndustryVouchers, oidKuaishouIndustryVouchers] =
    await Promise.all([
      getOrderById(task.order_id),
      primaryClaimTokenId ? getClaimTokenById(primaryClaimTokenId) : Promise.resolve(null),
      listTaskEventsByTaskId(task.id),
      listKuaishouIndustryVouchersByTaskId(task.id),
      task.platform_order_id
        ? listKuaishouIndustryVouchersByOid(task.platform_order_id)
        : Promise.resolve([]),
    ])
  const orderItems = order ? await listOrderItemsByOrderId(order.id) : []
  const orderItem = orderItems.find((item) => item.id === task.order_item_id) || null
  const taskContext = parseTaskContext(task)
  const taskState = parseTaskState(task)
  const viewerContext = createAdminViewerContext(session)
  // 后台回显的领取链接口径按**订单来源**决定（不再按 executor_key）：
  // 抖音码速达订单用后台配置的 `claimLinkBase`（买家领取页，走 affiliate_dash 领取流程）；
  // 其它来源沿用全局 buildClaimUrl（orders.claimBaseUrl）。
  const claimUrl = resolveAdminTaskClaimUrl(claimToken, order)
  const screenshotUrl = await resolveAdminTaskScreenshotUrl(task, viewerContext)
  const cloudSourceLabelMap = buildCloudSourceLabelMap()
  const kuaishouCloudFulfillment =
    mapKuaishouCloudFulfillmentContext(taskContext.kuaishouCloudFulfillment, {
      cloudSourceLabelMap,
    }) || mapKuaishouCloudTaskStateProjection(task, { cloudSourceLabelMap })
  const claimIdentity = buildClaimIdentityAdminSummary(taskContext, {
    flowLike: taskContext.kuaishouCloudFulfillment || taskContext.kuaishouFeifei || null,
    taskRoleId: task.role_id,
    taskRoleName: task.role_name,
  })
  const firstKuaishouIndustryVoucher = resolveKuaishouIndustryVoucherForTask(
    task,
    taskContext,
    taskKuaishouIndustryVouchers,
    oidKuaishouIndustryVouchers,
  )
  const kuaishouIndustryVoucher = firstKuaishouIndustryVoucher
    ? mapAdminKuaishouIndustryVoucher(firstKuaishouIndustryVoucher)
    : mapKuaishouIndustryVoucherContext(taskContext.kuaishouIndustryVoucher)
  const hasKuaishouIndustryVoucher = Boolean(
    kuaishouIndustryVoucher && String(kuaishouIndustryVoucher.voucherCode || '').trim(),
  )
  const kuaishouIndustryVoucherStatus = String(kuaishouIndustryVoucher?.status || '')
    .trim()
    .toUpperCase()
  const kuaishouIndustryVoucherSendCallbackStatus = String(
    kuaishouIndustryVoucher?.sendCallbackStatus || '',
  )
    .trim()
    .toLowerCase()

  return {
    task: mapAdminTaskListItem(
      {
        ...task,
        sku_code: orderItem?.sku_code || '',
        sku_name: orderItem?.sku_name || '',
        claim_token: claimToken?.token || '',
      },
      viewerContext,
    ),
    order: order
      ? {
          orderId: order.id,
          provider: order.provider || '',
          platform: order.platform,
          shopId: order.shop_id || '',
          shopName: order.shop_name || '',
          platformOrderId: order.platform_order_id,
          payStatus: order.pay_status,
          orderStatus: order.order_status,
          claimStatus: (order.claim_status as 'active' | 'paused' | 'closed') || 'active',
          claimStatusReason: order.claim_status_reason || null,
          claimStatusUpdatedAt: order.claim_status_updated_at || null,
        }
      : null,
    orderItem: orderItem
      ? {
          orderItemId: orderItem.id,
          skuCode: orderItem.sku_code,
          skuName: resolveAffiliateDashDisplayProductName(
            String(orderItem.sku_code || ''),
            String(orderItem.sku_name || ''),
            mergeAffiliateDashSkuMapping(getAffiliateDashConfig().skuMapping),
          ),
          quantity: orderItem.quantity,
        }
      : null,
    claimToken: claimToken
      ? {
          primaryClaimTokenId: claimToken.id,
          token: viewerContext.canViewSensitiveTaskData ? claimToken.token || '' : '',
          status: claimToken.status || '',
          expiredAt: claimToken.expired_at || '',
          claimUrl,
        }
      : null,
    artifacts: viewerContext.canViewSensitiveTaskData ? safeParseJson(task.artifacts_json) : {},
    screenshotUrl,
    review: {
      required: false,
      screenshotCapturedAt: String(taskState.reviewCapturedAt || '').trim() || null,
      roleId: String(taskState.reviewRoleId || '').trim() || '',
      roleName: String(taskState.reviewRoleName || '').trim() || '',
    },
    redeemResolution: mapRedeemResolutionContext(taskContext.redeemResolution),
    claimIdentity,
    kuaishouCloudFulfillment,
    kuaishouIndustryVoucher,
    manualDispatch: mapManualDispatchContext(taskContext.manualDispatch, viewerContext),
    affiliateDash: taskContext.affiliateDash || null,
    events: taskEvents.map(mapAdminTaskEvent),
    operations: {
      canRetry:
        viewerContext.canManageTaskLifecycle &&
        !isManualDispatchTask(task) &&
        !isRetiredFulfillmentExecutor(task.executor_key) &&
        canRetryTaskStatus(task.task_status),
      canRegenerateClaimLink: canRegenerateClaimLinkForViewer(task, viewerContext),
      canClose: canViewerCloseTask(task, viewerContext),
      canMarkManualReview:
        viewerContext.canManageTaskLifecycle && canMarkManualReviewTaskStatus(task.task_status),
      canCompleteManualDispatch:
        viewerContext.canManageTaskLifecycle &&
        (isManualDispatchTask(task) || isRetiredFulfillmentExecutor(task.executor_key)) &&
        canCompleteManualDispatchTaskStatus(task.task_status),
      canPrepareKuaishouCloudFulfillment: false,
      canRefreshKuaishouCloudRoleInfo: false,
      canRebindKuaishouCloudRole: false,
      canDispatchKuaishouCloudFulfillment: false,
      canReturnKuaishouCloudFulfillment: false,
      canResendKuaishouIndustryVoucherCode:
        viewerContext.canOperateKuaishouIndustryVoucher && hasKuaishouIndustryVoucher,
      canConsumeKuaishouIndustryVoucher:
        viewerContext.canOperateKuaishouIndustryVoucher &&
        hasKuaishouIndustryVoucher &&
        kuaishouIndustryVoucherStatus !== 'CONSUMED' &&
        kuaishouIndustryVoucherSendCallbackStatus === 'success',
      canViewSensitiveTaskData: viewerContext.canViewSensitiveTaskData,
    },
  }
}

/**
 * 后台展示的领取链接。
 *
 * - 抖音码速达订单（`provider='douyin_mashida'`）：`claimLinkBase` + token（买家领取页，
 *   走 affiliate_dash 领取流程）；未配 `claimLinkBase` 时退回全局 claim 链接，至少链接不会为空。
 * - 其它来源：沿用全局 `buildClaimUrl`（orders.claimBaseUrl），历史行为不变。
 *
 * ⚠️ 这里按 **provider** 判断，不按 executor_key：抖音皮肤单已改走 `affiliate_dash` 通道，
 * 按执行器判断会失效。拿不到 provider（order 为空）时按「其它来源」处理。
 */
function resolveAdminTaskClaimUrl(
  claimToken: { token: string } | null | undefined,
  order: Pick<OrderRow, 'provider'> | null | undefined,
): string {
  const token = String(claimToken?.token || '').trim()
  if (!token) {
    return ''
  }

  if (isDouyinMashidaProvider(order?.provider)) {
    const claimUrl = buildConfiguredClaimUrl(getDouyinMashidaSourceConfig().claimLinkBase, token)
    if (claimUrl) {
      return claimUrl
    }
  }

  return buildClaimUrl(token)
}

function mapKuaishouIndustryVoucherContext(value: unknown): JsonRecord | null {
  if (!value || typeof value !== 'object' || Array.isArray(value)) {
    return null
  }

  const record = value as JsonRecord
  return {
    oid: String(record.oid || '').trim(),
    voucherCode: String(record.voucherCode || record.eticketId || '').trim(),
    unitIndex: Number(record.unitIndex || 0) || 0,
    status: String(record.status || '').trim(),
    sendCallbackStatus: String(record.sendCallbackStatus || '').trim(),
    sendCallbackLastError: String(record.sendCallbackLastError || '').trim(),
    sendCallbackAttemptCount: Number(record.sendCallbackAttemptCount || 0) || 0,
    sendCallbackSentAt: record.sendCallbackSentAt || null,
    consumeSerialNum: String(record.consumeSerialNum || '').trim(),
    consumeDetails: normalizeAdminJsonArray(record.consumeDetails),
    consumedAt: record.consumedAt || null,
    destroyedAt: record.destroyedAt || null,
  }
}

function normalizeAdminJsonArray(value: unknown): JsonRecord[] {
  if (Array.isArray(value)) {
    return value.filter((item): item is JsonRecord =>
      Boolean(item && typeof item === 'object' && !Array.isArray(item)),
    )
  }

  try {
    const parsed = JSON.parse(String(value || '[]'))
    return Array.isArray(parsed)
      ? parsed.filter((item): item is JsonRecord =>
          Boolean(item && typeof item === 'object' && !Array.isArray(item)),
        )
      : []
  } catch {
    return []
  }
}

function resolveKuaishouIndustryVoucherForTask(
  task: TaskRow,
  taskContext: JsonRecord,
  taskVouchers: KuaishouIndustryVoucherRow[],
  oidVouchers: KuaishouIndustryVoucherRow[],
): KuaishouIndustryVoucherRow | null {
  const linkedVoucher = taskVouchers[0] || null
  if (linkedVoucher) {
    return linkedVoucher
  }

  const voucherContext =
    taskContext.kuaishouIndustryVoucher &&
    typeof taskContext.kuaishouIndustryVoucher === 'object' &&
    !Array.isArray(taskContext.kuaishouIndustryVoucher)
      ? (taskContext.kuaishouIndustryVoucher as JsonRecord)
      : {}
  const voucherCode = String(voucherContext.voucherCode || voucherContext.eticketId || '').trim()
  if (voucherCode) {
    const matchedByCode = oidVouchers.find(
      (voucher) => String(voucher.voucher_code || '').trim() === voucherCode,
    )
    if (matchedByCode) {
      return matchedByCode
    }
  }

  const unitIndex = Number(task.unit_index || 0) || 0
  if (unitIndex > 0) {
    const matchedByUnit = oidVouchers.find(
      (voucher) => Number(voucher.unit_index || 0) === unitIndex,
    )
    if (matchedByUnit) {
      return matchedByUnit
    }
  }

  return oidVouchers.length === 1 ? oidVouchers[0] || null : null
}

function buildCloudSourceLabelMap() {
  return new Map<string, string>()
}

export async function getAdminTaskScreenshotPath(
  taskId: AdminEntityIdInput,
  _session: AdminViewerSessionInput | null = null,
): Promise<string> {
  const task = await getRequiredTask(taskId)

  if (task.screenshot_path) {
    return task.screenshot_path
  }

  throw createHttpError('当前任务还没有可查看截图', {
    statusCode: 404,
    errorCode: 'admin_task_screenshot_not_found',
  })
}