import type { Request } from 'express'
import { Router } from 'express'

import { getAdminTaskDetail, getAdminTasks } from '../../services/admin/admin-read-service.js'
import {
  closeAdminTask,
  completeAdminTaskManualDispatch,
  markAdminTaskManualReview,
  regenerateAdminTaskClaimLink,
  retryAdminTask,
} from '../../services/admin/write/task-actions.js'
import {
  consumeAdminTaskKuaishouIndustryVoucher,
  resendAdminTaskKuaishouIndustryVoucherCode,
} from '../../services/admin/write/kuaishou-industry-actions.js'
import { createJsonHandler, requireAdminRoles } from './session.js'
import type {
  AdminTaskKuaishouIndustryConsumeRouteBody,
  AdminTaskManualDispatchRouteBody,
  AdminTaskRouteParams,
  AdminTaskRouteQuery,
} from '../../types/admin/route-inputs.js'
import type {
  AdminTaskActionResponse,
  AdminTaskManualDispatchResponse,
} from '../../types/admin/write-models.js'

const router = Router()

router.use('/tasks', requireAdminRoles(['admin', 'operator', 'support']))

function getTaskId(req: Request): string {
  return String((req.params as AdminTaskRouteParams).taskId || '')
}

router.get(
  '/tasks',
  createJsonHandler(
    (req) => getAdminTasks(req.query as AdminTaskRouteQuery, req.adminSession || null),
    {
      successMessage: 'ok',
      errorMessage: '读取任务列表失败',
      scope: '[admin/tasks]',
    },
  ),
)

router.get(
  '/tasks/:taskId',
  createJsonHandler((req) => getAdminTaskDetail(getTaskId(req), req.adminSession || null), {
    successMessage: 'ok',
    errorMessage: '读取任务详情失败',
    scope: '[admin/tasks/:taskId]',
  }),
)

router.post(
  '/tasks/:taskId/retry',
  requireAdminRoles(['admin', 'operator']),
  createJsonHandler((req) => retryAdminTask(getTaskId(req), req.adminSession || null), {
    successMessage: '任务已重试',
    errorMessage: '重试任务失败',
    scope: '[admin/tasks/:taskId/retry]',
    audit: (req, data) => buildTaskAudit('task_retry', req, data),
  }),
)

router.post(
  '/tasks/:taskId/regenerate-claim-link',
  requireAdminRoles(['admin', 'operator', 'support']),
  createJsonHandler(
    (req) => regenerateAdminTaskClaimLink(getTaskId(req), req.adminSession || null),
    {
      successMessage: '领取链接已重新生成',
      errorMessage: '重新生成领取链接失败',
      scope: '[admin/tasks/:taskId/regenerate-claim-link]',
      audit: (req, data) => buildTaskAudit('task_regenerate_claim_link', req, data),
    },
  ),
)

router.post(
  '/tasks/:taskId/close',
  requireAdminRoles(['admin', 'operator', 'support']),
  createJsonHandler((req) => closeAdminTask(getTaskId(req), req.adminSession || null), {
    successMessage: '任务已关闭',
    errorMessage: '关闭任务失败',
    scope: '[admin/tasks/:taskId/close]',
    audit: (req, data) => buildTaskAudit('task_closed', req, data),
  }),
)

router.post(
  '/tasks/:taskId/mark-manual-review',
  requireAdminRoles(['admin', 'operator']),
  createJsonHandler((req) => markAdminTaskManualReview(getTaskId(req), req.adminSession || null), {
    successMessage: '任务已转人工处理',
    errorMessage: '标记人工处理失败',
    scope: '[admin/tasks/:taskId/mark-manual-review]',
    audit: (req, data) => buildTaskAudit('task_mark_manual_review', req, data),
  }),
)

router.post(
  '/tasks/:taskId/complete-manual-dispatch',
  requireAdminRoles(['admin', 'operator']),
  createJsonHandler(
    (req) =>
      completeAdminTaskManualDispatch(
        getTaskId(req),
        req.body as AdminTaskManualDispatchRouteBody,
        req.adminSession || null,
      ),
    {
      successMessage: '人工履约结果已回写',
      errorMessage: '回写人工履约结果失败',
      scope: '[admin/tasks/:taskId/complete-manual-dispatch]',
      audit: (req, data) => {
        const result = data as AdminTaskManualDispatchResponse
        return {
          action: 'task_complete_manual_dispatch',
          targetType: 'task',
          targetId: String(getTaskId(req)),
          data: {
            taskId: result.task.taskId,
            taskNo: result.task.taskNo,
            outcome: result.outcome,
            deliveryStatus: result.task.deliveryStatus,
            resultCode: result.task.resultCode,
          },
        }
      },
    },
  ),
)

router.post(
  '/tasks/:taskId/kuaishou-industry/resend-code',
  requireAdminRoles(['admin', 'operator', 'support']),
  createJsonHandler(
    (req) => resendAdminTaskKuaishouIndustryVoucherCode(getTaskId(req), req.adminSession || null),
    {
      successMessage: '电子凭证发码回调已重发',
      errorMessage: '重发电子凭证发码回调失败',
      scope: '[admin/tasks/:taskId/kuaishou-industry/resend-code]',
      audit: (req, data) => buildTaskAudit('task_kuaishou_industry_resend_code', req, data),
    },
  ),
)

router.post(
  '/tasks/:taskId/kuaishou-industry/consume',
  requireAdminRoles(['admin', 'operator', 'support']),
  createJsonHandler(
    (req) =>
      consumeAdminTaskKuaishouIndustryVoucher(
        getTaskId(req),
        req.body as AdminTaskKuaishouIndustryConsumeRouteBody,
        req.adminSession || null,
      ),
    {
      successMessage: '电子凭证已执行核销',
      errorMessage: '执行电子凭证核销失败',
      scope: '[admin/tasks/:taskId/kuaishou-industry/consume]',
      audit: (req, data) => buildTaskAudit('task_kuaishou_industry_consume', req, data),
    },
  ),
)

function buildTaskAudit(action: string, req: Request, data: unknown) {
  const result = data as AdminTaskActionResponse

  return {
    action,
    targetType: 'task',
    targetId: String(getTaskId(req)),
    data: {
      taskId: result.task.taskId,
      taskNo: result.task.taskNo,
      status: result.task.status,
    },
  }
}

export default router