import { randomUUID } from 'crypto'
import { prisma } from '@/lib/prisma'
import { getPublicAppOrigin } from '@/lib/public-app-url'
import { buildDingtalkEntryPath } from '@/lib/safe-redirect'
import {
  getDingtalkPerformanceSurveyNotificationChannelForUser,
  getDingtalkRobotOtoReadResult,
  getDingtalkWorkNoticeSendResult,
  sendDingtalkRobotOtoMessage,
  sendDingtalkWorkNotice,
} from '@/lib/dingtalk-client'
import {
  getYouyidianNotificationStatus,
  submitYouyidianNotification,
} from '@/lib/youyidian-notification-center'

const STATUS = {
  PENDING: 'pending',
  PROCESSING: 'processing',
  RETRYING: 'retrying',
  SUCCEEDED: 'succeeded',
  EXHAUSTED: 'exhausted',
  SKIPPED: 'skipped',
} as const

const MAX_ATTEMPTS = 5
const RETRY_DELAYS_MS = [0, 60_000, 5 * 60_000, 15 * 60_000, 30 * 60_000, 60 * 60_000]
const RECOVERY_INTERVAL_MS = 60_000
const REMINDER_INTERVAL_MS = 10 * 60_000
const STALE_PROCESSING_MS = 5 * 60_000
const READ_STATUS_REFRESH_MS = 5 * 60_000

const NOTIFICATION_PROVIDER = {
  WORK_NOTICE: 'work_notice',
  ROBOT_OTO: 'robot_oto',
  NOTIFICATION_CENTER: 'notification_center',
} as const

type NotificationProvider = typeof NOTIFICATION_PROVIDER[keyof typeof NOTIFICATION_PROVIDER]

let workerStarted = false
let recoveryTimer: NodeJS.Timeout | null = null
let reminderTimer: NodeJS.Timeout | null = null
const deliveryTimers = new Map<string, NodeJS.Timeout>()
let readStatusRefreshInFlight: Promise<number> | null = null
let missingAssignmentRecoveryInFlight: Promise<number> | null = null

type QueueNotificationInput = {
  surveyId?: string | null
  targetId?: string | null
  assignmentId?: string | null
  recipientEmployeeId?: string | null
  recipientUserId?: string | null
  dingtalkUserId?: string | null
  recipientName: string
  eventType: string
  businessKey: string
  title: string
  content: string
  actionUrl?: string | null
}

function truncateBody(value: string | null | undefined, limit = 2000) {
  const text = String(value || '')
  return text.length > limit ? text.slice(0, limit) : text
}

function getSurveyUrl(path: string) {
  return `${getPublicAppOrigin()}${buildDingtalkEntryPath(path)}`
}

function clean(value: unknown) {
  const normalized = String(value ?? '').trim()
  return normalized.length > 0 ? normalized : null
}

function escapeDingtalkMarkdown(value: unknown) {
  return String(value ?? '')
    .replace(/\\/g, '\\\\')
    .replace(/([`*_\[\]#>])/g, '\\$1')
    .trim()
}

function buildNotificationCard(input: {
  icon: string
  statusLabel: string
  surveyTitle: string
  fields: Array<{ label: string; value: string | null | undefined }>
  note?: string | null
}) {
  const fieldLines = input.fields
    .filter((field) => clean(field.value))
    .map((field) => `**${escapeDingtalkMarkdown(field.label)}：** ${escapeDingtalkMarkdown(field.value)}  `)

  return [
    `### ${input.icon} ${escapeDingtalkMarkdown(input.statusLabel)}`,
    '',
    `**${escapeDingtalkMarkdown(input.surveyTitle)}**`,
    '',
    ...fieldLines,
    input.note ? `\n> ${escapeDingtalkMarkdown(input.note)}` : null,
  ].filter((line): line is string => line !== null).join('\n').trim()
}

function getNotificationActionTitle(eventType: string) {
  if (eventType === 'survey.assignment.created') return '立即填写'
  if (eventType === 'survey.assignment.due_reminder') return '继续填写'
  if (eventType === 'survey.target.confirmation.required') return '确认并提交'
  if (eventType === 'survey.result.available') return '查看结果'
  if (eventType.startsWith('survey.creator.')) return '查看结果'
  return '查看详情'
}

async function resolveNotificationDingtalkUserId(notification: {
  dingtalkUserId?: string | null
  recipientUserId?: string | null
  recipientEmployeeId?: string | null
}) {
  const current = clean(notification.dingtalkUserId)
  if (current) return current

  const recipientUserId = clean(notification.recipientUserId)
  if (recipientUserId) {
    const user = await prisma.user.findUnique({
      where: { id: recipientUserId },
      select: { dingtalkUserId: true },
    })
    const userDingtalkUserId = clean(user?.dingtalkUserId)
    if (userDingtalkUserId) return userDingtalkUserId
  }

  const recipientEmployeeId = clean(notification.recipientEmployeeId)
  if (!recipientEmployeeId) return null

  const employee = await prisma.performanceSurveyEmployeeProfile.findUnique({
    where: { id: recipientEmployeeId },
    select: { dingtalkUserId: true, dingEmail: true },
  })
  const employeeDingtalkUserId = clean(employee?.dingtalkUserId)
  if (employeeDingtalkUserId) return employeeDingtalkUserId

  const email = clean(employee?.dingEmail)
  if (!email) return null

  const user = await prisma.user.findFirst({
    where: { email },
    select: { dingtalkUserId: true },
  })
  return clean(user?.dingtalkUserId)
}

export function ensurePerformanceSurveyNotificationWorkerStarted() {
  if (workerStarted) return
  workerStarted = true

  const bootstrap = setTimeout(() => {
    void recoverDuePerformanceSurveyNotifications()
    void recoverMissingSurveyAssignmentNotifications()
    void queueDuePerformanceSurveyReminders()
    void refreshPerformanceSurveyNotificationReadStatuses()
  }, 1000)
  bootstrap.unref?.()

  recoveryTimer = setInterval(() => {
    void recoverDuePerformanceSurveyNotifications()
    void recoverMissingSurveyAssignmentNotifications()
    void refreshPerformanceSurveyNotificationReadStatuses()
  }, RECOVERY_INTERVAL_MS)
  recoveryTimer.unref?.()

  reminderTimer = setInterval(() => {
    void queueDuePerformanceSurveyReminders()
  }, REMINDER_INTERVAL_MS)
  reminderTimer.unref?.()
}

function scheduleNotificationProcessing(notificationId: string, delayMs: number) {
  const existing = deliveryTimers.get(notificationId)
  if (existing) {
    clearTimeout(existing)
  }

  const timer = setTimeout(() => {
    deliveryTimers.delete(notificationId)
    void processPerformanceSurveyNotification(notificationId)
  }, Math.max(0, delayMs))
  timer.unref?.()
  deliveryTimers.set(notificationId, timer)
}

export async function queuePerformanceSurveyNotification(input: QueueNotificationInput) {
  ensurePerformanceSurveyNotificationWorkerStarted()

  const existing = await prisma.performanceSurveyNotification.findUnique({
    where: {
      eventType_businessKey: {
        eventType: input.eventType,
        businessKey: input.businessKey,
      },
    },
  })

  if (existing) {
    return existing.id
  }

  const created = await prisma.performanceSurveyNotification.create({
    data: {
      id: randomUUID(),
      surveyId: input.surveyId || null,
      targetId: input.targetId || null,
      assignmentId: input.assignmentId || null,
      recipientEmployeeId: input.recipientEmployeeId || null,
      recipientUserId: input.recipientUserId || null,
      dingtalkUserId: input.dingtalkUserId || null,
      recipientName: input.recipientName,
      eventType: input.eventType,
      businessKey: input.businessKey,
      title: input.title,
      content: input.content,
      actionUrl: input.actionUrl || null,
      status: STATUS.PENDING,
      maxAttempts: MAX_ATTEMPTS,
      nextRetryAt: new Date(),
    },
    select: { id: true },
  })

  scheduleNotificationProcessing(created.id, 0)
  return created.id
}

export async function queueSurveyAssignmentNotifications(surveyId: string) {
  const survey = await prisma.performanceSurvey.findUnique({
    where: { id: surveyId },
    include: {
      assignments: {
        include: { target: true, evaluatorEmployee: true },
      },
    },
  })

  if (!survey || survey.status === 'cancelled') return []

  const selfCompletedTargetIds = new Set(
    survey.assignments
      .filter((assignment) => {
        const snapshot = assignment.evaluatorSnapshot as Record<string, unknown> | null
        return ['self', 'self_visual_final'].includes(String(snapshot?.performanceSurveyWorkflowRole || ''))
          && assignment.status === 'submitted'
      })
      .map((assignment) => assignment.targetId),
  )

  const ids: string[] = []
  for (const assignment of survey.assignments) {
    if (assignment.status !== 'pending') continue
    const workflowStageKey = clean(assignment.workflowStageKey)
    const isConfiguredWorkflow = Boolean(workflowStageKey && workflowStageKey !== 'legacy')
    if (isConfiguredWorkflow && !assignment.releasedAt) continue
    const snapshot = assignment.evaluatorSnapshot as Record<string, unknown> | null
    const workflowRole = snapshot?.performanceSurveyWorkflowRole
    if (
      !isConfiguredWorkflow &&
      survey.templateCode === 'visual_brand_tone' &&
      !['self', 'self_visual_final'].includes(String(workflowRole || '')) &&
      !selfCompletedTargetIds.has(assignment.targetId)
    ) continue
    const isVisualSelfAssignment = isConfiguredWorkflow
      ? assignment.reviewerSource === 'self'
      : survey.templateCode === 'visual_brand_tone'
        && ['self', 'self_visual_final'].includes(String(workflowRole || ''))
    const targetName = assignment.target.targetName
    ids.push(
      await queuePerformanceSurveyNotification({
        surveyId: survey.id,
        targetId: assignment.targetId,
        assignmentId: assignment.id,
        recipientEmployeeId: assignment.evaluatorEmployeeId,
        recipientUserId: assignment.evaluatorUserId,
        dingtalkUserId: assignment.evaluatorDingtalkUserId,
        recipientName: assignment.evaluatorName,
        eventType: 'survey.assignment.created',
        businessKey: `assignment:${assignment.id}`,
        title: '考核调研',
        content: buildNotificationCard({
          icon: '◆',
          statusLabel: '待填写',
          surveyTitle: survey.title,
          fields: [
            { label: '评价对象', value: targetName },
            { label: '截止时间', value: formatDateTime(survey.dueAt) },
          ],
          note: isVisualSelfAssignment
            ? isConfiguredWorkflow
              ? '请先完成当前阶段；提交后系统会自动开放后续评审'
              : '请先完成自评；提交后系统才会通知主管和终审人评分'
            : '请在截止时间前完成评分',
        }),
        actionUrl: getSurveyUrl(`/performance-survey/survey/${survey.id}?targetId=${assignment.targetId}`),
      }),
    )
  }

  return ids
}

export async function recoverMissingSurveyAssignmentNotifications(limit = 20) {
  ensurePerformanceSurveyNotificationWorkerStarted()
  if (missingAssignmentRecoveryInFlight) return missingAssignmentRecoveryInFlight

  missingAssignmentRecoveryInFlight = (async () => {
    const rows = await prisma.performanceSurveyAssignment.findMany({
      where: {
        status: 'pending',
        survey: { status: 'open' },
        notifications: {
          none: { eventType: 'survey.assignment.created' },
        },
        OR: [
          {
            AND: [
              { workflowStageKey: { not: 'legacy' } },
              { releasedAt: { not: null } },
            ],
          },
          {
            AND: [
              { workflowStageKey: 'legacy' },
              {
                OR: [
                  { survey: { templateCode: { not: 'visual_brand_tone' } } },
                  { evaluatorSnapshot: { path: ['performanceSurveyWorkflowRole'], equals: 'self' } },
                  { evaluatorSnapshot: { path: ['performanceSurveyWorkflowRole'], equals: 'self_visual_final' } },
                  {
                    target: {
                      assignments: {
                        some: {
                          status: 'submitted',
                          OR: [
                            { evaluatorSnapshot: { path: ['performanceSurveyWorkflowRole'], equals: 'self' } },
                            { evaluatorSnapshot: { path: ['performanceSurveyWorkflowRole'], equals: 'self_visual_final' } },
                          ],
                        },
                      },
                    },
                  },
                ],
              },
            ],
          },
        ],
      } as any,
      select: { surveyId: true },
      distinct: ['surveyId'],
      take: limit,
    })

    let queuedCount = 0
    for (const surveyId of Array.from(new Set(rows.map((row) => row.surveyId)))) {
      queuedCount += (await queueSurveyAssignmentNotifications(surveyId)).length
    }
    return queuedCount
  })()

  try {
    return await missingAssignmentRecoveryInFlight
  } finally {
    missingAssignmentRecoveryInFlight = null
  }
}

export async function queueSurveyTargetConfirmationNotifications(surveyId: string) {
  const survey = await prisma.performanceSurvey.findUnique({
    where: { id: surveyId },
    include: {
      targets: {
        include: { employeeProfile: true },
      },
    },
  })

  if (!survey || survey.status === 'cancelled') return []

  const creator = await prisma.user.findUnique({
    where: { id: survey.creatorUserId },
    select: { email: true, dingtalkUserId: true },
  })
  const creatorDingtalkUserId = clean(creator?.dingtalkUserId)
  const creatorEmail = clean(creator?.email)?.toLowerCase() || null
  const visualTemplate = survey.templateSnapshot as { surveyType?: string; requiredWorkItemCount?: number } | null
  const isVisualSurvey = visualTemplate?.surveyType === 'visual_case'
    || (!survey.positionGroupId && !survey.templateVersionId && survey.templateCode === 'visual_brand_tone')
  const requiredWorkItemCount = Math.max(1, Number(visualTemplate?.requiredWorkItemCount || 3))
  const ids: string[] = []

  for (const target of survey.targets) {
    if (target.targetType !== 'employee' || !target.employeeProfile) continue

    const targetDingtalkUserId = clean(target.employeeProfile.dingtalkUserId)
    const targetEmail = clean(target.employeeProfile.dingEmail)?.toLowerCase() || null
    const isCreator = Boolean(
      (survey.creatorEmployeeId && survey.creatorEmployeeId === target.employeeProfileId)
      || (creatorDingtalkUserId && creatorDingtalkUserId === targetDingtalkUserId)
      || (creatorEmail && creatorEmail === targetEmail),
    )
    if (isCreator) continue

    ids.push(
      await queuePerformanceSurveyNotification({
        surveyId: survey.id,
        targetId: target.id,
        recipientEmployeeId: target.employeeProfileId,
        dingtalkUserId: targetDingtalkUserId,
        recipientName: target.targetName,
        eventType: 'survey.target.confirmation.required',
        businessKey: `target-confirmation:${survey.id}:${target.id}`,
        title: '考核调研',
        content: buildNotificationCard({
          icon: isVisualSurvey ? '🖼️' : '📋',
          statusLabel: isVisualSurvey ? '待提交' : '待确认',
          surveyTitle: survey.title,
          fields: [
            { label: '发起人', value: survey.creatorName },
            { label: '被考核人', value: target.targetName },
            { label: '考核月份', value: formatAssessmentMonth(survey.assessmentMonth, survey.createdAt) },
            isVisualSurvey
              ? { label: '作品要求', value: `${requiredWorkItemCount} 个案例作品` }
              : { label: '确认事项', value: '被考核人信息' },
          ],
          note: '如信息有误，请联系发起人',
        }),
        actionUrl: getSurveyUrl(
          isVisualSurvey
            ? `/performance-survey/survey/${survey.id}?targetId=${target.id}`
            : '/performance-survey?tab=personal',
        ),
      }),
    )
  }

  return ids
}

export async function queueSurveyResultNotifications(surveyId: string) {
  const survey = await prisma.performanceSurvey.findUnique({
    where: { id: surveyId },
    include: {
      targets: { include: { employeeProfile: true } },
    },
  })

  if (!survey || survey.status === 'cancelled') return []

  const ids: string[] = []
  for (const target of survey.targets) {
    if (target.targetType !== 'employee' || !target.employeeProfile) continue
    ids.push(
      await queuePerformanceSurveyNotification({
        surveyId: survey.id,
        targetId: target.id,
        recipientEmployeeId: target.employeeProfileId,
        dingtalkUserId: target.employeeProfile.dingtalkUserId,
        recipientName: target.targetName,
        eventType: 'survey.result.available',
        businessKey: `result:${survey.id}:${target.id}`,
        title: '考核调研',
        content: buildNotificationCard({
          icon: '📊',
          statusLabel: '已生成',
          surveyTitle: survey.title,
          fields: [{ label: '评价对象', value: target.targetName }],
          note: '点击下方按钮查看完整结果',
        }),
        actionUrl: getSurveyUrl(`/performance-survey/results/${survey.id}?targetId=${target.id}`),
      }),
    )
  }

  return ids
}

export async function queueSurveyCreatorNotification(surveyId: string, eventType = 'survey.creator.completed') {
  const survey = await prisma.performanceSurvey.findUnique({
    where: { id: surveyId },
    include: {
      assignments: true,
    },
  })

  if (!survey || survey.status === 'cancelled') return null

  const creator = await prisma.user.findUnique({
    where: { id: survey.creatorUserId },
    select: { id: true, username: true, realName: true, dingtalkUserId: true },
  })

  const total = survey.assignments.length
  const submitted = survey.assignments.filter((assignment) => assignment.status === 'submitted').length

  return queuePerformanceSurveyNotification({
    surveyId: survey.id,
    recipientUserId: creator?.id || survey.creatorUserId,
    dingtalkUserId: creator?.dingtalkUserId || null,
    recipientName: creator?.realName || creator?.username || survey.creatorName,
    eventType,
    businessKey: `${eventType}:${survey.id}`,
    title: '考核调研',
    content: buildNotificationCard({
      icon: eventType === 'survey.creator.closed' ? '⏹️' : '✅',
      statusLabel: eventType === 'survey.creator.closed' ? '已关闭' : '已完成',
      surveyTitle: survey.title,
      fields: [{ label: '提交进度', value: `${submitted}/${total}` }],
      note: '点击下方按钮查看调研结果',
    }),
    actionUrl: getSurveyUrl(`/performance-survey/results/${survey.id}`),
  })
}

export async function queueDuePerformanceSurveyReminders() {
  ensurePerformanceSurveyNotificationWorkerStarted()

  const now = new Date()
  const before = new Date(Date.now() + 24 * 60 * 60 * 1000)
  const surveys = await prisma.performanceSurvey.findMany({
    where: {
      status: 'open',
      dueAt: {
        gt: now,
        lte: before,
      },
    },
    include: {
      assignments: {
        where: {
          status: 'pending',
          OR: [{ workflowStageKey: 'legacy' }, { releasedAt: { not: null } }],
        },
        include: { target: true },
      },
    },
  })

  const ids: string[] = []
  for (const survey of surveys) {
    const dueKey = survey.dueAt ? survey.dueAt.toISOString().slice(0, 10) : 'no-date'
    for (const assignment of survey.assignments) {
      ids.push(
        await queuePerformanceSurveyNotification({
          surveyId: survey.id,
          targetId: assignment.targetId,
          assignmentId: assignment.id,
          recipientEmployeeId: assignment.evaluatorEmployeeId,
          recipientUserId: assignment.evaluatorUserId,
          dingtalkUserId: assignment.evaluatorDingtalkUserId,
          recipientName: assignment.evaluatorName,
          eventType: 'survey.assignment.due_reminder',
          businessKey: `due:${dueKey}:${assignment.id}`,
          title: '考核调研',
          content: buildNotificationCard({
            icon: '⏰',
            statusLabel: '即将截止',
            surveyTitle: survey.title,
            fields: [
              { label: '评价对象', value: assignment.target.targetName },
              { label: '截止时间', value: formatDateTime(survey.dueAt) },
            ],
            note: '请尽快完成评分，避免错过截止时间',
          }),
          actionUrl: getSurveyUrl(`/performance-survey/survey/${survey.id}?targetId=${assignment.targetId}`),
        }),
      )
    }
  }

  return ids
}

export async function recoverDuePerformanceSurveyNotifications(limit = 20) {
  ensurePerformanceSurveyNotificationWorkerStarted()

  await prisma.performanceSurveyNotification.updateMany({
    where: {
      status: STATUS.PROCESSING,
      updatedAt: { lte: new Date(Date.now() - STALE_PROCESSING_MS) },
    },
    data: {
      status: STATUS.RETRYING,
      nextRetryAt: new Date(),
      lastError: '上次投递处理中断，已重新入队',
    },
  })

  const rows = await prisma.performanceSurveyNotification.findMany({
    where: {
      status: { in: [STATUS.PENDING, STATUS.RETRYING] },
      OR: [{ nextRetryAt: null }, { nextRetryAt: { lte: new Date() } }],
    },
    select: { id: true },
    orderBy: { createdAt: 'asc' },
    take: limit,
  })

  rows.forEach((row) => scheduleNotificationProcessing(row.id, 0))
  return rows.length
}

export async function retryPerformanceSurveyNotification(notificationId: string) {
  ensurePerformanceSurveyNotificationWorkerStarted()

  await prisma.performanceSurveyNotification.update({
    where: { id: notificationId },
    data: {
      status: STATUS.PENDING,
      nextRetryAt: new Date(),
      completedAt: null,
      attemptCount: 0,
      maxAttempts: MAX_ATTEMPTS,
      lastStatusCode: null,
      lastResponseBody: null,
      lastError: null,
      providerMessageId: null,
      readStatus: 'unknown',
      readAt: null,
      readStatusCheckedAt: null,
      sentAt: null,
    },
  })

  scheduleNotificationProcessing(notificationId, 0)
}

export async function processPerformanceSurveyNotification(notificationId: string) {
  ensurePerformanceSurveyNotificationWorkerStarted()

  const notification = await prisma.performanceSurveyNotification.findUnique({
    where: { id: notificationId },
    include: { survey: { select: { status: true } } },
  })

  if (!notification) return null
  if (![STATUS.PENDING, STATUS.RETRYING, STATUS.PROCESSING].includes(notification.status as any)) {
    return null
  }
  if (notification.survey?.status === 'cancelled') {
    await prisma.performanceSurveyNotification.update({
      where: { id: notificationId },
      data: {
        status: STATUS.SKIPPED,
        nextRetryAt: null,
        completedAt: new Date(),
        lastError: '调研已撤销，通知不再发送',
      },
    })
    return { success: false, status: STATUS.SKIPPED }
  }

  await prisma.performanceSurveyNotification.update({
    where: { id: notificationId },
    data: {
      status: STATUS.PROCESSING,
      updatedAt: new Date(),
    },
  })

  const resolvedDingtalkUserId = await resolveNotificationDingtalkUserId(notification)
  if (!resolvedDingtalkUserId) {
    await prisma.performanceSurveyNotification.update({
      where: { id: notificationId },
      data: {
        status: STATUS.SKIPPED,
        lastError: '收件人缺少钉钉 userId',
        completedAt: new Date(),
      },
    })
    return { success: false, status: STATUS.SKIPPED }
  }

  if (resolvedDingtalkUserId !== notification.dingtalkUserId) {
    await prisma.performanceSurveyNotification.update({
      where: { id: notificationId },
      data: {
        dingtalkUserId: resolvedDingtalkUserId,
        updatedAt: new Date(),
      },
    })
  }

  try {
    const providerType: NotificationProvider = getDingtalkPerformanceSurveyNotificationChannelForUser(
      resolvedDingtalkUserId,
    )
    const input = {
      userIds: [resolvedDingtalkUserId],
      title: notification.title,
      text: notification.content,
      actionUrl: notification.actionUrl,
      actionTitle: getNotificationActionTitle(notification.eventType),
    }
    const result = providerType === NOTIFICATION_PROVIDER.NOTIFICATION_CENTER
      ? await submitYouyidianNotification({
          idempotencyKey: `${notification.eventType}:${notification.businessKey}`,
          recipientUserId: resolvedDingtalkUserId,
          title: notification.title,
          content: notification.content,
          actionUrl: notification.actionUrl || '',
          actionTitle: getNotificationActionTitle(notification.eventType),
        })
      : providerType === NOTIFICATION_PROVIDER.ROBOT_OTO
        ? await sendDingtalkRobotOtoMessage(input)
        : await sendDingtalkWorkNotice(input)

    if ('skipped' in result && result.skipped) {
      await prisma.performanceSurveyNotification.update({
        where: { id: notificationId },
        data: {
          status: STATUS.SKIPPED,
          lastError: result.reason || '钉钉通知未发送',
          completedAt: new Date(),
        },
      })
      return { success: false, status: STATUS.SKIPPED }
    }

    await prisma.performanceSurveyNotification.update({
      where: { id: notificationId },
      data: {
        status: STATUS.SUCCEEDED,
        attemptCount: { increment: 1 },
        providerType,
        providerMessageId: providerType === NOTIFICATION_PROVIDER.NOTIFICATION_CENTER
          ? ('id' in result ? result.id || null : null)
          : providerType === NOTIFICATION_PROVIDER.ROBOT_OTO
            ? ('processQueryKey' in result ? result.processQueryKey || null : null)
            : ('taskId' in result ? result.taskId || result.requestId || null : null),
        readStatus: 'unknown',
        readAt: null,
        readStatusCheckedAt: null,
        lastStatusCode: 200,
        lastResponseBody: truncateBody(JSON.stringify(result.raw || result)),
        lastError: null,
        sentAt: new Date(),
        completedAt: new Date(),
        nextRetryAt: null,
      },
    })

    return { success: true, status: STATUS.SUCCEEDED }
  } catch (error) {
    const nextAttempt = notification.attemptCount + 1
    const exhausted = nextAttempt >= notification.maxAttempts
    const retryDelayMs = RETRY_DELAYS_MS[Math.min(nextAttempt, RETRY_DELAYS_MS.length - 1)]
    const nextRetryAt = new Date(Date.now() + retryDelayMs)

    await prisma.performanceSurveyNotification.update({
      where: { id: notificationId },
      data: {
        status: exhausted ? STATUS.EXHAUSTED : STATUS.RETRYING,
        attemptCount: { increment: 1 },
        lastError: error instanceof Error ? error.message : '钉钉通知发送失败',
        nextRetryAt: exhausted ? null : nextRetryAt,
        completedAt: exhausted ? new Date() : null,
      },
    })

    if (!exhausted) {
      scheduleNotificationProcessing(notificationId, retryDelayMs)
    }

    return { success: false, status: exhausted ? STATUS.EXHAUSTED : STATUS.RETRYING }
  }
}

export function refreshPerformanceSurveyNotificationReadStatuses(limit = 20) {
  if (readStatusRefreshInFlight) return readStatusRefreshInFlight
  readStatusRefreshInFlight = refreshPerformanceSurveyNotificationReadStatusesInternal(limit)
    .finally(() => {
      readStatusRefreshInFlight = null
    })
  return readStatusRefreshInFlight
}

async function refreshPerformanceSurveyNotificationReadStatusesInternal(limit = 20) {
  const staleBefore = new Date(Date.now() - READ_STATUS_REFRESH_MS)
  const notifications = await prisma.performanceSurveyNotification.findMany({
    where: {
      status: STATUS.SUCCEEDED,
      providerMessageId: { not: null },
      readStatus: { in: ['unknown', 'unread'] },
      OR: [
        { readStatusCheckedAt: null },
        { readStatusCheckedAt: { lte: staleBefore } },
      ],
    },
    select: {
      id: true,
      providerType: true,
      providerMessageId: true,
      dingtalkUserId: true,
    },
    orderBy: { sentAt: 'asc' },
    take: Math.max(1, Math.min(limit, 100)),
  })

  let refreshed = 0
  for (const notification of notifications) {
    const providerMessageId = clean(notification.providerMessageId)
    const recipientDingtalkUserId = clean(notification.dingtalkUserId)
    if (!providerMessageId || !recipientDingtalkUserId) continue

    try {
      const providerType = notification.providerType === NOTIFICATION_PROVIDER.NOTIFICATION_CENTER
        ? NOTIFICATION_PROVIDER.NOTIFICATION_CENTER
        : notification.providerType === NOTIFICATION_PROVIDER.ROBOT_OTO
          ? NOTIFICATION_PROVIDER.ROBOT_OTO
          : NOTIFICATION_PROVIDER.WORK_NOTICE
      let read = false
      let unread = false
      let deliveryFailed = false
      if (providerType === NOTIFICATION_PROVIDER.NOTIFICATION_CENTER) {
        const result = await getYouyidianNotificationStatus(providerMessageId)
        read = result.status === 'read'
        unread = result.status === 'unread'
        deliveryFailed = result.status === 'failed'
      } else if (providerType === NOTIFICATION_PROVIDER.ROBOT_OTO) {
        const result = await getDingtalkRobotOtoReadResult(providerMessageId)
        read = result.readUserIds.includes(recipientDingtalkUserId)
        unread = result.unreadUserIds.includes(recipientDingtalkUserId)
        deliveryFailed = result.deliveryFailed
      } else {
        const result = await getDingtalkWorkNoticeSendResult(providerMessageId)
        read = result.readUserIds.includes(recipientDingtalkUserId)
        unread = result.unreadUserIds.includes(recipientDingtalkUserId)
        deliveryFailed = [
          ...result.failedUserIds,
          ...result.invalidUserIds,
          ...result.forbiddenUserIds,
        ].includes(recipientDingtalkUserId)
      }
      const checkedAt = new Date()

      await prisma.performanceSurveyNotification.update({
        where: { id: notification.id },
        data: {
          readStatus: read ? 'read' : unread ? 'unread' : deliveryFailed ? 'delivery_failed' : 'unknown',
          readAt: read ? checkedAt : null,
          readStatusCheckedAt: checkedAt,
        },
      })
      refreshed += 1
    } catch {
      await prisma.performanceSurveyNotification.update({
        where: { id: notification.id },
        data: { readStatusCheckedAt: new Date() },
      })
    }
  }

  return refreshed
}

function formatDateTime(value: Date | string | null | undefined) {
  if (!value) return ''
  const date = new Date(value)
  if (Number.isNaN(date.getTime())) return ''
  const hour = String(date.getHours()).padStart(2, '0')
  const minute = String(date.getMinutes()).padStart(2, '0')
  return `${date.getMonth() + 1}月${date.getDate()}日 ${hour}:${minute}`
}

function formatAssessmentMonth(value: string | null | undefined, fallback: Date | string) {
  const normalized = String(value || '').trim()
  const match = normalized.match(/^(\d{4})-(\d{2})$/)
  if (match) return `${match[1]}年${Number(match[2])}月`

  const date = new Date(fallback)
  if (Number.isNaN(date.getTime())) return '-'
  return `${date.getFullYear()}年${date.getMonth() + 1}月`
}