import { BadRequestException, forwardRef, HttpException, HttpStatus, Inject, Injectable, Logger, NotFoundException, OnModuleDestroy, OnModuleInit, Optional } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { Queue, Worker } from 'bullmq';
import IORedis from 'ioredis';
import { randomUUID } from 'node:crypto';
import { createHash } from 'node:crypto';
import { setTimeout as sleep } from 'node:timers/promises';
import { BillingService } from '../billing/billing.service';
import { isIpAllowed } from '../common/ip-allowlist';
import { moneyToNumber } from '../common/money';
import { PrismaService } from '../prisma/prisma.service';
import { RiskReviewService } from '../risk-review/risk-review.service';
import { OpenApiService } from '../open-api/open-api.service';

export interface CreateBatchTaskDto {
  tenantId: string;
  applicationId?: string;
  templateId?: string;
  content: string;
  category?: string;
  phones: string[];
  sendMode?: 'immediate' | 'scheduled';
  scheduledAt?: string;
  variables?: Record<string, unknown>;
  createdById?: string;
  sourceIp?: string;
  userAgent?: string;
  sourceType?: 'client' | 'api' | 'cmpp';
  clientMessageId?: string;
}

export type CreateHttpBatchTaskDto = Omit<CreateBatchTaskDto, 'templateId' | 'variables' | 'sourceType'>;

export interface GatewayInboundAuthDto {
  account: string;
  password?: string;
  authSource?: string;
  timestamp?: number;
  remoteIp?: string;
}

export interface GatewayInboundSubmitDto {
  account: string;
  phoneNumber?: string;
  phoneNumbers?: string[];
  content: string;
  srcId?: string;
  destId?: string;
  sequenceId?: number;
  remoteIp?: string;
  longMessage?: {
    reference: number;
    total: number;
    index: number;
    format: number;
  };
}

interface GatewayInboundSingleSubmitResult {
  accepted: boolean;
  tenantId: string;
  applicationId: string;
  taskId: string;
  messageId: string;
  messageRecordId: string;
  status: string;
}

export interface GatewaySubmitResultDto {
  traceId?: string;
  messageId: string;
  channelId: string;
  submitId?: string;
  sequenceId?: number;
  gatewayMessageId: string;
  submitStatus: 'accepted' | 'rejected' | 'timeout';
  errorCode?: string;
  errorMessage?: string;
  submittedAt?: string;
  segments?: Array<{
    segmentTotal?: number;
    segmentIndex?: number;
    sequenceId?: number;
    gatewayMessageId?: string;
    submitStatus?: 'accepted' | 'rejected' | 'timeout' | string;
    errorCode?: string;
    errorMessage?: string;
    submittedAt?: string;
  }>;
}

export interface GatewayReceiptEventDto {
  traceId?: string;
  messageId?: string;
  channelId: string;
  sequenceId?: number;
  gatewayMessageId: string;
  phoneNumber?: string;
  receiptStatus: 'delivered' | 'undelivered' | 'unknown';
  rawStatus: string;
  errorCode?: string;
  errorMessage?: string;
  deliveredAt?: string;
}

export interface GatewayUplinkEventDto {
  traceId?: string;
  messageId?: string;
  channelId: string;
  sequenceId?: number;
  phoneNumber: string;
  destId: string;
  content: string;
  receivedAt?: string;
}

type UplinkMatchCandidateInput = {
  tenantId: string;
  applicationId: string;
  messageRecordId?: string;
  matchSource: 'access_number' | 'phone_window';
  confidence: number;
  reason: string;
};

export interface GatewayPendingDeliveryQueryDto {
  account: string;
  limit?: number;
}

export interface GatewayDownstreamSentDto {
  id: string;
  connectionId?: string;
  sequenceId?: string;
  messageId?: string;
  sentAt?: string;
  ackDeadlineAt?: string;
}

export interface GatewayDownstreamAcknowledgedDto extends GatewayDownstreamSentDto {
  result: number;
  acknowledgedAt?: string;
}

export type GatewayDownstreamFailureType =
  | 'send_failed'
  | 'ack_timeout'
  | 'ack_rejected'
  | 'ack_invalid'
  | 'connection_lost'
  | 'unrecoverable'
  | 'queue_timeout';

type GatewayControlDeliveryResult = {
  sent?: boolean;
  delivered?: boolean;
  retryable?: boolean;
  reasonCode?: string;
  errorMessage?: string;
  connectionId?: string;
  sequenceId?: string;
  messageId?: string;
  sentAt?: string;
  ackDeadlineAt?: string;
};

export interface GatewaySubmitDeadLetterDto {
  streamMessageId: string;
  traceId?: string;
  messageId?: string;
  channelId?: string;
  tenantId?: string;
  applicationId?: string;
  submitId?: string;
  failureCode: string;
  failureMessage: string;
  attempts: number;
  maxAttempts: number;
  commandPayload?: Record<string, unknown>;
  rawPayload?: string;
  deadLetteredAt?: string;
}

export interface RequeueGatewaySubmitExceptionDto {
  confirmedNotSubmitted?: boolean;
  reason?: string;
  operatorId?: string;
}

export interface GatewayDownstreamRecoveryStatusDto {
  account: string;
  gatewayInstanceId?: string;
  state: string;
  lockOwner?: string;
  lockExpiresAt?: string;
  lastAttemptAt?: string;
  lastSuccessAt?: string;
  lastFailureAt?: string;
  nextRetryAt?: string;
  attemptCount?: number;
  failureCategory?: string;
  lastError?: string;
  lastSkipReason?: string;
}

export interface TimeoutUnknownDto {
  olderThanHours?: number;
}

export interface ImportPreviewDto {
  tenantId: string;
  applicationId?: string;
  content: string;
  fileName?: string;
  encoding?: 'utf8' | 'gbk';
  delimiter?: ',' | '\t';
  requiredVariables?: string[];
}

export interface ConfirmImportDto extends CreateBatchTaskDto {
  importContent: string;
  requiredVariables?: string[];
}

interface SendJob {
  messageRecordId: string;
}

type QueuePriority = 'normal' | 'priority';

type RoutedChannel = {
  channel: {
    id: string;
    code: string;
    account: string;
    srcId: string;
    rateLimitPerSecond: number;
    unitPrice: number;
    status: string;
    carrier?: string | null;
    sendRegion: string;
    gatewayHost: string;
    gatewayPort: number;
    passwordCipher: string;
    cmppVersion: string;
    config?: unknown;
  };
  carrier: string;
  province?: string | null;
  groupId: string;
  routeScope: 'province' | 'national';
};

const SEND_QUEUE = 'sms.send.queue';
const GATEWAY_SUBMIT_QUEUE = 'gateway.submit.queue';
const GATEWAY_SUBMIT_STREAM = 'gateway.submit.commands';
const DEFAULT_DOWNSTREAM_RETRY_DELAY_MS = 60_000;
const DEFAULT_DOWNSTREAM_RETRY_MAX_DELAY_MS = 30 * 60_000;
const DEFAULT_DOWNSTREAM_MAX_RETRIES = 10;
const DEFAULT_DOWNSTREAM_PENDING_TIMEOUT_HOURS = 72;
const DEFAULT_RECEIPT_TIMEOUT_HOURS = 72;
const DEFAULT_RECEIPT_TIMEOUT_SCAN_INTERVAL_MS = 5 * 60_000;
const RECEIPT_TIMEOUT_INITIAL_DELAY_MS = 60_000;
const DEFAULT_SCHEDULED_DISPATCH_SCAN_INTERVAL_MS = 5_000;
const DEFAULT_SCHEDULED_DISPATCH_STALE_MS = 2 * 60_000;
const SCHEDULED_DISPATCH_INITIAL_DELAY_MS = 1_000;
const DEFAULT_GATEWAY_SUBMIT_REQUEUE_STALE_MS = 2 * 60_000;
const DEFAULT_DOWNSTREAM_MANUAL_REQUEUE_STALE_MS = 2 * 60_000;
const DEFAULT_INBOUND_LONG_MESSAGE_SCAN_INTERVAL_MS = 60_000;
const INBOUND_LONG_MESSAGE_SCAN_INITIAL_DELAY_MS = 10_000;
const DEFAULT_INBOUND_LONG_MESSAGE_PROCESSING_STALE_SECONDS = 30;
const GATEWAY_SUBMIT_REQUEUE_IDEMPOTENCY_TTL_SECONDS = 30 * 24 * 60 * 60;
const BULLMQ_PRIORITY: Record<QueuePriority, number> = {
  priority: 1,
  normal: 100,
};

@Injectable()
export class SendChainService implements OnModuleInit, OnModuleDestroy {
  private readonly logger = new Logger(SendChainService.name);
  private redis?: IORedis;
  private sendQueue?: Queue<SendJob, unknown, 'send-message'>;
  private gatewayQueue?: Queue;
  private worker?: Worker<SendJob>;
  private receiptTimeoutInitialTimer?: ReturnType<typeof setTimeout>;
  private receiptTimeoutIntervalTimer?: ReturnType<typeof setInterval>;
  private receiptTimeoutScanRunning = false;
  private scheduledDispatchInitialTimer?: ReturnType<typeof setTimeout>;
  private scheduledDispatchIntervalTimer?: ReturnType<typeof setInterval>;
  private scheduledDispatchScanRunning = false;
  private inboundLongMessageInitialTimer?: ReturnType<typeof setTimeout>;
  private inboundLongMessageIntervalTimer?: ReturnType<typeof setInterval>;

  constructor(
    private readonly prisma: PrismaService,
    private readonly billing: BillingService,
    private readonly riskReview: RiskReviewService,
    @Optional() @Inject(forwardRef(() => OpenApiService)) private readonly openApi?: OpenApiService,
  ) {}

  onModuleInit() {
    if (process.env.API_ENABLE_SEND_WORKER === 'true') {
      this.startWorker();
    }
    if (process.env.SMS_RECEIPT_TIMEOUT_SCAN_ENABLED !== 'false') {
      this.receiptTimeoutInitialTimer = setTimeout(() => void this.runReceiptTimeoutScan(), RECEIPT_TIMEOUT_INITIAL_DELAY_MS);
      this.receiptTimeoutInitialTimer.unref?.();
      this.receiptTimeoutIntervalTimer = setInterval(
        () => void this.runReceiptTimeoutScan(),
        positiveInteger(process.env.SMS_RECEIPT_TIMEOUT_SCAN_INTERVAL_MS, DEFAULT_RECEIPT_TIMEOUT_SCAN_INTERVAL_MS),
      );
      this.receiptTimeoutIntervalTimer.unref?.();
    }
    if (process.env.SMS_SCHEDULED_DISPATCH_SCAN_ENABLED !== 'false') {
      this.scheduledDispatchInitialTimer = setTimeout(
        () => void this.runScheduledDispatchScan(),
        SCHEDULED_DISPATCH_INITIAL_DELAY_MS,
      );
      this.scheduledDispatchInitialTimer.unref?.();
      this.scheduledDispatchIntervalTimer = setInterval(
        () => void this.runScheduledDispatchScan(),
        positiveInteger(process.env.SMS_SCHEDULED_DISPATCH_SCAN_INTERVAL_MS, DEFAULT_SCHEDULED_DISPATCH_SCAN_INTERVAL_MS),
      );
      this.scheduledDispatchIntervalTimer.unref?.();
    }
    if (process.env.CMPP_INBOUND_LONG_MESSAGE_SCAN_ENABLED !== 'false') {
      this.inboundLongMessageInitialTimer = setTimeout(
        () => void this.expireInboundLongMessages().catch((error) => {
          this.logger.error(`Failed to expire inbound CMPP long messages: ${String(error)}`);
        }),
        INBOUND_LONG_MESSAGE_SCAN_INITIAL_DELAY_MS,
      );
      this.inboundLongMessageInitialTimer.unref?.();
      this.inboundLongMessageIntervalTimer = setInterval(
        () => void this.expireInboundLongMessages().catch((error) => {
          this.logger.error(`Failed to expire inbound CMPP long messages: ${String(error)}`);
        }),
        positiveInteger(
          process.env.CMPP_INBOUND_LONG_MESSAGE_SCAN_INTERVAL_MS,
          DEFAULT_INBOUND_LONG_MESSAGE_SCAN_INTERVAL_MS,
        ),
      );
      this.inboundLongMessageIntervalTimer.unref?.();
    }
  }

  async onModuleDestroy() {
    if (this.receiptTimeoutInitialTimer) clearTimeout(this.receiptTimeoutInitialTimer);
    if (this.receiptTimeoutIntervalTimer) clearInterval(this.receiptTimeoutIntervalTimer);
    if (this.scheduledDispatchInitialTimer) clearTimeout(this.scheduledDispatchInitialTimer);
    if (this.scheduledDispatchIntervalTimer) clearInterval(this.scheduledDispatchIntervalTimer);
    if (this.inboundLongMessageInitialTimer) clearTimeout(this.inboundLongMessageInitialTimer);
    if (this.inboundLongMessageIntervalTimer) clearInterval(this.inboundLongMessageIntervalTimer);
    await this.worker?.close();
    await this.sendQueue?.close();
    await this.gatewayQueue?.close();
    this.redis?.disconnect();
  }

  async createBatchTask(data: CreateBatchTaskDto) {
    const phones = [...new Set(data.phones ?? [])];
    const schedule = parseSchedule(data);
    await this.validateSendResources(data.tenantId, data.applicationId, data.templateId);
    const [messageClassification, unitPrice, queuePriority, accessNumber] = await Promise.all([
      this.resolveTemplateMessageClassification(data.tenantId, data.applicationId, data.templateId, data.content),
      this.resolveUnitPrice(data.tenantId, data.applicationId),
      this.resolveQueuePriority(data.tenantId, data.applicationId),
      this.resolveApplicationAccessNumber(data.tenantId, data.applicationId),
    ]);
    const risk = messageClassification.rejectionReason
      ? { status: 'rejected', reason: messageClassification.rejectionReason, task: null }
      : await this.riskReview.evaluateTask({
        tenantId: data.tenantId,
        applicationId: data.applicationId,
        templateId: data.templateId,
        content: data.content,
        category: data.category,
        phones,
        variables: messageClassification.variables ?? data.variables,
        createdById: data.createdById,
      });
    const billing = this.billing.estimateSmsCost({
      tenantId: data.tenantId,
      applicationId: data.applicationId,
      taskId: risk.task?.id,
      content: data.content,
      phoneCount: phones.length,
      unitPrice,
    });
    const batchStatus = statusFromRisk(risk.status, Boolean(schedule.scheduledAt));
    const shouldReserveBalance = batchStatus === 'ready';
    if (risk.status === 'approved') {
      const accountCheck = await this.billing.checkAccount({
        tenantId: data.tenantId,
        amountCents: billing.amountCents,
      });
      if (!accountCheck.canSend) {
        throw new BadRequestException('企业账户余额不足');
      }
    }
    if (data.applicationId && risk.status !== 'rejected') {
      await this.reserveDailySendQuota(data.applicationId, phones.length);
    }
    const task = await this.prisma.smsBatchTask.create({
      data: {
        tenantId: data.tenantId,
        applicationId: data.applicationId,
        templateId: data.templateId,
        taskNo: `BT-${Date.now()}-${randomUUID().slice(0, 8)}`,
        sourceType: data.sourceType ?? 'client',
        content: data.content,
        category: data.category,
        phoneTotal: phones.length,
        status: batchStatus,
        riskTaskId: risk.task?.id,
        auditStatus: risk.status === 'pending_review' ? 'pending' : risk.status === 'rejected' ? 'rejected' : 'approved',
        reviewReason: risk.status === 'pending_review' ? risk.reason : null,
        rejectReason: risk.status === 'rejected' ? risk.reason : null,
        progressTotal: phones.length,
        scheduledAt: schedule.scheduledAt,
        createdById: data.createdById,
      },
    });
    if (shouldReserveBalance && billing.amountCents > 0) {
      await this.billing.freeze({
        tenantId: data.tenantId,
        amountCents: billing.amountCents,
        relatedType: 'sms_batch_task',
        relatedId: task.id,
        remark: '发送任务创建冻结',
      });
    }
    await this.prisma.smsApiRequest.create({
      data: {
        tenantId: data.tenantId,
        batchTaskId: task.id,
        requestId: `REQ-${Date.now()}-${randomUUID().slice(0, 8)}`,
        sourceIp: data.sourceIp,
        userAgent: data.userAgent,
        payloadSummary: {
          phoneTotal: phones.length,
          contentLength: [...data.content].length,
          category: data.category,
          sendMode: schedule.scheduledAt ? 'scheduled' : 'immediate',
          scheduledAt: schedule.scheduledAt?.toISOString(),
        },
        status: batchStatus === 'rejected' ? 'rejected' : 'accepted',
      },
    });
    if (phones.length > 0) {
      await this.prisma.smsMessageRecord.createMany({
        data: phones.map((phone) => ({
          tenantId: data.tenantId,
          batchTaskId: task.id,
          applicationId: data.applicationId,
          templateId: data.templateId,
          signatureId: messageClassification.signatureId,
          drainageInfoId: messageClassification.drainageInfoId,
          messageId: `MSG-${randomUUID()}`,
          clientMessageId: data.clientMessageId,
          phoneNumber: phone,
          content: data.content,
          billingUnits: billing.billingUnitsPerMessage,
          unitPrice: billing.unitPrice,
          amountCents: billing.billingUnitsPerMessage * billing.unitPrice,
          queuePriority,
          clientSrcId: accessNumber.clientSrcId,
          applicationExtension: accessNumber.applicationExtension,
          status: batchStatus === 'ready' ? 'queued' : batchStatus === 'scheduled' ? 'scheduled' : batchStatus,
          errorMessage: risk.status === 'rejected' ? risk.reason ?? undefined : undefined,
        })),
      });
    }
    if (batchStatus === 'ready') {
      await this.enqueueBatchTask(task.id);
    }
    return this.getBatchTask(task.id, undefined, data.sourceType ?? 'client');
  }

  async createHttpBatchTask(data: CreateHttpBatchTaskDto) {
    if (!data.applicationId) {
      throw new BadRequestException('公开 HTTP 发送必须关联企业应用');
    }
    const template = await this.resolveInboundTemplateCandidate(data.applicationId, data.content);
    if (!template || template.auditStatus !== 'approved' || template.signature?.auditStatus !== 'approved') {
      throw new BadRequestException('短信内容未匹配当前应用已审核通过的签名和模板');
    }
    const variables = matchTemplateContent(template.content, data.content);
    if (variables === null) {
      throw new BadRequestException('短信内容与已审核模板不匹配');
    }
    return this.createBatchTask({
      ...data,
      templateId: template.id,
      variables,
      sourceType: 'api',
    });
  }

  async listBatchTasks(tenantId?: string, status?: string, sourceType = 'client') {
    const tasks = await this.prisma.smsBatchTask.findMany({
      where: { tenantId, status, sourceType },
      include: {
        tenant: true,
        application: true,
        template: true,
        apiRequests: true,
      },
      orderBy: { createdAt: 'desc' },
    });
    const taskIds = tasks.map((task) => task.id);
    const messageStats = taskIds.length > 0 ? await this.prisma.smsMessageRecord.groupBy({
      by: ['batchTaskId', 'carrier', 'province', 'status'],
      where: { batchTaskId: { in: taskIds } },
      _count: { _all: true },
      _sum: { billingUnits: true },
    }) : [];
    return tasks.map((task) => ({
      ...task,
      messageStats: messageStats.filter((item) => item.batchTaskId === task.id),
    }));
  }

  async getBatchTask(taskId: string, tenantId?: string, sourceType = 'client') {
    const task = await this.prisma.smsBatchTask.findFirst({
      where: { id: taskId, tenantId, sourceType },
      include: { apiRequests: true, messages: { take: 20, orderBy: { queuedAt: 'asc' } } },
    });
    if (!task) {
      throw new NotFoundException('SMS batch task not found');
    }
    return task;
  }

  async listClientTaskMessages(taskId: string, tenantId: string) {
    await this.getBatchTask(taskId, tenantId, 'client');
    return this.listMessages({ tenantId, taskId });
  }

  listMessages(query: {
    tenantId?: string;
    applicationId?: string;
    channelId?: string;
    taskId?: string;
    phoneNumber?: string;
    status?: string;
  } = {}) {
    return this.prisma.smsMessageRecord.findMany({
      where: {
        tenantId: query.tenantId,
        applicationId: query.applicationId,
        channelId: query.channelId,
        batchTaskId: query.taskId,
        phoneNumber: query.phoneNumber,
        status: query.status,
      },
      include: {
        tenant: true,
        application: true,
        channel: true,
        submitRecords: { include: { channel: true }, orderBy: { createdAt: 'asc' } },
        receiptRecords: { include: { channel: true }, orderBy: { createdAt: 'asc' } },
      },
      orderBy: { queuedAt: 'desc' },
    });
  }

  listSubmitRecords(taskId?: string) {
    return this.prisma.smsSubmitRecord.findMany({
      where: { batchTaskId: taskId },
      orderBy: { createdAt: 'desc' },
    });
  }

  listReceiptRecords(taskId?: string) {
    return this.prisma.smsReceiptRecord.findMany({
      where: { batchTaskId: taskId },
      orderBy: { createdAt: 'desc' },
    });
  }

  listUplinkMessages(tenantId?: string, channelId?: string) {
    return this.prisma.smsUplinkMessage.findMany({
      where: { tenantId, channelId },
      include: { application: true, channel: true, messageRecord: { include: { application: true } } },
      orderBy: { receivedAt: 'desc' },
    });
  }

  async previewImport(data: ImportPreviewDto) {
    const sizeBytes = Buffer.byteLength(data.content, 'utf8');
    if (sizeBytes > 20 * 1024 * 1024) {
      throw new BadRequestException('导入文件不能超过 20MB');
    }
    const rows = parseImportRows(data.content, data.delimiter);
    const phones: string[] = [];
    const errors: Array<{ rowNumber: number; phoneNumber?: string; reason: string }> = [];
    const requiredVariables = data.requiredVariables ?? [];
    const enterpriseBlacklist = data.applicationId ? await this.prisma.enterpriseBlacklist.findMany({
      where: { tenantId: data.tenantId, applicationId: data.applicationId, status: 'active' },
      select: { phoneNumber: true },
    }) : [];
    const globalBlacklist = await this.prisma.globalBlacklist.findMany({
      where: { status: 'active' },
      select: { phoneNumber: true },
    });
    const blacklist = new Set([...enterpriseBlacklist, ...globalBlacklist].map((item) => item.phoneNumber));
    const seen = new Set<string>();
    for (const row of rows) {
      if (!row.phoneNumber) {
        errors.push({ rowNumber: row.rowNumber, reason: '缺少手机号' });
        continue;
      }
      if (!/^1[3-9]\d{9}$/.test(row.phoneNumber)) {
        errors.push({ rowNumber: row.rowNumber, phoneNumber: row.phoneNumber, reason: '手机号格式非法' });
        continue;
      }
      if (seen.has(row.phoneNumber)) {
        errors.push({ rowNumber: row.rowNumber, phoneNumber: row.phoneNumber, reason: '重复号码' });
        continue;
      }
      if (blacklist.has(row.phoneNumber)) {
        errors.push({ rowNumber: row.rowNumber, phoneNumber: row.phoneNumber, reason: '命中黑名单' });
        continue;
      }
      const missingVariables = requiredVariables.filter((name) => !row.variables[name]);
      if (missingVariables.length > 0) {
        errors.push({ rowNumber: row.rowNumber, phoneNumber: row.phoneNumber, reason: `变量列缺失：${missingVariables.join(',')}` });
        continue;
      }
      seen.add(row.phoneNumber);
      phones.push(row.phoneNumber);
    }
    return {
      fileName: data.fileName,
      encoding: data.encoding ?? 'utf8',
      totalRows: rows.length,
      validCount: phones.length,
      errorCount: errors.length,
      phones,
      errors,
    };
  }

  async confirmImport(data: ConfirmImportDto) {
    const preview = await this.previewImport({
      tenantId: data.tenantId,
      applicationId: data.applicationId,
      content: data.importContent,
      requiredVariables: data.requiredVariables,
    });
    if (preview.validCount === 0) {
      throw new BadRequestException('导入文件没有可发送号码');
    }
    return this.createBatchTask({ ...data, phones: preview.phones });
  }

  async enqueueBatchTask(taskId: string) {
    const task = await this.prisma.smsBatchTask.findUnique({ where: { id: taskId } });
    if (!task) {
      throw new NotFoundException('SMS batch task not found');
    }
    if (task.status === 'canceled') {
      throw new BadRequestException('SMS batch task is canceled');
    }
    const messages = await this.prisma.smsMessageRecord.findMany({
      where: { batchTaskId: taskId, status: 'queued' },
      select: { id: true, queuePriority: true },
      take: 100000,
    });
    const queue = this.getSendQueue();
    for (const message of messages) {
      const queuePriority = normalizeQueuePriority(message.queuePriority);
      await queue.add('send-message', { messageRecordId: message.id }, {
        jobId: message.id,
        attempts: 3,
        priority: BULLMQ_PRIORITY[queuePriority],
      });
    }
    await this.prisma.smsBatchTask.update({ where: { id: taskId }, data: { status: 'queued' } });
    return { taskId, enqueued: messages.length };
  }

  async cancelBatchTask(taskId: string, tenantId?: string, sourceType = 'client') {
    const task = await this.prisma.smsBatchTask.findFirst({ where: { id: taskId, tenantId, sourceType } });
    if (!task) {
      throw new NotFoundException('SMS batch task not found');
    }
    if (task.status !== 'scheduled') {
      throw new BadRequestException('Only scheduled SMS batch tasks can be canceled before dispatch');
    }
    await this.prisma.smsMessageRecord.updateMany({
      where: { batchTaskId: taskId, status: 'scheduled' },
      data: { status: 'canceled', errorMessage: '定时任务已取消' },
    });
    return this.prisma.smsBatchTask.update({
      where: { id: taskId },
      data: { status: 'canceled', canceledAt: new Date() },
    });
  }

  async handleReviewDecision(reviewTaskId: string, decision: 'approved' | 'rejected', reason: string) {
    const reviewTask = await this.prisma.smsSendTask.findUnique({
      where: { id: reviewTaskId },
      include: {
        messageRecords: {
          where: { status: 'pending_review' },
          include: { batchTask: true },
        },
      },
    });
    if (!reviewTask || reviewTask.messageRecords.length === 0) {
      return { reviewTaskId, decision, affected: 0 };
    }
    const batchTaskIds = new Set<string>();
    for (const message of reviewTask.messageRecords) {
      if (!message.tenantId || !message.applicationId || !message.batchTaskId) continue;
      if (decision === 'approved') {
        await this.prisma.smsMessageRecord.update({
          where: { id: message.id },
          data: { status: 'queued', errorCode: null, errorMessage: null },
        });
        await this.prisma.smsBatchTask.update({
          where: { id: message.batchTaskId },
          data: { status: 'ready', auditStatus: 'approved', reviewReason: reason, rejectReason: null },
        });
        batchTaskIds.add(message.batchTaskId);
      } else {
        await this.releaseMessageReservation(
          message as typeof message & { tenantId: string; batchTaskId: string },
          '模板不匹配人工审核驳回释放冻结',
        );
        await this.prisma.smsBatchTask.update({
          where: { id: message.batchTaskId },
          data: { status: 'rejected', auditStatus: 'rejected', rejectReason: reason },
        });
        await this.recordCmppFailureReceipt(message, 'REVIEW_REJECTED', reason);
      }
    }
    for (const batchTaskId of batchTaskIds) {
      await this.enqueueBatchTask(batchTaskId);
    }
    return { reviewTaskId, decision, affected: reviewTask.messageRecords.length };
  }

  async terminateBatchTask(taskId: string) {
    const task = await this.prisma.smsBatchTask.findUnique({ where: { id: taskId } });
    if (!task) {
      throw new NotFoundException('SMS batch task not found');
    }
    if (['finished', 'completed', 'failed', 'canceled', 'rejected'].includes(task.status)) {
      throw new BadRequestException('SMS batch task is already final');
    }
    await this.prisma.smsMessageRecord.updateMany({
      where: { batchTaskId: taskId, status: { in: ['ready', 'queued', 'scheduled', 'submit_queued'] } },
      data: { status: 'canceled', errorMessage: '运营终止任务，未提交号码停止发送' },
    });
    await this.refreshTaskProgress(taskId);
    return this.prisma.smsBatchTask.update({
      where: { id: taskId },
      data: { status: 'canceled', canceledAt: new Date(), rejectReason: '运营终止任务' },
    });
  }

  async dispatchDueScheduledTasks(now = new Date()) {
    const staleCutoff = new Date(now.getTime() - positiveInteger(
      process.env.SMS_SCHEDULED_DISPATCH_STALE_MS,
      DEFAULT_SCHEDULED_DISPATCH_STALE_MS,
    ));
    const tasks = await this.prisma.smsBatchTask.findMany({
      where: {
        OR: [
          { status: 'scheduled', scheduledAt: { lte: now } },
          { status: { in: ['scheduled_dispatching', 'scheduled_recovering'] }, updatedAt: { lt: staleCutoff } },
        ],
      },
      orderBy: { scheduledAt: 'asc' },
    });
    const results: Array<{ taskId: string; status: string; enqueued?: number; reason?: string }> = [];
    for (const task of tasks) {
      const candidateStatus = task.status || 'scheduled';
      const claimedStatus = candidateStatus === 'scheduled_dispatching' ? 'scheduled_recovering' : 'scheduled_dispatching';
      const claimed = await this.prisma.smsBatchTask.updateMany({
        where: {
          id: task.id,
          status: candidateStatus,
          ...(candidateStatus === 'scheduled' ? {} : { updatedAt: { lt: staleCutoff } }),
        },
        data: { status: claimedStatus },
      });
      if (claimed.count !== 1) continue;
      let reservationEstablished = false;
      let dispatchPrepared = false;
      try {
        await this.validateSendResources(task.tenantId, task.applicationId ?? undefined, task.templateId ?? undefined);
        const messages = await this.prisma.smsMessageRecord.findMany({
          where: { batchTaskId: task.id, status: { in: ['scheduled', 'queued'] } },
          select: { id: true, amountCents: true, billingUnits: true },
          take: 100000,
        });
        const amountCents = messages.reduce((sum, message) => sum + moneyToNumber(message.amountCents), 0);
        const existingReservation = await this.prisma.accountTransaction.findFirst({
          where: { tenantId: task.tenantId, transactionType: 'frozen', relatedType: 'sms_batch_task', relatedId: task.id },
          select: { id: true },
        });
        reservationEstablished = Boolean(existingReservation);
        if (!reservationEstablished) {
          const accountCheck = await this.billing.checkAccount({ tenantId: task.tenantId, amountCents });
          if (!accountCheck.canSend) {
            throw new BadRequestException('定时任务到点时企业账户余额不足');
          }
          if (amountCents > 0) {
            await this.billing.freeze({
              tenantId: task.tenantId,
              amountCents,
              relatedType: 'sms_batch_task',
              relatedId: task.id,
              remark: '定时任务到点冻结',
            });
            reservationEstablished = true;
          }
        }
        dispatchPrepared = true;
        await this.prisma.smsMessageRecord.updateMany({
          where: { batchTaskId: task.id, status: 'scheduled' },
          data: { status: 'queued' },
        });
        const enqueued = await this.enqueueBatchTask(task.id);
        results.push({ taskId: task.id, status: 'queued', enqueued: enqueued.enqueued });
      } catch (error) {
        const reason = error instanceof Error ? error.message : '定时任务到点执行失败';
        if (reservationEstablished || dispatchPrepared) {
          await this.prisma.smsBatchTask.update({
            where: { id: task.id },
            data: { status: claimedStatus, rejectReason: `调度将在超时后恢复：${reason}` },
          });
          results.push({ taskId: task.id, status: 'retrying', reason });
          continue;
        }
        await this.prisma.smsMessageRecord.updateMany({
          where: { batchTaskId: task.id, status: 'scheduled' },
          data: { status: 'rejected', errorMessage: reason },
        });
        await this.prisma.smsBatchTask.update({
          where: { id: task.id },
          data: { status: 'failed', rejectReason: reason },
        });
        results.push({ taskId: task.id, status: 'failed', reason });
      }
    }
    return { dispatched: results.filter((result) => result.status === 'queued').length, results };
  }

  private async runScheduledDispatchScan() {
    if (this.scheduledDispatchScanRunning) return;
    this.scheduledDispatchScanRunning = true;
    try {
      await this.dispatchDueScheduledTasks();
    } catch (error) {
      this.logger.error(`Scheduled SMS dispatch scan failed: ${error instanceof Error ? error.message : String(error)}`);
    } finally {
      this.scheduledDispatchScanRunning = false;
    }
  }

  startWorker() {
    if (this.worker) {
      return { status: 'already_started' };
    }
    const connection = bullmqConnection();
    this.worker = new Worker<SendJob>(
      SEND_QUEUE,
      async (job) => this.processSendJob(job.data),
      { connection, concurrency: Number(process.env.API_SEND_WORKER_CONCURRENCY ?? 20) },
    );
    return { status: 'started' };
  }

  async processSendJob(job: SendJob) {
    const message = await this.prisma.smsMessageRecord.findUnique({
      where: { id: job.messageRecordId },
      include: { batchTask: true, template: { include: { signature: true } }, signature: true },
    });
    if (!message || message.status !== 'queued') {
      return { skipped: true };
    }
    if (!message.tenantId || !message.batchTaskId) {
      return { skipped: true, reason: 'standalone channel test message' };
    }
    const businessMessage = message as typeof message & { tenantId: string; batchTaskId: string };
    try {
      const routed = await this.selectChannelForMessage(businessMessage);
      return await this.submitMessageToGateway(businessMessage, routed, 0);
    } catch (error) {
      const reason = error instanceof Error ? error.message : '无可用通道组或通道';
      await this.prisma.smsMessageRecord.update({
        where: { id: message.id },
        data: { status: 'failed', errorMessage: reason },
      });
      await this.releaseMessageReservation(businessMessage, reason);
      if (message.batchTask?.sourceType === 'cmpp') {
        await this.recordCmppFailureReceipt(businessMessage, 'ROUTE', reason);
      } else {
        await this.refreshTaskProgress(businessMessage.batchTaskId);
      }
      return { submitted: false, messageRecordId: message.id, status: 'failed', reason };
    }
  }

  async handleSubmitResult(data: GatewaySubmitResultDto) {
    const message = await this.requireMessageByGatewayEvent(data.messageId, data.gatewayMessageId);
    const batchTask = message.batchTaskId
      ? await this.prisma.smsBatchTask.findUnique({ where: { id: message.batchTaskId }, select: { sourceType: true } })
      : null;
    const submittedAt = data.submittedAt ? new Date(data.submittedAt) : new Date();
    await this.prisma.smsSubmitRecord.updateMany({
      where: data.submitId ? { submitId: data.submitId } : { messageRecordId: message.id },
      data: {
        sequenceId: data.sequenceId,
        gatewayMessageId: data.gatewayMessageId,
        submitStatus: data.submitStatus,
        errorCode: data.errorCode,
        errorMessage: data.errorMessage,
        submittedAt,
      },
    });
    await this.recordSubmitSegments(message, data, submittedAt);
    const isStandaloneChannelTest = !message.tenantId && !message.batchTaskId;
    if (data.submitId && message.submitId && data.submitId !== message.submitId) {
      return this.prisma.smsMessageRecord.findUnique({ where: { id: message.id } });
    }
    const status = data.submitStatus === 'accepted' ? 'submitted' : data.submitStatus === 'timeout' ? 'timeout' : 'submit_failed';
    if (data.submitStatus === 'accepted' && !isStandaloneChannelTest && message.tenantId && message.batchTaskId) {
      const businessMessage = message as typeof message & { tenantId: string; batchTaskId: string };
      await this.chargeAcceptedMessage(businessMessage);
    } else if (data.submitStatus !== 'accepted' && !isStandaloneChannelTest && message.tenantId && message.batchTaskId) {
      const businessMessage = message as typeof message & { tenantId: string; batchTaskId: string };
      const retried = await this.retryMessageIfAllowed(businessMessage, data.submitStatus === 'timeout' ? '提交超时补发' : '提交失败补发');
      if (retried) {
        await this.refreshTaskProgress(businessMessage.batchTaskId);
        return retried;
      }
      await this.releaseMessageReservation(businessMessage, data.submitStatus === 'timeout' ? '提交超时释放冻结' : '提交失败释放冻结');
    }
    await this.prisma.smsMessageRecord.update({
      where: { id: message.id },
      data: {
        gatewayMessageId: data.gatewayMessageId,
        submitStatus: data.submitStatus,
        status,
        errorCode: data.errorCode,
        errorMessage: data.errorMessage,
        submittedAt,
        timeoutAt: data.submitStatus === 'timeout' ? submittedAt : undefined,
      },
    });
    if (data.submitStatus !== 'accepted' && batchTask?.sourceType === 'cmpp' && message.tenantId && message.applicationId) {
      await this.recordCmppFailureReceipt(
        message as typeof message & { tenantId: string; applicationId: string; batchTaskId: string },
        data.errorCode || 'SUBMIT',
        data.errorMessage || (data.submitStatus === 'timeout' ? '上游提交超时' : '上游拒绝短信'),
      );
    }
    await this.prisma.gatewaySubmitDeadLetter.updateMany({
      where: {
        status: { in: ['pending', 'requeueing', 'requeue_recovering', 'requeued'] },
        OR: [
          data.submitId ? { submitId: data.submitId } : undefined,
          data.messageId ? { messageId: data.messageId } : undefined,
        ].filter(Boolean) as Array<{ submitId?: string; messageId?: string }>,
      },
      data: {
        status: 'resolved',
        resolvedAt: submittedAt,
        resolvedStatus: data.submitStatus,
      },
    });
    if (message.batchTaskId) {
      await this.refreshTaskProgress(message.batchTaskId);
    }
    return this.prisma.smsMessageRecord.findUnique({ where: { id: message.id } });
  }

  async handleReceipt(data: GatewayReceiptEventDto) {
    const resolved = await this.resolveReceiptMessage(data);
    const logicalChannelId = resolved.channelId ?? data.channelId;
    const receiptKey = this.receiptEventKey(data, logicalChannelId);
    const existingReceipt = await this.prisma.smsReceiptRecord.findUnique({
      where: { receiptKey },
      include: { messageRecord: true },
    });
    if (existingReceipt?.messageRecord) {
      return existingReceipt.messageRecord;
    }
    const message = resolved.message;
    const deliveredAt = data.deliveredAt ? new Date(data.deliveredAt) : new Date();
    if (resolved.submitRecordId) {
      await this.prisma.smsSubmitRecord.updateMany({
        where: {
          id: resolved.submitRecordId,
          gatewayMessageId: null,
        },
        data: {
          gatewayMessageId: data.gatewayMessageId,
          sequenceId: data.sequenceId,
        },
      });
    }
    try {
      await this.prisma.smsReceiptRecord.create({
        data: {
          tenantId: message.tenantId,
          batchTaskId: message.batchTaskId,
          messageRecordId: message.id,
          receiptKey,
          channelId: logicalChannelId,
          messageId: resolved.messageId,
          gatewayMessageId: data.gatewayMessageId,
          phoneNumber: data.phoneNumber?.trim() || message.phoneNumber,
          sequenceId: data.sequenceId,
          receiptStatus: data.receiptStatus,
          rawStatus: data.rawStatus,
          errorCode: data.errorCode,
          errorMessage: data.errorMessage,
          deliveredAt,
        },
      });
    } catch (error) {
      if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === 'P2002') {
        const duplicate = await this.prisma.smsReceiptRecord.findUnique({
          where: { receiptKey },
          include: { messageRecord: true },
        });
        if (duplicate?.messageRecord) return duplicate.messageRecord;
      }
      throw error;
    }
    const logicalReceipt = { ...data, channelId: logicalChannelId };
    await this.recordReceiptSegment(message, logicalReceipt, deliveredAt, resolved.submitRecordId);
    const aggregate = await this.aggregateReceiptSegments(
      message,
      logicalReceipt,
      deliveredAt,
      resolved.submitRecordId,
      resolved.submitId,
    );
    if (!aggregate.terminal) {
      return this.prisma.smsMessageRecord.findUnique({ where: { id: message.id } });
    }
    const status = aggregate.status;
    const isCurrentAttempt =
      (!message.channelId || message.channelId === logicalChannelId)
      && (
        !message.gatewayMessageId
        || message.gatewayMessageId === data.gatewayMessageId
        || (aggregate.segmentTotal > 1 && (!message.submitId || message.submitId === resolved.submitId))
      );
    if (!isCurrentAttempt || (status === 'failed' && message.status === 'delivered')) {
      return this.prisma.smsMessageRecord.findUnique({ where: { id: message.id } });
    }
    const isStandaloneChannelTest = !message.tenantId && !message.batchTaskId;
    if (status === 'failed' && !isStandaloneChannelTest && message.tenantId && message.batchTaskId) {
      const businessMessage = message as typeof message & { tenantId: string; batchTaskId: string };
      const retried = await this.retryMessageIfAllowed(businessMessage, '回执失败补发');
      if (retried) {
        await this.refreshTaskProgress(businessMessage.batchTaskId);
        return retried;
      }
      await this.refundMessage(businessMessage, '最终失败退款');
    }
    await this.prisma.smsMessageRecord.update({
      where: { id: message.id },
      data: {
        channelId: logicalChannelId,
        gatewayMessageId: message.gatewayMessageId ?? data.gatewayMessageId,
        receiptStatus: aggregate.receiptStatus,
        receiptRawStatus: aggregate.rawStatus,
        status,
        errorCode: aggregate.errorCode,
        errorMessage: aggregate.errorMessage ?? (status === 'delivered' ? null : aggregate.rawStatus),
        deliveredAt: aggregate.deliveredAt,
      },
    });
    if (!isStandaloneChannelTest && message.tenantId && message.applicationId) {
      await this.queueAndTryDownstreamDelivery({
        tenantId: message.tenantId,
        applicationId: message.applicationId,
        messageRecordId: message.id,
        messageId: message.messageId,
        deliveryType: 'receipt',
        payload: {
          messageId: message.messageId,
          gatewayMessageId: data.gatewayMessageId,
          phoneNumber: message.phoneNumber,
          receiptStatus: aggregate.receiptStatus,
          rawStatus: aggregate.rawStatus,
          errorCode: aggregate.errorCode,
          submitSequenceId: message.cmppSubmitSequenceId ? Number(message.cmppSubmitSequenceId) : undefined,
          submitGroupMessageId: message.cmppSubmitGroupMessageId ?? undefined,
          deliveredAt: aggregate.deliveredAt.toISOString(),
        },
      });
    }
    if (message.batchTaskId) {
      await this.refreshTaskProgress(message.batchTaskId);
    }
    return this.prisma.smsMessageRecord.findUnique({ where: { id: message.id } });
  }

  async handleUplink(data: GatewayUplinkEventDto) {
    const channel = await this.prisma.smsChannel.findUnique({ where: { id: data.channelId } });
    if (!channel) {
      throw new NotFoundException('SMS channel not found');
    }
    const match = await this.resolveUplinkMatch(data, channel);
    const record = await this.prisma.smsUplinkMessage.create({
      data: {
        tenantId: match.tenantId,
        applicationId: match.applicationId,
        messageRecordId: match.messageRecordId,
        channelId: data.channelId,
        messageId: data.messageId,
        sequenceId: data.sequenceId,
        phoneNumber: data.phoneNumber,
        destId: data.destId,
        content: data.content,
        matchStatus: match.matchStatus,
        matchReason: match.matchReason,
        receivedAt: data.receivedAt ? new Date(data.receivedAt) : new Date(),
      },
    });
    if (match.candidates.length > 0) {
      await this.prisma.smsUplinkMatchCandidate.createMany({
        data: match.candidates.map((candidate) => ({
          uplinkMessageId: record.id,
          tenantId: candidate.tenantId,
          applicationId: candidate.applicationId,
          messageRecordId: candidate.messageRecordId,
          matchSource: candidate.matchSource,
          confidence: candidate.confidence,
          reason: candidate.reason,
        })),
        skipDuplicates: true,
      });
    }
    if (match.tenantId && match.applicationId) {
      await this.queueAndTryDownstreamDelivery({
        tenantId: match.tenantId,
        applicationId: match.applicationId,
        messageRecordId: match.messageRecordId,
        messageId: data.messageId,
        deliveryType: 'uplink',
        payload: {
          messageId: data.messageId,
          applicationId: match.applicationId,
          phoneNumber: data.phoneNumber,
          destId: data.destId,
          content: data.content,
          receivedAt: record.receivedAt.toISOString(),
          uplinkMessageId: record.id,
        },
      });
    }
    return record;
  }

  async listPendingDownstreamDeliveries(data: GatewayPendingDeliveryQueryDto) {
    const application = await this.findInboundApplication(data.account);
    if (!application || application.status !== 'active' || application.tenant.status !== 'active') {
      throw new BadRequestException('CMPP account is invalid or disabled');
    }
    const expiredAcknowledgements = await this.prisma.cmppDownstreamDelivery.findMany({
      where: { applicationId: application.id, status: 'awaiting_ack', ackDeadlineAt: { lte: new Date() } },
      select: { id: true },
      take: 500,
    });
    for (const expired of expiredAcknowledgements) {
      await this.markDownstreamDeliveryFailed(expired.id, 'CMPP_DELIVER_RESP timeout recovered after Gateway restart', 'ack_timeout');
    }
    return this.prisma.cmppDownstreamDelivery.findMany({
      where: {
        applicationId: application.id,
        status: 'pending',
        OR: [{ nextRetryAt: null }, { nextRetryAt: { lte: new Date() } }],
      },
      orderBy: { createdAt: 'asc' },
      take: Math.min(Math.max(data.limit ?? 100, 1), 500),
    });
  }

  async markDownstreamDeliveryDelivered(id: string) {
    return this.prisma.cmppDownstreamDelivery.update({
      where: { id },
      data: {
        status: 'delivered',
        deliveredAt: new Date(),
        lastError: null,
      },
    });
  }

  async markDownstreamDeliverySent(data: GatewayDownstreamSentDto) {
    const sentAt = asDateOrNull(data.sentAt) ?? new Date();
    const ackDeadlineAt = asDateOrNull(data.ackDeadlineAt) ?? new Date(sentAt.getTime() + downstreamAckTimeoutMs());
    await this.prisma.cmppDownstreamDelivery.updateMany({
      where: { id: data.id, status: { not: 'delivered' } },
      data: {
        status: 'awaiting_ack',
        sentAt,
        ackDeadlineAt,
        ackSequenceId: data.sequenceId,
        ackMessageId: data.messageId,
        connectionId: data.connectionId,
        nextRetryAt: null,
        lastError: null,
      },
    });
    return this.prisma.cmppDownstreamDelivery.findUnique({ where: { id: data.id } });
  }

  async acknowledgeDownstreamDelivery(data: GatewayDownstreamAcknowledgedDto) {
    const acknowledgedAt = asDateOrNull(data.acknowledgedAt) ?? new Date();
    const acknowledgedMessageId = String(data.messageId ?? '').trim();
    if (data.result === 0 && acknowledgedMessageId !== '' && acknowledgedMessageId !== '0') {
      await this.prisma.cmppDownstreamDelivery.updateMany({
        where: { id: data.id, status: { not: 'delivered' } },
        data: {
          status: 'delivered',
          acknowledgedAt,
          deliveredAt: acknowledgedAt,
          ackDeadlineAt: null,
          ackResult: data.result,
          ackSequenceId: data.sequenceId,
          ackMessageId: data.messageId,
          connectionId: data.connectionId,
          nextRetryAt: null,
          lastError: null,
        },
      });
      return this.prisma.cmppDownstreamDelivery.findUnique({ where: { id: data.id } });
    }
    await this.prisma.cmppDownstreamDelivery.updateMany({
      where: { id: data.id, status: { not: 'delivered' } },
      data: {
        acknowledgedAt,
        ackResult: data.result,
        ackSequenceId: data.sequenceId,
        ackMessageId: data.messageId,
        connectionId: data.connectionId,
      },
    });
    if (data.result === 0) {
      return this.markDownstreamDeliveryFailed(data.id, 'CMPP_DELIVER_RESP Msg_Id=0，客户端仅确认协议收包，无法关联原短信', 'ack_invalid');
    }
    return this.markDownstreamDeliveryFailed(data.id, `downstream CMPP_DELIVER_RESP result=${data.result}`, 'ack_rejected');
  }

  async markDownstreamDeliveryFailed(id: string, errorMessage?: string, failureType: GatewayDownstreamFailureType = 'send_failed') {
    const delivery = await this.prisma.cmppDownstreamDelivery.findUnique({ where: { id } });
    if (!delivery) {
      throw new NotFoundException('Downstream delivery not found');
    }
    if (delivery.status === 'delivered') {
      return delivery;
    }
    if (failureType === 'queue_timeout' && delivery.status !== 'pending') {
      return delivery;
    }
    const retryCount = (delivery.retryCount ?? 0) + 1;
    const acknowledgementFailure = failureType === 'ack_timeout' || failureType === 'ack_rejected' || failureType === 'ack_invalid' || failureType === 'connection_lost';
    const retryAllowed = !acknowledgementFailure || delivery.retryEnabled !== false;
    const nonRetryableFailure = failureType === 'unrecoverable' || failureType === 'queue_timeout';
    const finalFailure = nonRetryableFailure || !retryAllowed || retryCount >= downstreamMaxRetries();
    const finalStatus = failureType === 'ack_rejected' ? 'rejected' : acknowledgementFailure ? 'unconfirmed' : 'failed';
    const updated = await this.prisma.cmppDownstreamDelivery.update({
      where: { id },
      data: {
        status: finalFailure ? finalStatus : 'pending',
        retryCount,
        nextRetryAt: finalFailure ? null : new Date(Date.now() + downstreamRetryDelayMs(retryCount)),
        ackDeadlineAt: null,
        lastError: errorMessage ?? 'downstream delivery failed',
      },
    });
    if (finalFailure) {
      await this.prisma.operationLog.create({
        data: {
          tenantId: updated.tenantId,
          action: 'gateway.downstream_delivery_failed',
          resource: 'cmpp_downstream_delivery',
          resourceId: updated.id,
          detail: {
            deliveryType: updated.deliveryType,
            applicationId: updated.applicationId,
            messageId: updated.messageId,
            retryCount,
            failureType,
            retryEnabled: updated.retryEnabled,
            errorMessage: updated.lastError,
          },
        },
      });
    }
    return updated;
  }

  async recordGatewaySubmitDeadLetter(data: GatewaySubmitDeadLetterDto) {
    const createdAt = data.deadLetteredAt ? new Date(data.deadLetteredAt) : new Date();
    return this.prisma.gatewaySubmitDeadLetter.upsert({
      where: { streamMessageId: data.streamMessageId },
      update: {
        tenantId: data.tenantId,
        applicationId: data.applicationId,
        channelId: data.channelId,
        traceId: data.traceId,
        messageId: data.messageId,
        submitId: data.submitId,
        failureCode: data.failureCode,
        failureMessage: data.failureMessage,
        attempts: data.attempts,
        maxAttempts: data.maxAttempts,
        commandPayload: data.commandPayload as Prisma.InputJsonValue | undefined,
        rawPayload: data.rawPayload,
      },
      create: {
        streamMessageId: data.streamMessageId,
        tenantId: data.tenantId,
        applicationId: data.applicationId,
        channelId: data.channelId,
        traceId: data.traceId,
        messageId: data.messageId,
        submitId: data.submitId,
        failureCode: data.failureCode,
        failureMessage: data.failureMessage,
        attempts: data.attempts,
        maxAttempts: data.maxAttempts,
        commandPayload: data.commandPayload as Prisma.InputJsonValue | undefined,
        rawPayload: data.rawPayload,
        createdAt,
      },
    });
  }

  async recordGatewayDownstreamRecoveryStatus(data: GatewayDownstreamRecoveryStatusDto) {
    const account = String(data.account ?? '').trim();
    if (!account) {
      throw new BadRequestException('account is required');
    }
    const recoveryStatuses = (this.prisma as PrismaService & {
      gatewayDownstreamRecoveryStatus: {
        findUnique: (args: Record<string, unknown>) => Promise<any>;
        upsert: (args: Record<string, unknown>) => Promise<any>;
      };
    }).gatewayDownstreamRecoveryStatus;
    const previous = await recoveryStatuses.findUnique({
      where: { account },
      select: {
        state: true,
        gatewayInstanceId: true,
        lockOwner: true,
        failureCategory: true,
        lastError: true,
        lastSkipReason: true,
      },
    });
    const application = await this.prisma.smsApplication.findUnique({
      where: { cmppAccount: account },
      select: { id: true, tenantId: true, name: true },
    });
    const failureCategory = normalizeRecoveryFailureCategory(data);
    const updated = await recoveryStatuses.upsert({
      where: { account },
      update: {
        tenantId: application?.tenantId ?? null,
        applicationId: application?.id ?? null,
        gatewayInstanceId: data.gatewayInstanceId ?? null,
        state: data.state,
        lockOwner: data.lockOwner ?? null,
        lockExpiresAt: asDateOrNull(data.lockExpiresAt),
        lastAttemptAt: asDateOrNull(data.lastAttemptAt),
        lastSuccessAt: asDateOrNull(data.lastSuccessAt),
        lastFailureAt: asDateOrNull(data.lastFailureAt),
        nextRetryAt: asDateOrNull(data.nextRetryAt),
        attemptCount: Number.isFinite(Number(data.attemptCount)) ? Number(data.attemptCount) : 0,
        failureCategory,
        lastError: data.lastError ?? null,
        lastSkipReason: data.lastSkipReason ?? null,
      },
      create: {
        account,
        tenantId: application?.tenantId,
        applicationId: application?.id,
        gatewayInstanceId: data.gatewayInstanceId,
        state: data.state,
        lockOwner: data.lockOwner,
        lockExpiresAt: asDateOrNull(data.lockExpiresAt),
        lastAttemptAt: asDateOrNull(data.lastAttemptAt),
        lastSuccessAt: asDateOrNull(data.lastSuccessAt),
        lastFailureAt: asDateOrNull(data.lastFailureAt),
        nextRetryAt: asDateOrNull(data.nextRetryAt),
        attemptCount: Number.isFinite(Number(data.attemptCount)) ? Number(data.attemptCount) : 0,
        failureCategory,
        lastError: data.lastError,
        lastSkipReason: data.lastSkipReason,
      },
      include: {
        tenant: true,
        application: true,
      },
    });
    const normalizedUpdated = updated as typeof updated & {
      failureCategory?: string | null;
      lockOwner?: string | null;
      lockExpiresAt?: Date | null;
    };
    if (hasRecoveryAuditStateChanged(previous, updated)) {
      await this.prisma.operationLog.create({
        data: {
          tenantId: updated.tenantId ?? undefined,
          action: 'gateway.downstream_recovery_status_changed',
          resource: 'gateway_downstream_recovery_status',
          resourceId: updated.id,
          detail: {
            account,
            previousState: previous?.state ?? null,
            state: updated.state,
            gatewayInstanceId: updated.gatewayInstanceId,
            lockOwner: normalizedUpdated.lockOwner,
            attemptCount: updated.attemptCount,
            nextRetryAt: updated.nextRetryAt,
            failureCategory: normalizedUpdated.failureCategory,
            applicationId: updated.applicationId,
            applicationName: application?.name,
            lastError: updated.lastError,
            lastSkipReason: updated.lastSkipReason,
          },
        },
      });
    }
    return updated;
  }

  async requeueGatewaySubmitDeadLetter(id: string, data: RequeueGatewaySubmitExceptionDto = {}) {
    const deadLetter = await this.prisma.gatewaySubmitDeadLetter.findUnique({ where: { id } });
    if (!deadLetter) {
      throw new NotFoundException('Gateway提交异常记录不存在');
    }
    if (deadLetter.status !== 'pending') {
      throw new BadRequestException('该提交异常当前状态不允许重新入队');
    }
    if (!data.confirmedNotSubmitted) {
      throw new BadRequestException('请确认运营商未接收该短信后再重新入队');
    }
    const reason = String(data.reason ?? '').trim();
    if (reason.length < 5 || reason.length > 500) {
      throw new BadRequestException('请填写5至500字的重新入队原因');
    }
    if (!deadLetter.commandPayload || !isObjectRecord(deadLetter.commandPayload)) {
      throw new BadRequestException('该提交异常缺少可重新入队的SubmitCommand');
    }
    if (deadLetter.manualRetryCount >= 3) {
      throw new BadRequestException('该提交异常已达到人工重新入队次数上限');
    }
    const message = deadLetter.messageId
      ? await this.prisma.smsMessageRecord.findUnique({ where: { messageId: deadLetter.messageId } })
      : null;
    if (message && (
      message.submitStatus === 'accepted'
      || ['submitted', 'delivered', 'unknown'].includes(message.status)
      || ['delivered', 'unknown'].includes(message.receiptStatus ?? '')
    )) {
      throw new BadRequestException('该短信已有成功或不确定的上游结果，为避免重复发送，禁止重新入队');
    }
    const commandChannelId = String(deadLetter.commandPayload.channelId ?? deadLetter.channelId ?? '').trim();
    if (!commandChannelId) {
      throw new BadRequestException('该提交异常缺少通道信息');
    }
    const channel = await this.prisma.smsChannel.findUnique({
      where: { id: commandChannelId },
      include: { connectionStates: true },
    });
    if (!channel || channel.status !== 'active') {
      throw new BadRequestException('原通道不存在或已停用，不能重新入队');
    }
    if (!channel.connectionStates.some((state) => state.status === 'connected' && state.currentConnections > 0)) {
      throw new BadRequestException('原通道当前没有可用CMPP连接，请先恢复通道');
    }
    const claimed = await this.prisma.gatewaySubmitDeadLetter.updateMany({
      where: { id, status: 'pending' },
      data: { status: 'requeueing' },
    });
    if (claimed.count !== 1) {
      throw new BadRequestException('该提交异常已被其他操作处理，请刷新后重试');
    }
    const requeueKey = gatewaySubmitRequeueKey(deadLetter.id, deadLetter.manualRetryCount + 1);
    let retryStreamMessageId: string;
    try {
      const publishedStreamMessageId = await this.publishGatewaySubmitCommand(deadLetter.commandPayload, requeueKey);
      if (!publishedStreamMessageId) {
        throw new Error('Gateway提交异常重新入队未返回Stream消息编号');
      }
      retryStreamMessageId = publishedStreamMessageId;
    } catch (error) {
      await this.prisma.gatewaySubmitDeadLetter.updateMany({
        where: { id, status: 'requeueing' },
        data: { status: 'pending' },
      });
      throw error;
    }
    const finalized = await this.prisma.gatewaySubmitDeadLetter.updateMany({
      where: { id, status: 'requeueing' },
      data: {
        status: 'requeued',
        manualRetryCount: { increment: 1 },
        lastRetryStreamId: retryStreamMessageId,
        lastRetriedAt: new Date(),
      },
    });
    const updated = await this.prisma.gatewaySubmitDeadLetter.findUnique({ where: { id } });
    if (!updated) {
      throw new NotFoundException('Gateway提交异常记录不存在');
    }
    if (finalized.count !== 1 && updated.status !== 'resolved') {
      throw new BadRequestException('该提交异常状态已变化，请刷新后确认处理结果');
    }
    await this.prisma.operationLog.create({
      data: {
        tenantId: updated.tenantId ?? undefined,
        userId: data.operatorId,
        action: 'gateway.submit_dead_letter_requeue',
        resource: 'gateway_submit_dead_letter',
        resourceId: updated.id,
        detail: {
          streamMessageId: updated.streamMessageId,
          retryStreamMessageId,
          submitId: updated.submitId,
          messageId: updated.messageId,
          reason,
          confirmedNotSubmitted: true,
        },
      },
    });
    return updated;
  }

  async recoverStaleGatewaySubmitRequeues(now = new Date()) {
    const staleCutoff = new Date(now.getTime() - positiveInteger(
      process.env.GATEWAY_SUBMIT_REQUEUE_STALE_MS,
      DEFAULT_GATEWAY_SUBMIT_REQUEUE_STALE_MS,
    ));
    const stale = await this.prisma.gatewaySubmitDeadLetter.findMany({
      where: { status: 'requeueing', updatedAt: { lt: staleCutoff } },
      orderBy: { updatedAt: 'asc' },
      take: 100,
    });
    let recovered = 0;
    let failed = 0;
    for (const deadLetter of stale) {
      if (!deadLetter.commandPayload || !isObjectRecord(deadLetter.commandPayload)) {
        await this.prisma.gatewaySubmitDeadLetter.updateMany({
          where: { id: deadLetter.id, status: 'requeueing', updatedAt: deadLetter.updatedAt },
          data: { status: 'pending' },
        });
        failed += 1;
        continue;
      }
      const claimed = await this.prisma.gatewaySubmitDeadLetter.updateMany({
        where: { id: deadLetter.id, status: 'requeueing', updatedAt: deadLetter.updatedAt },
        data: { status: 'requeue_recovering' },
      });
      if (claimed.count !== 1) continue;
      try {
        const requeueKey = gatewaySubmitRequeueKey(deadLetter.id, deadLetter.manualRetryCount + 1);
        const retryStreamMessageId = await this.publishGatewaySubmitCommand(deadLetter.commandPayload, requeueKey);
        if (!retryStreamMessageId) throw new Error('Gateway提交异常恢复未返回Stream消息编号');
        const finalized = await this.prisma.gatewaySubmitDeadLetter.updateMany({
          where: { id: deadLetter.id, status: 'requeue_recovering' },
          data: {
            status: 'requeued',
            manualRetryCount: { increment: 1 },
            lastRetryStreamId: retryStreamMessageId,
            lastRetriedAt: new Date(),
          },
        });
        if (finalized.count === 1) {
          recovered += 1;
          await this.prisma.operationLog.create({
            data: {
              tenantId: deadLetter.tenantId ?? undefined,
              action: 'gateway.submit_dead_letter_requeue_recovered',
              resource: 'gateway_submit_dead_letter',
              resourceId: deadLetter.id,
              detail: { retryStreamMessageId, requeueKey },
            },
          });
        }
      } catch (error) {
        failed += 1;
        await this.prisma.gatewaySubmitDeadLetter.updateMany({
          where: { id: deadLetter.id, status: 'requeue_recovering' },
          data: { status: 'requeueing' },
        });
        this.logger.error(`Gateway submit requeue recovery failed for ${deadLetter.id}: ${error instanceof Error ? error.message : String(error)}`);
      }
    }
    return { recovered, failed };
  }

  async requeueDownstreamDelivery(id: string) {
    const delivery = await this.prisma.cmppDownstreamDelivery.findUnique({
      where: { id },
      include: { application: { select: { cmppAccount: true } } },
    });
    if (!delivery) {
      throw new NotFoundException('Downstream delivery not found');
    }
    if (delivery.status === 'awaiting_ack') {
      throw new BadRequestException('该记录正在等待客户端确认，不允许并发重投');
    }
    const payload = isObjectRecord(delivery.payload) ? { ...delivery.payload } : null;
    if (!payload) {
      throw new BadRequestException('下游投递记录缺少可重放 payload');
    }
    const path =
      delivery.deliveryType === 'receipt'
        ? '/downstream/receipt'
        : delivery.deliveryType === 'uplink'
          ? '/downstream/uplink'
          : null;
    if (!path) {
      throw new BadRequestException(`Unsupported downstream delivery type ${delivery.deliveryType}`);
    }

    const requestPayload = {
      deliveryId: delivery.id,
      account: String(payload.account ?? delivery.application?.cmppAccount ?? ''),
      ...payload,
    };
    const retriedAt = new Date();
    const claimed = await this.prisma.cmppDownstreamDelivery.updateMany({
      where: {
        id: delivery.id,
        status: delivery.status,
        updatedAt: delivery.updatedAt,
      },
      data: {
        status: 'manual_requeueing',
        retryCount: 0,
        manualRetryCount: { increment: 1 },
        lastRetriedAt: retriedAt,
        nextRetryAt: null,
        sentAt: null,
        acknowledgedAt: null,
        ackDeadlineAt: null,
        ackResult: null,
        ackSequenceId: null,
        ackMessageId: null,
        connectionId: null,
        deliveredAt: null,
        lastError: null,
      },
    });
    if (claimed.count !== 1) {
      throw new BadRequestException('该下游投递记录已被其他操作处理，请刷新后重试');
    }
    await this.prisma.operationLog.create({
      data: {
        tenantId: delivery.tenantId,
        action: 'gateway.downstream_delivery_requeue',
        resource: 'cmpp_downstream_delivery',
        resourceId: delivery.id,
        detail: {
          deliveryType: delivery.deliveryType,
          applicationId: delivery.applicationId,
          messageId: delivery.messageId,
          previousStatus: delivery.status,
          previousRetryCount: delivery.retryCount,
          manualRetryCount: (delivery.manualRetryCount ?? 0) + 1,
          lastRetriedAt: retriedAt,
        },
      },
    });
    try {
      const result = await this.postGatewayControl(path, requestPayload) as GatewayControlDeliveryResult;
      if (result.sent || result.delivered) {
        return this.markDownstreamDeliverySent({ id: delivery.id, ...result });
      }
      return this.markDownstreamDeliveryFailed(
        delivery.id,
        downstreamControlFailureMessage(result),
        result.retryable === false ? 'unrecoverable' : 'send_failed',
      );
    } catch (error) {
      return this.markDownstreamDeliveryFailed(
        delivery.id,
        error instanceof Error ? error.message : 'Gateway control delivery failed',
      );
    }
  }

  async recoverStaleDownstreamManualRequeues(now = new Date()) {
    const staleCutoff = new Date(now.getTime() - positiveInteger(
      process.env.CMPP_DOWNSTREAM_MANUAL_REQUEUE_STALE_MS,
      DEFAULT_DOWNSTREAM_MANUAL_REQUEUE_STALE_MS,
    ));
    const stale = await this.prisma.cmppDownstreamDelivery.findMany({
      where: { status: 'manual_requeueing', updatedAt: { lt: staleCutoff } },
      select: { id: true, updatedAt: true },
      orderBy: { updatedAt: 'asc' },
      take: 500,
    });
    let recovered = 0;
    for (const delivery of stale) {
      const updated = await this.prisma.cmppDownstreamDelivery.updateMany({
        where: { id: delivery.id, status: 'manual_requeueing', updatedAt: delivery.updatedAt },
        data: {
          status: 'pending',
          nextRetryAt: null,
          lastError: '人工重投进程中断，已恢复为待投递',
        },
      });
      recovered += updated.count;
    }
    return { recovered };
  }

  async batchRequeueDownstreamDeliveries(ids: string[]) {
    const uniqueIds = [...new Set(ids.filter(Boolean))];
    if (uniqueIds.length === 0) {
      throw new BadRequestException('请选择至少一条下游投递记录');
    }
    const results: Array<{ id: string; status: 'success' | 'failed'; errorMessage?: string }> = [];
    for (const id of uniqueIds) {
      try {
        await this.requeueDownstreamDelivery(id);
        results.push({ id, status: 'success' });
      } catch (error) {
        results.push({
          id,
          status: 'failed',
          errorMessage: error instanceof Error ? error.message : '批量重投失败',
        });
      }
    }
    return {
      total: uniqueIds.length,
      successCount: results.filter((item) => item.status === 'success').length,
      failedCount: results.filter((item) => item.status === 'failed').length,
      results,
    };
  }

  async claimUplinkMatchCandidate(uplinkMessageId: string, candidateId: string, operatorId?: string) {
    const candidate = await this.prisma.smsUplinkMatchCandidate.findFirst({
      where: { id: candidateId, uplinkMessageId },
      include: {
        application: { select: { id: true, name: true, cmppAccount: true } },
        messageRecord: { select: { id: true, messageId: true, content: true } },
        uplinkMessage: true,
      },
    });
    if (!candidate) {
      throw new NotFoundException('Uplink match candidate not found');
    }
    if (candidate.status === 'rejected') {
      throw new BadRequestException('该候选已被排除，不能认领');
    }
    if (candidate.uplinkMessage.matchStatus === 'matched' && candidate.status !== 'claimed') {
      throw new BadRequestException('该上行记录已完成匹配，不能重复认领');
    }
    const claimedAt = new Date();
    const messageId = candidate.uplinkMessage.messageId ?? candidate.messageRecord?.messageId ?? null;
    const [updatedUplink] = await this.prisma.$transaction([
      this.prisma.smsUplinkMessage.update({
        where: { id: uplinkMessageId },
        data: {
          tenantId: candidate.tenantId,
          applicationId: candidate.applicationId,
          messageRecordId: candidate.messageRecordId,
          messageId,
          matchStatus: 'matched',
          matchReason: `人工认领：${candidate.reason ?? candidate.matchSource}`,
        },
      }),
      this.prisma.smsUplinkMatchCandidate.updateMany({
        where: {
          uplinkMessageId,
          id: { not: candidate.id },
          status: 'pending',
        },
        data: { status: 'rejected' },
      }),
      this.prisma.smsUplinkMatchCandidate.update({
        where: { id: candidate.id },
        data: {
          status: 'claimed',
          claimedAt,
          claimedById: operatorId,
        },
      }),
      this.prisma.operationLog.create({
        data: {
          tenantId: candidate.tenantId,
          userId: operatorId,
          action: 'gateway.uplink_manual_claim',
          resource: 'sms_uplink_message',
          resourceId: uplinkMessageId,
          detail: {
            candidateId: candidate.id,
            applicationId: candidate.applicationId,
            applicationName: candidate.application.name,
            messageRecordId: candidate.messageRecordId,
            messageId,
            matchSource: candidate.matchSource,
            phoneNumber: candidate.uplinkMessage.phoneNumber,
            destId: candidate.uplinkMessage.destId,
          },
        },
      }),
    ]);

    await this.queueAndTryDownstreamDelivery({
      tenantId: candidate.tenantId,
      applicationId: candidate.applicationId,
      messageRecordId: candidate.messageRecordId,
      messageId,
      deliveryType: 'uplink',
      payload: {
        messageId,
        applicationId: candidate.applicationId,
        phoneNumber: candidate.uplinkMessage.phoneNumber,
        destId: candidate.uplinkMessage.destId,
        content: candidate.uplinkMessage.content,
        receivedAt: candidate.uplinkMessage.receivedAt.toISOString(),
        manualClaim: true,
        uplinkMessageId,
      },
    });
    return this.prisma.smsUplinkMessage.findUnique({
      where: { id: updatedUplink.id },
      include: {
        tenant: true,
        application: true,
        channel: true,
        messageRecord: { include: { application: true } },
        matchCandidates: {
          include: {
            tenant: true,
            application: true,
            messageRecord: { include: { application: true, tenant: true, channel: true } },
          },
          orderBy: [{ status: 'asc' }, { confidence: 'desc' }, { createdAt: 'asc' }],
        },
      },
    });
  }

  private async queueAndTryDownstreamDelivery(data: {
    tenantId: string;
    applicationId?: string | null;
    messageRecordId?: string | null;
    messageId?: string | null;
    deliveryType: 'receipt' | 'uplink';
    payload: Record<string, unknown>;
  }) {
    if (!data.applicationId) {
      return null;
    }
    const application = await this.prisma.smsApplication.findUnique({
      where: { id: data.applicationId },
      select: {
        cmppAccount: true,
        interfaceEnabled: true,
        downstreamReceiptRetryEnabled: true,
        downstreamUplinkRetryEnabled: true,
        httpConfig: true,
      },
    });
    try {
      await this.openApi?.queueWebhookEvent({
        tenantId: data.tenantId,
        applicationId: data.applicationId,
        messageRecordId: data.messageRecordId,
        messageId: data.messageId,
        uplinkMessageId: typeof data.payload.uplinkMessageId === 'string' ? data.payload.uplinkMessageId : undefined,
        eventType: data.deliveryType,
        payload: data.payload,
      });
    } catch (error) {
      this.logger.error(`HTTP webhook queue failed for ${data.deliveryType}/${data.messageId ?? '-'}: ${error instanceof Error ? error.message : String(error)}`);
    }
    if (application?.interfaceEnabled !== true) {
      return null;
    }
    const payload = { account: application?.cmppAccount, applicationId: data.applicationId, ...data.payload };
    const delivery = await this.prisma.cmppDownstreamDelivery.create({
      data: {
        tenantId: data.tenantId,
        applicationId: data.applicationId,
        messageRecordId: data.messageRecordId,
        messageId: data.messageId,
        deliveryType: data.deliveryType,
        payload,
        retryEnabled: data.deliveryType === 'uplink'
          ? application?.downstreamUplinkRetryEnabled ?? true
          : application?.downstreamReceiptRetryEnabled ?? true,
        status: 'pending',
      },
    });
    try {
      const result = await this.postGatewayControl(
        data.deliveryType === 'receipt' ? '/downstream/receipt' : '/downstream/uplink',
        { deliveryId: delivery.id, ...payload },
      ) as GatewayControlDeliveryResult;
      if (result.sent || result.delivered) {
        await this.markDownstreamDeliverySent({ id: delivery.id, ...result });
      } else {
        await this.markDownstreamDeliveryFailed(
          delivery.id,
          downstreamControlFailureMessage(result),
          result.retryable === false ? 'unrecoverable' : 'send_failed',
        );
      }
    } catch (error) {
      await this.markDownstreamDeliveryFailed(delivery.id, error instanceof Error ? error.message : 'Gateway control delivery failed');
    }
    return delivery;
  }

  private async resolveUplinkMatch(
    data: GatewayUplinkEventDto,
    channel: { id: string; srcId?: string | null },
  ): Promise<{
    tenantId?: string;
    applicationId?: string;
    messageRecordId?: string;
    matchStatus: string;
    matchReason: string;
    candidates: UplinkMatchCandidateInput[];
  }> {
    if (data.messageId) {
      const message = await this.prisma.smsMessageRecord.findUnique({ where: { messageId: data.messageId } });
      if (message?.tenantId) {
        return {
          tenantId: message.tenantId,
          applicationId: message.applicationId ?? undefined,
          messageRecordId: message.id,
          matchStatus: message.applicationId ? 'matched' : 'unmatched',
          matchReason: message.applicationId ? 'messageId 精确匹配' : 'messageId 匹配到下发记录但无应用',
          candidates: [],
        };
      }
    }

    const accessNumber = data.destId || channel.srcId || '';
    const accessRoutes = accessNumber
      ? await this.prisma.channelRouteRule.findMany({
        where: {
          applicationId: { not: null },
          status: 'active',
          group: { items: { some: { channelId: channel.id, channel: { srcId: accessNumber } } } },
        },
        select: { applicationId: true },
        take: 10,
      })
      : [];
    const accessApplicationIds = [...new Set(accessRoutes.map((route) => route.applicationId).filter((value): value is string => Boolean(value)))];
    const accessApplications = accessApplicationIds.length > 0
      ? await this.prisma.smsApplication.findMany({
        where: { id: { in: accessApplicationIds }, status: 'active' },
        select: { id: true, tenantId: true, name: true },
      })
      : [];
    if (accessApplications.length === 1) {
      return {
        tenantId: accessApplications[0].tenantId,
        applicationId: accessApplications[0].id,
        matchStatus: 'matched',
        matchReason: '接入号唯一匹配应用',
        candidates: [],
      };
    }
    if (accessApplications.length > 1) {
      return {
        matchStatus: 'ambiguous',
        matchReason: '接入号匹配多个应用',
        candidates: accessApplications.map((application) => ({
          tenantId: application.tenantId,
          applicationId: application.id,
          matchSource: 'access_number',
          confidence: 70,
          reason: `接入号 ${accessNumber} 可匹配应用 ${application.name}`,
        })),
      };
    }

    const windowHours = Number(process.env.UPLINK_MATCH_WINDOW_HOURS ?? 72);
    const since = new Date(Date.now() - Math.max(1, windowHours) * 60 * 60 * 1000);
    const recentMessages = await this.prisma.smsMessageRecord.findMany({
      where: {
        phoneNumber: data.phoneNumber,
        tenantId: { not: null },
        applicationId: { not: null },
        submittedAt: { gte: since },
      },
      orderBy: { submittedAt: 'desc' },
      take: 2,
    });
    const matchableRecentMessages = recentMessages.filter((message) => message.tenantId && message.applicationId);
    if (matchableRecentMessages.length === 1) {
      return {
        tenantId: matchableRecentMessages[0].tenantId ?? undefined,
        applicationId: matchableRecentMessages[0].applicationId ?? undefined,
        messageRecordId: matchableRecentMessages[0].id,
        matchStatus: 'matched',
        matchReason: `手机号 ${windowHours} 小时窗口唯一匹配`,
        candidates: [],
      };
    }
    if (matchableRecentMessages.length > 1) {
      return {
        matchStatus: 'ambiguous',
        matchReason: `手机号 ${windowHours} 小时窗口匹配多条下发记录`,
        candidates: matchableRecentMessages
          .map((message) => ({
            tenantId: String(message.tenantId),
            applicationId: String(message.applicationId),
            messageRecordId: message.id,
            matchSource: 'phone_window',
            confidence: 55,
            reason: `手机号 ${windowHours} 小时窗口候选下发 ${message.messageId}`,
          })),
      };
    }
    return { matchStatus: 'unmatched', matchReason: '未匹配到应用或下发记录', candidates: [] };
  }

  async authenticateInboundApplication(data: GatewayInboundAuthDto) {
    const application = await this.findInboundApplication(data.account);
    if (!application || application.status !== 'active' || application.tenant.status !== 'active') {
      throw new BadRequestException('CMPP account is invalid or disabled');
    }
    if (!application.interfaceEnabled) {
      throw new BadRequestException('CMPP interface is disabled for this application');
    }
    if (application.tenant.certificationStatus !== 'approved') {
      throw new BadRequestException('Enterprise certification is not approved');
    }
    if (!matchesApplicationSecret(data, application.secretHash)) {
      throw new BadRequestException('CMPP account or password is invalid');
    }
    if (data.remoteIp && !isIpAllowed(data.remoteIp, application.ipAllowlist.map((item) => item.ipCidr))) {
      throw new BadRequestException('CMPP source IP is not in application allowlist');
    }
    return {
      applicationId: application.id,
      tenantId: application.tenantId,
      account: application.cmppAccount,
      enterpriseCode: application.cmppEnterpriseCode,
      passwordCipher: application.secretHash,
      maxConnections: application.cmppMaxConnections,
      status: 'authenticated',
    };
  }

  async submitInboundMessage(data: GatewayInboundSubmitDto) {
    const phoneNumbers = data.phoneNumbers?.length
      ? data.phoneNumbers.map((phoneNumber) => phoneNumber.trim())
      : data.phoneNumber
        ? [data.phoneNumber.trim()]
        : [];
    if (phoneNumbers.length === 0 || phoneNumbers.some((phoneNumber) => !/^1[3-9]\d{9}$/.test(phoneNumber))) {
      throw new BadRequestException('CMPP submit phone number is invalid');
    }

    const application = await this.findInboundApplication(data.account);
    if (!application) {
      throw new BadRequestException('CMPP account is invalid');
    }
    if (data.longMessage) {
      if (data.remoteIp && !isIpAllowed(data.remoteIp, application.ipAllowlist.map((item) => item.ipCidr))) {
        throw new BadRequestException('CMPP source IP is not in application allowlist');
      }
      validateInboundApplicationSrcId(data.srcId, application);
      const collection = await this.collectInboundLongMessageFragment(data, application, phoneNumbers);
      if (collection.response) {
        return collection.response;
      }
      if (!collection.complete) {
        return {
          accepted: true,
          tenantId: application.tenantId,
          applicationId: application.id,
          messageId: collection.messageId,
          status: 'fragment_pending',
          fragmentPending: true,
          receivedSegments: collection.receivedSegments,
          segmentTotal: data.longMessage.total,
          phoneCount: phoneNumbers.length,
          messages: phoneNumbers.map((phoneNumber) => ({
            phoneNumber,
            messageId: collection.messageId,
            status: 'fragment_pending',
          })),
        };
      }
      try {
        const response = await this.recoverCompletedInboundLongMessageResponse(
          collection.messageId,
          phoneNumbers,
        ) ?? await this.submitCompleteInboundMessage({
          ...data,
          content: collection.content,
          sequenceId: collection.sequenceId,
          longMessage: undefined,
        }, phoneNumbers, application, collection.messageId);
        await this.prisma.cmppInboundLongMessage.update({
          where: { id: collection.groupId },
          data: {
            status: 'completed',
            response: JSON.parse(JSON.stringify(response)) as Prisma.InputJsonValue,
            completedAt: new Date(),
          },
        });
        return response;
      } catch (error) {
        await this.prisma.cmppInboundLongMessage.update({
          where: { id: collection.groupId },
          data: {
            status: 'rejected',
            completedAt: new Date(),
          },
        }).catch(() => undefined);
        throw error;
      }
    }
    return this.submitCompleteInboundMessage(data, phoneNumbers, application);
  }

  private async recoverCompletedInboundLongMessageResponse(messageId: string, phoneNumbers: string[]) {
    const existing = await this.prisma.smsMessageRecord.findMany({
      where: {
        cmppSubmitGroupMessageId: messageId,
        phoneNumber: { in: phoneNumbers },
      },
      select: {
        id: true,
        tenantId: true,
        applicationId: true,
        batchTaskId: true,
        messageId: true,
        phoneNumber: true,
        status: true,
        errorCode: true,
      },
    });
    const byPhone = new Map(existing.map((item) => [item.phoneNumber, item]));
    const ordered = phoneNumbers.map((phoneNumber) => byPhone.get(phoneNumber));
    if (ordered.some((item) => !item)) {
      return null;
    }
    const messages = ordered.map((item, index) => ({
      phoneNumber: phoneNumbers[index],
      messageId: item!.messageId,
      messageRecordId: item!.id,
      taskId: item!.batchTaskId ?? '',
      status: item!.status,
    }));
    const first = ordered[0]!;
    const dailyLimitRejected = ordered.every((item) => item!.errorCode === 'DAILY_LIMIT');
    return {
      accepted: !dailyLimitRejected,
      tenantId: first.tenantId ?? '',
      applicationId: first.applicationId ?? '',
      taskId: first.batchTaskId ?? '',
      messageId: first.messageId,
      messageRecordId: first.id,
      status: dailyLimitRejected ? 'rejected' : 'accepted',
      result: dailyLimitRejected ? 8 : undefined,
      phoneCount: messages.length,
      messages,
    };
  }

  private async submitCompleteInboundMessage(
    data: GatewayInboundSubmitDto,
    phoneNumbers: string[],
    application: Awaited<ReturnType<SendChainService['findInboundApplication']>>,
    requestedGroupMessageId?: string,
  ) {
    if (!application) {
      throw new BadRequestException('CMPP account is invalid');
    }
    const persisted = requestedGroupMessageId
      ? await this.prisma.smsMessageRecord.findMany({
          where: {
            cmppSubmitGroupMessageId: requestedGroupMessageId,
            phoneNumber: { in: phoneNumbers },
          },
          select: {
            id: true,
            tenantId: true,
            applicationId: true,
            batchTaskId: true,
            messageId: true,
            phoneNumber: true,
            status: true,
            errorCode: true,
          },
        })
      : [];
    const persistedByPhone = new Map(persisted.map((item) => [item.phoneNumber, item]));
    const missingPhoneCount = phoneNumbers.filter((phoneNumber) => !persistedByPhone.has(phoneNumber)).length;
    const dailyQuota = missingPhoneCount > 0
      ? await this.tryReserveDailySendQuota(application.id, missingPhoneCount)
      : { reserved: true, dailyLimit: application.dailyLimit ?? 100000 };
    const dailyLimitRejection = dailyQuota.reserved
      ? undefined
      : {
          code: 'DAILY_LIMIT',
          reason: `应用当日发送上限${dailyQuota.dailyLimit}条，本次${missingPhoneCount}条超出剩余配额`,
        };

    const submitGroupMessageId = requestedGroupMessageId ?? `MSG-${randomUUID()}`;
    const submissions = phoneNumbers.map((phoneNumber, index) => ({
      phoneNumber,
      persisted: persistedByPhone.get(phoneNumber),
      messageId: persistedByPhone.get(phoneNumber)?.messageId
        ?? (index === 0 ? submitGroupMessageId : `MSG-${randomUUID()}`),
    }));
    const results: GatewayInboundSingleSubmitResult[] = [];
    const concurrency = 10;
    for (let offset = 0; offset < submissions.length; offset += concurrency) {
      const batch = submissions.slice(offset, offset + concurrency);
      results.push(...await Promise.all(batch.map((submission) => submission.persisted
        ? Promise.resolve({
            accepted: submission.persisted.errorCode !== 'DAILY_LIMIT',
            tenantId: submission.persisted.tenantId ?? application.tenantId,
            applicationId: submission.persisted.applicationId ?? application.id,
            taskId: submission.persisted.batchTaskId ?? '',
            messageId: submission.persisted.messageId,
            messageRecordId: submission.persisted.id,
            status: submission.persisted.status,
          })
        : this.submitInboundSingleMessage({
            ...data,
            phoneNumber: submission.phoneNumber,
            phoneNumbers: undefined,
          }, submission.messageId, submitGroupMessageId, dailyLimitRejection))));
    }
    const first = results[0];
    return {
      ...first,
      result: dailyLimitRejection ? 8 : undefined,
      phoneCount: results.length,
      messages: results.map((result, index) => ({
        phoneNumber: phoneNumbers[index],
        messageId: result.messageId,
        messageRecordId: result.messageRecordId,
        taskId: result.taskId,
        status: result.status,
      })),
    };
  }

  private async collectInboundLongMessageFragment(
    data: GatewayInboundSubmitDto,
    application: NonNullable<Awaited<ReturnType<SendChainService['findInboundApplication']>>>,
    phoneNumbers: string[],
  ) {
    const fragment = data.longMessage;
    if (!fragment || !Number.isInteger(fragment.reference) || fragment.reference < 0 || fragment.reference > 65535
      || !Number.isInteger(fragment.total) || fragment.total < 2 || fragment.total > 255
      || !Number.isInteger(fragment.index) || fragment.index < 1 || fragment.index > fragment.total
      || !Number.isInteger(fragment.format) || fragment.format < 0 || fragment.format > 255) {
      throw new BadRequestException('CMPP long message fragment metadata is invalid');
    }
    const groupKey = createHash('sha256').update(JSON.stringify({
      applicationId: application.id,
      account: data.account,
      srcId: data.srcId?.trim() ?? '',
      phoneNumbers,
      reference: fragment.reference,
      total: fragment.total,
      format: fragment.format,
    })).digest('hex');
    const contentHash = createHash('sha256').update(data.content).digest('hex');
    const now = new Date();
    const expiresAt = new Date(now.getTime() + positiveInteger(
      process.env.CMPP_INBOUND_LONG_MESSAGE_TTL_SECONDS,
      300,
    ) * 1000);

    return this.prisma.$transaction(async (tx) => {
      await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtextextended(${groupKey}, 0))`;
      await tx.cmppInboundLongMessage.updateMany({
        where: {
          groupKey,
          status: { in: ['collecting', 'processing'] },
          expiresAt: { lte: now },
        },
        data: { status: 'expired', completedAt: now },
      });

      const recent = await tx.cmppInboundLongMessage.findFirst({
        where: {
          groupKey,
          expiresAt: { gt: now },
        },
        include: { segments: { orderBy: { segmentIndex: 'asc' } } },
        orderBy: { createdAt: 'desc' },
      });
      const matchingRecentSegment = recent?.segments.find((item) => item.segmentIndex === fragment.index);
      if (recent && ['completed', 'rejected'].includes(recent.status)
        && matchingRecentSegment?.contentHash === contentHash
        && matchingRecentSegment.sequenceId === (data.sequenceId == null ? null : String(data.sequenceId))) {
        return {
          complete: recent.status === 'completed',
          groupId: recent.id,
          messageId: recent.messageId,
          receivedSegments: recent.segments.length,
          response: recent.response as any,
          content: recent.segments.map((item) => item.content).join(''),
          sequenceId: parseOptionalSequenceId(recent.segments[0]?.sequenceId),
        };
      }

      let group = recent && ['collecting', 'processing'].includes(recent.status) ? recent : null;
      if (!group) {
        group = await tx.cmppInboundLongMessage.create({
          data: {
            tenantId: application.tenantId,
            applicationId: application.id,
            groupKey,
            account: data.account,
            srcId: data.srcId?.trim() || null,
            phoneNumbers,
            concatReference: fragment.reference,
            segmentTotal: fragment.total,
            msgFmt: fragment.format,
            messageId: `MSG-${randomUUID()}`,
            expiresAt,
          },
          include: { segments: { orderBy: { segmentIndex: 'asc' } } },
        });
      }
      if (group.status === 'processing') {
        const processingStaleMs = positiveInteger(
          process.env.CMPP_INBOUND_LONG_MESSAGE_PROCESSING_STALE_SECONDS,
          DEFAULT_INBOUND_LONG_MESSAGE_PROCESSING_STALE_SECONDS,
        ) * 1000;
        const complete = group.segments.length === fragment.total
          && group.segments.every((item, index) => item.segmentIndex === index + 1);
        if (complete && now.getTime() - group.updatedAt.getTime() >= processingStaleMs) {
          await tx.cmppInboundLongMessage.update({
            where: { id: group.id },
            data: { status: 'processing', expiresAt },
          });
          return {
            complete: true,
            groupId: group.id,
            messageId: group.messageId,
            receivedSegments: group.segments.length,
            response: null,
            content: group.segments.map((item) => item.content).join(''),
            sequenceId: parseOptionalSequenceId(group.segments[0]?.sequenceId),
          };
        }
        return {
          complete: false,
          groupId: group.id,
          messageId: group.messageId,
          receivedSegments: group.segments.length,
          response: group.response as any,
          content: '',
          sequenceId: undefined,
        };
      }

      const existing = group.segments.find((item) => item.segmentIndex === fragment.index);
      if (existing && (existing.contentHash !== contentHash
        || existing.sequenceId !== (data.sequenceId == null ? null : String(data.sequenceId)))) {
        throw new BadRequestException(`CMPP long message fragment ${fragment.index} conflicts with the stored fragment`);
      }
      if (!existing) {
        await tx.cmppInboundLongMessageSegment.create({
          data: {
            groupId: group.id,
            segmentIndex: fragment.index,
            sequenceId: data.sequenceId == null ? null : String(data.sequenceId),
            content: data.content,
            contentHash,
          },
        });
      }
      const segments = await tx.cmppInboundLongMessageSegment.findMany({
        where: { groupId: group.id },
        orderBy: { segmentIndex: 'asc' },
      });
      const complete = segments.length === fragment.total
        && segments.every((item, index) => item.segmentIndex === index + 1);
      if (complete) {
        await tx.cmppInboundLongMessage.update({
          where: { id: group.id },
          data: { status: 'processing', expiresAt },
        });
      }
      return {
        complete,
        groupId: group.id,
        messageId: group.messageId,
        receivedSegments: segments.length,
        response: null,
        content: complete ? segments.map((item) => item.content).join('') : '',
        sequenceId: parseOptionalSequenceId(segments[0]?.sequenceId),
      };
    });
  }

  async expireInboundLongMessages(now = new Date()) {
    return this.prisma.cmppInboundLongMessage.updateMany({
      where: {
        status: { in: ['collecting', 'processing'] },
        expiresAt: { lte: now },
      },
      data: {
        status: 'expired',
        completedAt: now,
      },
    });
  }

  private async submitInboundSingleMessage(
    data: GatewayInboundSubmitDto & { phoneNumber: string },
    messageId: string,
    submitGroupMessageId: string,
    synchronousRejection?: { code: string; reason: string },
  ) {
    const application = await this.findInboundApplication(data.account);
    if (!application) {
      throw new BadRequestException('CMPP account is invalid');
    }
    if (data.remoteIp && !isIpAllowed(data.remoteIp, application.ipAllowlist.map((item) => item.ipCidr))) {
      throw new BadRequestException('CMPP source IP is not in application allowlist');
    }
    if (!/^1[3-9]\d{9}$/.test(data.phoneNumber)) {
      throw new BadRequestException('CMPP submit phone number is invalid');
    }
    const clientSrcId = validateInboundApplicationSrcId(data.srcId, application);
    const template = await this.resolveInboundTemplateCandidate(application.id, data.content);
    const templateVariables = template ? matchTemplateContent(template.content, data.content) ?? {} : {};
    const unitPrice = moneyToNumber(application.customerUnitPrice);
    const queuePriority = normalizeQueuePriority(application.queuePriority);
    const billing = this.billing.estimateSmsCost({
      tenantId: application.tenantId,
      applicationId: application.id,
      content: data.content,
      phoneCount: 1,
      unitPrice,
    });
    const task = await this.prisma.smsBatchTask.create({
      data: {
        tenantId: application.tenantId,
        applicationId: application.id,
        templateId: template?.id,
        taskNo: `BT-${Date.now()}-${randomUUID().slice(0, 8)}`,
        sourceType: 'cmpp',
        content: data.content,
        phoneTotal: 1,
        status: synchronousRejection ? 'rejected' : 'validating',
        auditStatus: synchronousRejection ? 'rejected' : undefined,
        rejectReason: synchronousRejection?.reason,
        progressTotal: 1,
      },
    });
    await this.prisma.smsApiRequest.create({
      data: {
        tenantId: application.tenantId,
        batchTaskId: task.id,
        requestId: `REQ-${Date.now()}-${randomUUID().slice(0, 8)}`,
        sourceIp: data.remoteIp,
        userAgent: 'cmpp-gateway',
        payloadSummary: { phoneTotal: 1, contentLength: [...data.content].length, account: data.account },
        status: synchronousRejection ? 'rejected' : 'accepted',
      },
    });
    const message = await this.prisma.smsMessageRecord.create({
      data: {
        tenantId: application.tenantId,
        batchTaskId: task.id,
        applicationId: application.id,
        templateId: template?.id,
        messageId,
        phoneNumber: data.phoneNumber,
        content: data.content,
        billingUnits: billing.billingUnitsPerMessage,
        unitPrice: billing.unitPrice,
        amountCents: billing.amountCents,
        queuePriority,
        cmppSubmitSequenceId: data.sequenceId == null ? null : String(data.sequenceId),
        cmppSubmitGroupMessageId: submitGroupMessageId,
        clientSrcId,
        applicationExtension: application.cmppApplicationExtension,
        status: synchronousRejection ? 'rejected' : 'validating',
        errorCode: synchronousRejection?.code,
        errorMessage: synchronousRejection?.reason,
      },
    });

    if (synchronousRejection) {
      return {
        accepted: false,
        tenantId: application.tenantId,
        applicationId: application.id,
        taskId: task.id,
        messageId: message.messageId,
        messageRecordId: message.id,
        status: 'rejected',
      };
    }

    const reject = async (code: string, reason: string) => {
      await this.prisma.smsBatchTask.update({
        where: { id: task.id },
        data: { status: 'rejected', auditStatus: 'rejected', rejectReason: reason },
      });
      await this.recordCmppFailureReceipt(message, code, reason);
    };
    const queueAfterRiskChecks = async (options: { templateId?: string; signatureId?: string }) => {
      const drainage = await this.resolveDrainageInfoMatch(options.signatureId, data.content);
      const drainageInfoId = drainage?.id;
      const drainageReason = drainageRejectionReason(drainage);
      if (drainageReason) {
        await this.prisma.smsMessageRecord.update({
          where: { id: message.id },
          data: { drainageInfoId, signatureId: options.signatureId },
        });
        await reject('DRAINAGE_NOT_APPROVED', drainageReason);
        return;
      }
      const risk = await this.riskReview.evaluateTask({
        tenantId: application.tenantId,
        applicationId: application.id,
        templateId: options.templateId,
        content: data.content,
        variables: options.templateId ? templateVariables : undefined,
        phones: [data.phoneNumber],
      });
      if (risk.status === 'rejected') {
        await reject('RISK', risk.reason || '短信被风控拒绝');
        return;
      }
      if (risk.status === 'pending_review') {
        await this.prisma.smsMessageRecord.update({
          where: { id: message.id },
          data: { status: 'pending_review', signatureId: options.signatureId, drainageInfoId },
        });
        await this.prisma.smsBatchTask.update({
          where: { id: task.id },
          data: { status: 'pending_review', riskTaskId: risk.task?.id, auditStatus: 'pending', reviewReason: risk.reason },
        });
        return;
      }
      const accountCheck = await this.billing.checkAccount({
        tenantId: application.tenantId,
        amountCents: billing.amountCents,
      });
      if (!accountCheck.canSend) {
        await reject('BALANCE', '企业账户余额不足');
        return;
      }
      if (billing.amountCents > 0) {
        await this.billing.freeze({
          tenantId: application.tenantId,
          amountCents: billing.amountCents,
          relatedType: 'sms_batch_task',
          relatedId: task.id,
          remark: 'CMPP 入站短信冻结',
        });
      }
      await this.prisma.smsMessageRecord.update({
        where: { id: message.id },
        data: { status: 'queued', signatureId: options.signatureId, drainageInfoId },
      });
      await this.prisma.smsBatchTask.update({
        where: { id: task.id },
        data: { status: 'ready', riskTaskId: risk.task?.id, auditStatus: 'approved' },
      });
      await this.enqueueBatchTask(task.id);
    };
    if (application.status !== 'active' || application.tenant.status !== 'active') {
      await reject('ACCOUNT', '企业或短信应用已停用');
    } else if (!application.interfaceEnabled) {
      await reject('INTERFACE', '短信应用 CMPP 接口已停用');
    } else if (application.tenant.certificationStatus !== 'approved') {
      await reject('CERT', '企业认证未通过');
    } else if (!template && application.templateMismatchMode === 'manual_review') {
      const signature = await this.resolveInboundSignatureCandidate(application.id, data.content);
      if (!signature) {
        await reject('SIGNATURE', '短信内容未识别到已审核通过的签名');
      } else {
        const drainage = await this.resolveDrainageInfoMatch(signature.id, data.content);
        const drainageReason = drainageRejectionReason(drainage);
        if (drainageReason) {
          await this.prisma.smsMessageRecord.update({
            where: { id: message.id },
            data: { drainageInfoId: drainage?.id, signatureId: signature.id },
          });
          await reject('DRAINAGE_NOT_APPROVED', drainageReason);
          return {
            accepted: true,
            tenantId: application.tenantId,
            applicationId: application.id,
            messageId,
            messageRecordId: message.id,
            taskId: task.id,
            status: 'rejected',
          };
        }
        const risk = await this.riskReview.evaluateTask({
          tenantId: application.tenantId,
          applicationId: application.id,
          content: data.content,
          phones: [data.phoneNumber],
        });
        if (risk.status === 'rejected') {
          await reject('RISK', risk.reason || '短信被风控拒绝');
        } else {
          const accountCheck = await this.billing.checkAccount({
            tenantId: application.tenantId,
            amountCents: billing.amountCents,
          });
          if (!accountCheck.canSend) {
            await reject('BALANCE', '企业账户余额不足');
          } else {
            if (billing.amountCents > 0) {
              await this.billing.freeze({
                tenantId: application.tenantId,
                amountCents: billing.amountCents,
                relatedType: 'sms_batch_task',
                relatedId: task.id,
                remark: 'CMPP 模板不匹配待审核短信冻结',
              });
            }
            const reviewTask = risk.status === 'pending_review' && risk.task
              ? await this.attachMessageToReviewTask(risk.task.id, message.id, signature.id, drainage?.id)
              : await this.riskReview.aggregateTemplateMismatch({
                tenantId: application.tenantId,
                applicationId: application.id,
                account: data.account,
                messageRecordId: message.id,
                signatureId: signature.id,
                content: data.content,
              });
            await this.prisma.smsBatchTask.update({
              where: { id: task.id },
              data: {
                status: 'pending_review',
                riskTaskId: reviewTask?.id,
                auditStatus: 'pending',
                reviewReason: reviewTask?.reviewReason ?? '模板不匹配，等待人工审核',
              },
            });
          }
        }
      }
    } else if (!template && application.templateMismatchMode === 'direct_send') {
      const signature = await this.resolveInboundSignatureCandidate(application.id, data.content);
      if (!signature) {
        await reject('SIGNATURE', '短信内容未识别到已审核通过的签名');
      } else {
        await queueAfterRiskChecks({ signatureId: signature.id });
      }
    } else if (!template) {
      await reject('TEMPLATE', '短信内容未匹配到已报备模板');
    } else if (template.auditStatus !== 'approved') {
      await reject('TEMPLATE', '短信模板尚未审核通过');
    } else if (!template.signature || template.signature.auditStatus !== 'approved') {
      await reject('SIGNATURE', '短信签名尚未审核通过');
    } else {
      await queueAfterRiskChecks({ templateId: template.id, signatureId: template.signature.id });
    }
    return {
      accepted: true,
      tenantId: application.tenantId,
      applicationId: application.id,
      taskId: task.id,
      messageId: message.messageId,
      messageRecordId: message.id,
      status: 'accepted',
    };
  }

  async markUnknownTimeout(data: TimeoutUnknownDto) {
    const olderThanHours = data.olderThanHours ?? positiveInteger(process.env.SMS_RECEIPT_TIMEOUT_HOURS, DEFAULT_RECEIPT_TIMEOUT_HOURS);
    const cutoff = new Date(Date.now() - olderThanHours * 60 * 60 * 1000);
    const candidates = await this.prisma.smsMessageRecord.findMany({
      where: {
        tenantId: { not: null },
        status: { in: ['submitted', 'unknown'] },
        submittedAt: { lte: cutoff },
      },
      select: { id: true, tenantId: true, batchTaskId: true, messageId: true, amountCents: true, billingUnits: true },
      take: 10000,
    });
    const timedOutTaskIds = new Set<string>();
    let timeout = 0;
    for (const candidate of candidates) {
      if (!candidate.tenantId) continue;
      const transitioned = await this.prisma.smsMessageRecord.updateMany({
        where: { id: candidate.id, status: { in: ['submitted', 'unknown'] } },
        data: { status: 'timeout', timeoutAt: new Date(), errorMessage: `${olderThanHours}小时未收到明确回执，自动转超时` },
      });
      if (transitioned.count !== 1) continue;
      timeout += 1;
      await this.refundMessage(candidate as typeof candidate & { tenantId: string }, `${olderThanHours}小时未收到明确回执，自动超时退款`);
      if (candidate.batchTaskId) timedOutTaskIds.add(candidate.batchTaskId);
    }
    for (const batchTaskId of timedOutTaskIds) {
      await this.refreshTaskProgress(batchTaskId);
    }
    return { timeout };
  }

  async markExpiredDownstreamDeliveries(olderThanHours = downstreamPendingTimeoutHours()) {
    const cutoff = new Date(Date.now() - olderThanHours * 60 * 60_000);
    const expired = await this.prisma.cmppDownstreamDelivery.findMany({
      where: {
        status: 'pending',
        OR: [
          { lastRetriedAt: null, createdAt: { lte: cutoff } },
          { lastRetriedAt: { lte: cutoff } },
        ],
      },
      select: { id: true },
      take: 500,
    });
    for (const delivery of expired) {
      await this.markDownstreamDeliveryFailed(
        delivery.id,
        `下游投递排队超过 ${olderThanHours} 小时，系统自动终止重试`,
        'queue_timeout',
      );
    }
    return { failed: expired.length };
  }

  private async runReceiptTimeoutScan() {
    if (this.receiptTimeoutScanRunning) return;
    this.receiptTimeoutScanRunning = true;
    try {
      const [receiptResult, downstreamResult, requeueRecoveryResult, downstreamManualRecoveryResult] = await Promise.all([
        this.markUnknownTimeout({}),
        this.markExpiredDownstreamDeliveries(),
        this.recoverStaleGatewaySubmitRequeues(),
        this.recoverStaleDownstreamManualRequeues(),
      ]);
      if (receiptResult.timeout > 0) this.logger.log(`Marked ${receiptResult.timeout} messages as receipt timeout and refunded charged messages`);
      if (downstreamResult.failed > 0) this.logger.log(`Terminated ${downstreamResult.failed} expired downstream deliveries`);
      if (requeueRecoveryResult.recovered > 0) this.logger.log(`Recovered ${requeueRecoveryResult.recovered} stale Gateway submit requeues`);
      if (downstreamManualRecoveryResult.recovered > 0) this.logger.log(`Recovered ${downstreamManualRecoveryResult.recovered} stale downstream manual requeues`);
    } catch (error) {
      this.logger.error('Receipt timeout scan failed', error instanceof Error ? error.stack : String(error));
    } finally {
      this.receiptTimeoutScanRunning = false;
    }
  }

  private async submitMessageToGateway(
    message: {
      id: string;
      tenantId: string;
      batchTaskId: string;
      applicationId?: string | null;
      templateId?: string | null;
      messageId: string;
      phoneNumber: string;
      content: string;
      billingUnits: number;
      queuePriority?: string | null;
      clientSrcId?: string | null;
      applicationExtension?: string | null;
      template?: { signature?: { id?: string | null; name?: string | null } | null } | null;
      signature?: { id?: string | null; name?: string | null } | null;
    },
    routed: RoutedChannel,
    attempt: number,
  ) {
    const channel = routed.channel;
    const upstreamSrcId = composeUpstreamSrcId(channel.srcId, message.applicationExtension);
    await this.ensureSignatureReportedForChannel(message, channel.id);
    await this.waitForChannelRateLimit(channel.id, channel.rateLimitPerSecond);
    const submitId = `SUB-${randomUUID()}`;
    const session = await this.prisma.cmppSubmitSession.upsert({
      where: { sessionNo: `OPEN-${channel.id}` },
      update: { submitTotal: { increment: 1 } },
      create: { channelId: channel.id, sessionNo: `OPEN-${channel.id}`, submitTotal: 1 },
    });
    await this.prisma.smsSubmitRecord.create({
      data: {
        tenantId: message.tenantId,
        batchTaskId: message.batchTaskId,
        messageRecordId: message.id,
        channelId: channel.id,
        sessionId: session.id,
        submitId,
        submitStatus: 'queued',
        costUnitPrice: channel.unitPrice ?? 0,
        costAmountCents: moneyToNumber(channel.unitPrice) * Math.max(1, message.billingUnits ?? 1),
      },
    });
    await this.prisma.smsMessageRecord.update({
      where: { id: message.id },
      data: {
        channelId: channel.id,
        carrier: routed.carrier,
        province: routed.province,
        submitId,
        status: 'submit_queued',
        submitStatus: 'queued',
        receiptStatus: null,
        errorCode: null,
        errorMessage: attempt > 0 ? `第 ${attempt + 1} 次提交，路由至${routed.routeScope === 'national' ? '全国' : '省网'}通道` : undefined,
      },
    });
    const command = {
      schemaVersion: 'v1',
      messageType: 'SubmitCommand',
      traceId: randomUUID(),
      messageId: message.messageId,
      channelId: channel.id,
      createdAt: new Date().toISOString(),
      tenantId: message.tenantId,
      applicationId: message.applicationId ?? 'unknown',
      taskId: message.batchTaskId,
      submitId,
      queuePriority: normalizeQueuePriority(message.queuePriority),
      phoneNumber: message.phoneNumber,
      content: message.content,
      signature: message.template?.signature?.name ?? message.signature?.name ?? 'SMS',
      templateId: message.templateId ?? 'unknown',
      billingUnits: message.billingUnits,
      route: {
        channelCode: channel.code,
        cmppAccountCode: channel.account,
        priority: attempt,
        rateLimitPerSecond: channel.rateLimitPerSecond,
        carrier: routed.carrier,
        province: routed.province ?? undefined,
        scope: routed.routeScope,
        groupId: routed.groupId,
      },
      cmpp: {
        serviceId: channel.config && typeof channel.config === 'object' && 'serviceId' in channel.config
          ? String(channel.config.serviceId)
          : 'SMS',
        srcId: upstreamSrcId,
        extensionDigits: getNonNegativeConfigInteger(channel.config, 'extensionDigits', 0),
        registeredDelivery: 1,
        msgFmt: 8,
      },
      upstream: {
        gatewayHost: channel.gatewayHost,
        gatewayPort: channel.gatewayPort,
        account: channel.account,
        passwordCipher: channel.passwordCipher,
        cmppVersion: channel.cmppVersion,
        desiredConnections: getPositiveConfigInteger(channel.config, 'desiredConnections', 1),
        windowSize: getPositiveConfigInteger(channel.config, 'windowSize', 16),
        heartbeatIntervalSeconds: getPositiveConfigInteger(channel.config, 'heartbeatIntervalSeconds', 30),
        heartbeatMissThreshold: getPositiveConfigInteger(channel.config, 'heartbeatMissThreshold', 3),
      },
      retry: { attempt, maxAttempts: 1 },
    };
    await this.getGatewayQueue().add('submit-command', command);
    await this.publishGatewaySubmitCommand(command);
    await this.refreshTaskProgress(message.batchTaskId);
    return { submitted: true, messageRecordId: message.id, channelId: channel.id, attempt };
  }

  private async retryMessageIfAllowed(
    message: {
      id: string;
      tenantId: string;
      batchTaskId: string;
      applicationId?: string | null;
      templateId?: string | null;
      messageId: string;
      phoneNumber: string;
      content: string;
      billingUnits: number;
      queuedAt?: Date;
      clientSrcId?: string | null;
      applicationExtension?: string | null;
    },
    reason: string,
  ) {
    const attempts = await this.prisma.smsSubmitRecord.findMany({
      where: { messageRecordId: message.id },
      orderBy: { createdAt: 'asc' },
      take: 200,
    });
    const attemptedChannelIds = attempts.map((attempt) => attempt.channelId);
    const ageMinutes = (Date.now() - new Date(message.queuedAt ?? Date.now()).getTime()) / 60_000;
    if (ageMinutes >= 72 * 60) {
      return null;
    }
    const route = await this.findApplicationRoute(message.tenantId, message.applicationId ?? undefined, await this.identifyCarrier(message.phoneNumber));
    const retryTimeLimitMinutes = Math.min(route.group.retryTimeLimitMinutes ?? route.group.retryTimeLimitHours * 60, 72 * 60);
    if (!route.group.retryEnabled || ageMinutes >= retryTimeLimitMinutes) {
      return null;
    }
    try {
      const routed = await this.selectChannelForMessage(message, {
        forceNational: true,
        excludeChannelIds: attemptedChannelIds,
      });
      await this.prisma.smsMessageRecord.update({
        where: { id: message.id },
        data: { errorMessage: reason },
      });
      return await this.submitMessageToGateway(message, routed, attempts.length);
    } catch {
      return null;
    }
  }

  private async selectChannelForMessage(
    message: { id: string; tenantId: string; applicationId?: string | null; templateId?: string | null; phoneNumber: string; template?: { signature?: { id?: string | null } | null } | null; signature?: { id?: string | null } | null },
    options: { forceNational?: boolean; excludeChannelIds?: string[] } = {},
  ): Promise<RoutedChannel> {
    if (!message.applicationId) {
      throw new BadRequestException('短信应用未配置，无法选择通道组');
    }
    const carrier = await this.identifyCarrier(message.phoneNumber);
    const province = await this.identifyProvince(message.phoneNumber);
    await this.prisma.smsMessageRecord.update({
      where: { id: message.id },
      data: { carrier, province },
    });
    const route = await this.findApplicationRoute(message.tenantId, message.applicationId, carrier);
    const excluded = new Set(options.excludeChannelIds ?? []);
    const signatureId = await this.resolveMessageSignatureId(message);
    if (!signatureId) throw new BadRequestException('短信签名未配置，无法选择已报备通道');
    const approvedTasks = await this.prisma.channelSignatureReportTask.findMany({
      where: { signatureId, reportType: 'signature', status: 'approved', channelId: { in: route.group.items.map((item) => item.channelId) } },
      select: { channelId: true },
    });
    const approvedChannelIds = new Set(approvedTasks.map((task) => task.channelId));
    const items = route.group.items.filter((item) =>
      !excluded.has(item.channelId)
      && approvedChannelIds.has(item.channelId)
      && normalizeCarrier(item.carrier) === carrier
      && isCarrierCompatible(item.channel.carrier, carrier),
    );
    const provinceCandidates = options.forceNational ? [] : items.filter((item) => isProvinceChannel(item, province));
    const nationalCandidates = items.filter((item) => isNationalChannel(item));
    const selected = [...provinceCandidates, ...nationalCandidates].find((item) => this.isChannelSendAvailable(item.channel));
    if (!selected) {
      throw new NotFoundException('无已报备通过且在线的可用通道');
    }
    return {
      channel: { ...selected.channel, unitPrice: moneyToNumber(selected.channel.unitPrice) },
      carrier,
      province,
      groupId: route.groupId,
      routeScope: isNationalChannel(selected) ? 'national' : 'province',
    };
  }

  private async findApplicationRoute(tenantId: string, applicationId: string | undefined, carrier: string) {
    const route = await this.prisma.channelRouteRule.findFirst({
      where: {
        status: 'active',
        tenantId,
        applicationId,
        carrier,
        channelId: null,
        province: null,
      },
      include: { group: { include: { items: { include: { channel: { include: { connectionStates: true } } }, orderBy: { priority: 'asc' } } } } },
      orderBy: { priority: 'asc' },
    });
    if (!route) {
      throw new NotFoundException('企业应用未配置对应运营商通道组');
    }
    if (route.group.status !== 'active') {
      throw new BadRequestException('企业应用绑定的通道组已停用');
    }
    if (normalizeCarrier(route.group.carrier) !== carrier) {
      throw new BadRequestException('企业应用绑定的通道组运营商与路由规则不一致');
    }
    return route;
  }

  private async identifyCarrier(phoneNumber: string) {
    const rules = await this.prisma.phoneCarrierRule.findMany({
      where: { status: 'active' },
      orderBy: [{ priority: 'asc' }, { createdAt: 'asc' }],
    });
    for (const rule of rules) {
      try {
        if (new RegExp(rule.pattern).test(phoneNumber)) {
          return normalizeCarrier(rule.carrier);
        }
      } catch {
        continue;
      }
    }
    return 'mobile';
  }

  private async identifyProvince(phoneNumber: string) {
    for (let length = Math.min(7, phoneNumber.length); length >= 3; length -= 1) {
      const segment = await this.prisma.phoneSegment.findUnique({ where: { prefix: phoneNumber.slice(0, length) } });
      if (segment?.province) {
        return segment.province;
      }
    }
    return null;
  }

  private isChannelSendAvailable(channel: { status: string; connectionStates?: Array<{ status: string; currentConnections: number; desiredConnections: number }> }) {
    if (channel.status !== 'active') {
      return false;
    }
    return (channel.connectionStates ?? []).some((connection) =>
      connection.desiredConnections > 0 && connection.currentConnections > 0 && connection.status === 'connected',
    );
  }

  private async resolveUnitPrice(tenantId: string, applicationId?: string) {
    if (!applicationId) {
      return 0;
    }
    const application = await this.prisma.smsApplication.findUnique({
      where: { id: applicationId },
      select: { tenantId: true, customerUnitPrice: true },
    });
    if (!application || application.tenantId !== tenantId) {
      return 0;
    }
    return moneyToNumber(application.customerUnitPrice);
  }

  private async resolveQueuePriority(tenantId: string, applicationId?: string): Promise<QueuePriority> {
    if (!applicationId) {
      return 'normal';
    }
    const application = await this.prisma.smsApplication.findUnique({
      where: { id: applicationId },
      select: { tenantId: true, queuePriority: true },
    });
    if (!application || application.tenantId !== tenantId) {
      return 'normal';
    }
    return normalizeQueuePriority(application.queuePriority);
  }

  private async resolveApplicationAccessNumber(tenantId: string, applicationId?: string) {
    if (!applicationId) {
      return { clientSrcId: null, applicationExtension: null };
    }
    const application = await this.prisma.smsApplication.findUnique({
      where: { id: applicationId },
      select: { tenantId: true, cmppClientSrcId: true, cmppApplicationExtension: true },
    });
    if (!application || application.tenantId !== tenantId) {
      return { clientSrcId: null, applicationExtension: null };
    }
    return {
      clientSrcId: application.cmppClientSrcId,
      applicationExtension: application.cmppApplicationExtension,
    };
  }

  private findInboundApplication(account: string) {
    return this.prisma.smsApplication.findFirst({
      where: { cmppAccount: account },
      include: {
        tenant: true,
        ipAllowlist: true,
      },
    });
  }

  private async resolveInboundTemplateCandidate(applicationId: string, content: string) {
    const exact = await this.prisma.smsTemplate.findFirst({
      where: {
        applicationId,
        content,
        auditStatus: 'approved',
        signature: { auditStatus: 'approved' },
      },
      include: { signature: true },
      orderBy: { updatedAt: 'desc' },
    });
    if (exact) return exact;
    const variableTemplates = await this.prisma.smsTemplate.findMany({
      where: {
        applicationId,
        content: { contains: '${' },
        auditStatus: 'approved',
        signature: { auditStatus: 'approved' },
      },
      include: { signature: true },
      orderBy: { updatedAt: 'desc' },
    });
    return variableTemplates.find((template) => matchTemplateContent(template.content, content) !== null) ?? null;
  }

  private resolveInboundSignatureCandidate(applicationId: string, content: string) {
    const match = content.match(/^【[^】]+】/);
    if (!match?.[0]) return null;
    return this.prisma.smsSignature.findFirst({
      where: {
        applicationId,
        name: match[0],
        auditStatus: 'approved',
      },
      orderBy: { updatedAt: 'desc' },
    });
  }

  private async resolveTemplateMessageClassification(
    tenantId: string,
    applicationId: string | undefined,
    templateId: string | undefined,
    content: string,
  ) {
    if (templateId) {
      const template = await this.prisma.smsTemplate.findUnique({
        where: { id: templateId },
        include: { signature: true },
      });
      if (!template || template.tenantId !== tenantId || template.applicationId !== applicationId
        || template.auditStatus !== 'approved' || template.signature?.auditStatus !== 'approved') {
        throw new BadRequestException('短信模板不存在、未通过审核或不属于当前应用');
      }
      const variables = matchTemplateContent(template.content, content);
      if (variables === null) {
        throw new BadRequestException('短信内容与选定的审核模板不匹配');
      }
      const drainage = await this.resolveDrainageInfoMatch(template.signatureId, content);
      return {
        signatureId: template.signatureId,
        drainageInfoId: drainage?.id,
        variables,
        rejectionReason: drainageRejectionReason(drainage),
      };
    }

    if (!applicationId) {
      throw new BadRequestException('自由内容短信必须关联企业应用');
    }
    const [application, signature] = await Promise.all([
      this.prisma.smsApplication.findUnique({
        where: { id: applicationId },
        select: { tenantId: true, templateMismatchMode: true },
      }),
      this.resolveInboundSignatureCandidate(applicationId, content),
    ]);
    if (!application || application.tenantId !== tenantId) {
      throw new BadRequestException('短信应用不存在或不属于当前企业');
    }
    if (!signature) {
      throw new BadRequestException('短信内容未以当前应用已审核通过的签名开头');
    }
    if (application.templateMismatchMode !== 'direct_send') {
      throw new BadRequestException('当前应用未允许无模板自由内容直接发送');
    }
    const drainage = await this.resolveDrainageInfoMatch(signature.id, content);
    return {
      signatureId: signature.id,
      drainageInfoId: drainage?.id,
      variables: undefined,
      rejectionReason: drainageRejectionReason(drainage),
    };
  }

  private async resolveDrainageInfoMatch(signatureId: string | null | undefined, content: string) {
    if (!signatureId) return undefined;
    const candidates = await this.prisma.smsDrainageInfo.findMany({
      where: { signatureId, auditStatus: { not: 'deleted' } },
      select: { id: true, url: true, auditStatus: true, updatedAt: true },
      orderBy: [{ updatedAt: 'desc' }, { id: 'asc' }],
    });
    const matches = candidates
      .map((item) => ({ ...item, normalizedUrl: item.url.trim() }))
      .filter((item) => item.normalizedUrl.length > 0 && content.includes(item.normalizedUrl))
      .sort((left, right) => right.normalizedUrl.length - left.normalizedUrl.length || right.updatedAt.getTime() - left.updatedAt.getTime());
    if (matches.length === 0) return undefined;
    const longestLength = matches[0].normalizedUrl.length;
    const longestMatches = matches.filter((item) => item.normalizedUrl.length === longestLength);
    if (longestMatches.length !== 1) {
      throw new BadRequestException({
        code: 'DRAINAGE_MATCH_AMBIGUOUS',
        message: '短信内容同时匹配多条等长引流地址，无法确定报备资料',
        drainageInfoIds: longestMatches.map((item) => item.id),
      });
    }
    const matched = longestMatches[0];
    return { id: matched.id, auditStatus: matched.auditStatus };
  }

  private async attachMessageToReviewTask(reviewTaskId: string, messageRecordId: string, signatureId: string, drainageInfoId?: string) {
    await this.prisma.smsMessageRecord.update({
      where: { id: messageRecordId },
      data: { reviewTaskId, signatureId, drainageInfoId, status: 'pending_review' },
    });
    return this.prisma.smsSendTask.findUnique({ where: { id: reviewTaskId } });
  }

  private async recordCmppFailureReceipt(
    message: {
      id: string;
      tenantId?: string | null;
      batchTaskId?: string | null;
      applicationId?: string | null;
      messageId: string;
      phoneNumber: string;
      cmppSubmitSequenceId?: string | null;
      cmppSubmitGroupMessageId?: string | null;
    },
    errorCode: string,
    reason: string,
  ) {
    if (!message.tenantId || !message.applicationId) return null;
    const existing = await this.prisma.smsReceiptRecord.findFirst({
      where: { messageRecordId: message.id, gatewayMessageId: `PLATFORM:${message.messageId}` },
    });
    if (existing) return existing;
    const deliveredAt = new Date();
    await this.prisma.smsMessageRecord.update({
      where: { id: message.id },
      data: { status: 'failed', receiptStatus: 'undelivered', receiptRawStatus: 'REJECTD', errorCode, errorMessage: reason, deliveredAt },
    });
    const gatewayMessageId = `PLATFORM:${message.messageId}`;
    const receipt = await this.prisma.smsReceiptRecord.create({
      data: {
        tenantId: message.tenantId,
        batchTaskId: message.batchTaskId,
        messageRecordId: message.id,
        receiptKey: createHash('sha256').update(`platform\u0000${gatewayMessageId}\u0000${message.phoneNumber}\u0000undelivered\u0000REJECTD\u0000${errorCode}`).digest('hex'),
        messageId: message.messageId,
        gatewayMessageId,
        phoneNumber: message.phoneNumber,
        receiptStatus: 'undelivered',
        rawStatus: 'REJECTD',
        errorCode,
        errorMessage: reason,
        deliveredAt,
      },
    });
    await this.queueAndTryDownstreamDelivery({
      tenantId: message.tenantId,
      applicationId: message.applicationId,
      messageRecordId: message.id,
      messageId: message.messageId,
      deliveryType: 'receipt',
      payload: {
        messageId: message.messageId,
        gatewayMessageId: `PLATFORM:${message.messageId}`,
        phoneNumber: message.phoneNumber,
        receiptStatus: 'undelivered',
        rawStatus: 'REJECTD',
        errorCode,
        errorMessage: reason,
        submitSequenceId: message.cmppSubmitSequenceId ? Number(message.cmppSubmitSequenceId) : undefined,
        submitGroupMessageId: message.cmppSubmitGroupMessageId ?? undefined,
        deliveredAt: deliveredAt.toISOString(),
      },
    });
    if (message.batchTaskId) await this.refreshTaskProgress(message.batchTaskId);
    return receipt;
  }

  private async validateSendResources(tenantId: string, applicationId?: string, templateId?: string) {
    const tenant = await this.prisma.tenant.findUnique({ where: { id: tenantId } });
    if (!tenant || tenant.status !== 'active') {
      throw new BadRequestException('企业客户不存在或已停用');
    }
    if (tenant.certificationStatus !== 'approved') {
      throw new BadRequestException('企业认证未通过，不能发送短信');
    }
    if (!applicationId) {
      return;
    }
    const application = await this.prisma.smsApplication.findUnique({ where: { id: applicationId } });
    if (!application || application.tenantId !== tenantId || application.status !== 'active') {
      throw new BadRequestException('短信应用不存在或已停用');
    }
    if (!application.interfaceEnabled) {
      throw new BadRequestException('短信应用接口未开通，不能发送短信');
    }
    if (!templateId) {
      return;
    }
    const template = await this.prisma.smsTemplate.findUnique({
      where: { id: templateId },
      include: { signature: true },
    });
    if (!template || template.tenantId !== tenantId || template.applicationId !== applicationId || template.auditStatus !== 'approved') {
      throw new BadRequestException('短信模板不存在、未通过审核或不属于当前应用');
    }
    if (!template.signature || template.signature.auditStatus !== 'approved') {
      throw new BadRequestException('短信签名未审核通过');
    }
  }

  private async reserveDailySendQuota(applicationId: string, requestedCount: number) {
    const result = await this.tryReserveDailySendQuota(applicationId, requestedCount);
    if (!result.reserved) {
      throw new HttpException({
        code: 'DAILY_SEND_LIMIT_EXCEEDED',
        message: `应用当日发送上限${result.dailyLimit}条，本次${requestedCount}条超出剩余配额`,
        dailyLimit: result.dailyLimit,
        requestedCount,
      }, HttpStatus.TOO_MANY_REQUESTS);
    }
    return result;
  }

  private async tryReserveDailySendQuota(applicationId: string, requestedCount: number) {
    if (!Number.isInteger(requestedCount) || requestedCount <= 0) {
      throw new BadRequestException('发送号码数量必须为正整数');
    }
    const usageDate = shanghaiDateKey();
    const reservationId = randomUUID();
    const rows = await this.prisma.$queryRaw<Array<{ dailyLimit: number; usedCount: number | null }>>(Prisma.sql`
      WITH application_limit AS (
        SELECT id, COALESCE("dailyLimit", 100000)::integer AS "dailyLimit"
        FROM "SmsApplication"
        WHERE id = ${applicationId}
      ), reservation AS (
        INSERT INTO "SmsApplicationDailyUsage" (
          id, "applicationId", "usageDate", "usedCount", "createdAt", "updatedAt"
        )
        SELECT ${reservationId}, id, ${usageDate}::date, ${requestedCount}, NOW(), NOW()
        FROM application_limit
        WHERE ${requestedCount} <= "dailyLimit"
        ON CONFLICT ("applicationId", "usageDate") DO UPDATE
          SET "usedCount" = "SmsApplicationDailyUsage"."usedCount" + EXCLUDED."usedCount",
              "updatedAt" = NOW()
          WHERE "SmsApplicationDailyUsage"."usedCount" + EXCLUDED."usedCount"
                <= (SELECT "dailyLimit" FROM application_limit)
        RETURNING "usedCount"
      )
      SELECT application_limit."dailyLimit", reservation."usedCount"
      FROM application_limit
      LEFT JOIN reservation ON TRUE
    `);
    if (rows.length === 0) {
      throw new NotFoundException('短信应用不存在');
    }
    return {
      dailyLimit: Number(rows[0].dailyLimit),
      usedCount: rows[0].usedCount == null ? null : Number(rows[0].usedCount),
      reserved: rows[0].usedCount != null,
    };
  }

  private async chargeAcceptedMessage(message: {
    tenantId: string;
    applicationId?: string | null;
    batchTaskId: string;
    messageId: string;
    phoneNumber: string;
    content: string;
    billingUnits: number;
    unitPrice: number | bigint;
    amountCents: number | bigint;
  }) {
    const amountCents = moneyToNumber(message.amountCents);
    const unitPrice = moneyToNumber(message.unitPrice);
    const billingUnits = message.billingUnits ?? 0;
    const exists = await this.prisma.smsBillingRecord.findFirst({ where: { messageId: message.messageId } });
    if (exists?.billingStatus === 'charged') {
      return;
    }
    if (amountCents > 0) {
      await this.billing.release({
        tenantId: message.tenantId,
        amountCents,
        relatedType: 'sms_batch_task',
        relatedId: message.batchTaskId,
        remark: `短信 ${message.messageId} 提交成功释放冻结并转扣费`,
      });
    }
    const transaction = await this.billing.charge({
      tenantId: message.tenantId,
      amountCents,
      relatedType: 'sms_message_record',
      relatedId: message.messageId,
      remark: '提交成功扣费',
    });
    const data = {
      tenantId: message.tenantId,
      applicationId: message.applicationId ?? undefined,
      taskId: message.batchTaskId,
      messageId: message.messageId,
      phoneNumber: message.phoneNumber,
      contentLength: [...message.content].length,
      billingUnits,
      unitPrice,
      amountCents,
      billingStatus: 'charged',
      transactionId: transaction.id,
    };
    if (exists) {
      await this.prisma.smsBillingRecord.update({ where: { id: exists.id }, data });
      return;
    }
    await this.prisma.smsBillingRecord.create({ data });
  }

  private async releaseMessageReservation(
    message: { tenantId: string; batchTaskId: string; messageId: string; amountCents: number | bigint; billingUnits: number },
    remark: string,
  ) {
    const amountCents = moneyToNumber(message.amountCents);
    if (amountCents <= 0) {
      return;
    }
    const charged = await this.prisma.smsBillingRecord.findFirst({ where: { messageId: message.messageId, billingStatus: 'charged' } });
    if (charged) {
      return;
    }
    const released = await this.prisma.accountTransaction.findFirst({
      where: { relatedType: 'sms_message_record', relatedId: message.messageId, transactionType: 'released' },
    });
    if (released) {
      return;
    }
    await this.billing.release({
      tenantId: message.tenantId,
      amountCents,
      relatedType: 'sms_message_record',
      relatedId: message.messageId,
      remark: `${remark}: ${message.messageId}`,
    });
  }

  private async refundMessage(
    message: { tenantId: string; messageId: string; amountCents: number | bigint; billingUnits: number },
    remark: string,
  ) {
    const amountCents = moneyToNumber(message.amountCents);
    if (amountCents <= 0) {
      return;
    }
    const refunded = await this.prisma.smsBillingRecord.findFirst({ where: { messageId: message.messageId, billingStatus: 'refunded' } });
    if (refunded) {
      return;
    }
    const charged = await this.prisma.smsBillingRecord.findFirst({ where: { messageId: message.messageId, billingStatus: 'charged' } });
    if (!charged) {
      return;
    }
    const transaction = await this.billing.refund({
      tenantId: message.tenantId,
      amountCents,
      relatedType: 'sms_message_record',
      relatedId: message.messageId,
      remark,
    });
    await this.prisma.smsBillingRecord.updateMany({
      where: { messageId: message.messageId },
      data: { billingStatus: 'refunded', transactionId: transaction.id },
    });
  }

  private async ensureSignatureReportedForChannel(
    message: {
      id: string;
      templateId?: string | null;
      template?: { signature?: { id?: string | null; name?: string | null } | null } | null;
      signature?: { id?: string | null; name?: string | null } | null;
    },
    channelId: string,
  ) {
    const signatureId = await this.resolveMessageSignatureId(message);
    if (!signatureId) {
      throw new BadRequestException('短信签名未配置，不能提交到通道');
    }
    const reportTask = await this.prisma.channelSignatureReportTask.findFirst({
      where: { signatureId, channelId, reportType: 'signature', status: 'approved' },
      select: { id: true },
    });
    if (!reportTask) {
      throw new BadRequestException('短信签名未在最终通道报备通过');
    }
  }

  private async resolveMessageSignatureId(message: { templateId?: string | null; template?: { signature?: { id?: string | null } | null } | null; signature?: { id?: string | null } | null }) {
    const direct = message.template?.signature?.id ?? message.signature?.id ?? null;
    if (direct || !message.templateId) return direct;
    const template = await this.prisma.smsTemplate.findUnique({ where: { id: message.templateId }, include: { signature: true } });
    return template?.signature?.id ?? null;
  }

  private async waitForChannelRateLimit(channelId: string, tps: number) {
    const redis = this.getRedis();
    for (;;) {
      const bucket = `rate:channel:${channelId}:${Math.floor(Date.now() / 1000)}`;
      const count = await redis.incr(bucket);
      if (count === 1) {
        await redis.expire(bucket, 2);
      }
      if (count <= Math.max(1, tps)) {
        return;
      }
      await sleep(100);
    }
  }

  private async refreshTaskProgress(batchTaskId: string) {
    const groups = await this.prisma.smsMessageRecord.groupBy({
      by: ['status'],
      where: { batchTaskId },
      _count: { _all: true },
    });
    const count = (statuses: string[]) =>
      groups.filter((group) => statuses.includes(group.status)).reduce((sum, group) => sum + group._count._all, 0);
    const progressTotal = groups.reduce((sum, group) => sum + group._count._all, 0);
    const submittedTotal = count(['submit_queued', 'submitted', 'delivered', 'failed', 'unknown', 'timeout']);
    const successTotal = count(['delivered']);
    const failedTotal = count(['submit_failed', 'failed']);
    const unknownTotal = count(['unknown']);
    const timeoutTotal = count(['timeout']);
    const doneTotal = successTotal + failedTotal + timeoutTotal;
    const status = progressTotal > 0 && doneTotal >= progressTotal ? 'finished' : submittedTotal > 0 ? 'sending' : 'queued';
    await this.prisma.smsBatchTask.update({
      where: { id: batchTaskId },
      data: { progressTotal, submittedTotal, successTotal, failedTotal, unknownTotal, timeoutTotal, status },
    });
  }

  private smsMessageSegmentAuditDelegate() {
    return (this.prisma as PrismaService & {
      smsMessageSegmentAudit: {
        upsert: (args: Record<string, unknown>) => Promise<any>;
        updateMany: (args: Record<string, unknown>) => Promise<{ count: number }>;
        findFirst: (args: Record<string, unknown>) => Promise<any | null>;
        findMany: (args: Record<string, unknown>) => Promise<any[]>;
      };
    }).smsMessageSegmentAudit;
  }

  private async recordSubmitSegments(
    message: {
      id: string;
      tenantId?: string | null;
      batchTaskId?: string | null;
      channelId?: string | null;
      submitId?: string | null;
      billingUnits?: number | null;
    },
    data: GatewaySubmitResultDto,
    submittedAt: Date,
  ) {
    const segmentAudits = this.smsMessageSegmentAuditDelegate();
    const submitRecord = await this.prisma.smsSubmitRecord.findFirst({
      where: {
        messageRecordId: message.id,
        OR: [
          data.submitId ? { submitId: data.submitId } : undefined,
          data.gatewayMessageId ? { gatewayMessageId: data.gatewayMessageId } : undefined,
        ].filter(Boolean) as Array<{ submitId?: string; gatewayMessageId?: string }>,
      },
      orderBy: { createdAt: 'desc' },
    });
    const submitId = data.submitId ?? submitRecord?.submitId ?? message.submitId ?? `SUB-AUDIT-${message.id}`;
    const attempt = submitRecord
      ? Math.max(0, await this.prisma.smsSubmitRecord.count({
        where: {
          messageRecordId: message.id,
          createdAt: { lte: submitRecord.createdAt },
        },
      }) - 1)
      : 0;
    const fallbackSegments = [{
      segmentTotal: Math.max(1, Number(message.billingUnits ?? 1)),
      segmentIndex: 1,
      sequenceId: data.sequenceId,
      gatewayMessageId: data.gatewayMessageId,
      submitStatus: data.submitStatus,
      errorCode: data.errorCode,
      errorMessage: data.errorMessage,
      submittedAt: data.submittedAt,
    }];
    const segments = data.segments && data.segments.length > 0 ? data.segments : fallbackSegments;
    const segmentTotal = Math.max(1, ...segments.map((item) => Number(item.segmentTotal ?? segments.length ?? 1)));
    await Promise.all(segments.map((segment, index) => {
      const segmentIndex = Math.max(1, Number(segment.segmentIndex ?? index + 1));
      const status = segment.submitStatus ?? data.submitStatus;
      return segmentAudits.upsert({
        where: {
          messageRecordId_submitId_segmentIndex: {
            messageRecordId: message.id,
            submitId,
            segmentIndex,
          },
        },
        update: {
          submitRecordId: submitRecord?.id ?? null,
          channelId: data.channelId ?? message.channelId ?? null,
          attempt,
          segmentTotal,
          sequenceId: segment.sequenceId ?? data.sequenceId ?? null,
          gatewayMessageId: segment.gatewayMessageId ?? data.gatewayMessageId ?? null,
          submitStatus: status,
          errorCode: segment.errorCode ?? data.errorCode ?? null,
          errorMessage: segment.errorMessage ?? data.errorMessage ?? null,
          submittedAt: segment.submittedAt ? new Date(segment.submittedAt) : submittedAt,
        },
        create: {
          tenantId: message.tenantId,
          batchTaskId: message.batchTaskId,
          messageRecordId: message.id,
          submitRecordId: submitRecord?.id ?? null,
          channelId: data.channelId ?? message.channelId ?? null,
          submitId,
          attempt,
          segmentTotal,
          segmentIndex,
          sequenceId: segment.sequenceId ?? data.sequenceId ?? null,
          gatewayMessageId: segment.gatewayMessageId ?? data.gatewayMessageId ?? null,
          submitStatus: status,
          compensationType: submitRecord && submitRecord.submitId !== message.submitId ? 'retry_submit' : null,
          errorCode: segment.errorCode ?? data.errorCode ?? null,
          errorMessage: segment.errorMessage ?? data.errorMessage ?? null,
          submittedAt: segment.submittedAt ? new Date(segment.submittedAt) : submittedAt,
        },
      });
    }));
  }

  private async recordReceiptSegment(
    message: {
      id: string;
      tenantId?: string | null;
      batchTaskId?: string | null;
      channelId?: string | null;
      submitId?: string | null;
      billingUnits?: number | null;
    },
    data: GatewayReceiptEventDto,
    deliveredAt: Date,
    submitRecordId?: string,
  ) {
    const segmentAudits = this.smsMessageSegmentAuditDelegate();
    const updated = await segmentAudits.updateMany({
      where: {
        messageRecordId: message.id,
        gatewayMessageId: data.gatewayMessageId,
      },
      data: {
        receiptStatus: data.receiptStatus,
        rawStatus: data.rawStatus,
        errorCode: data.errorCode ?? null,
        deliveredAt,
      },
    });
    if (updated.count > 0) {
      return;
    }
    const submitRecord = submitRecordId
      ? await this.prisma.smsSubmitRecord.findUnique({ where: { id: submitRecordId } })
      : await this.prisma.smsSubmitRecord.findFirst({
        where: { messageRecordId: message.id, gatewayMessageId: data.gatewayMessageId },
        orderBy: { createdAt: 'desc' },
      });
    await segmentAudits.upsert({
      where: {
        messageRecordId_submitId_segmentIndex: {
          messageRecordId: message.id,
          submitId: submitRecord?.submitId ?? message.submitId ?? `RECEIPT-AUDIT-${data.gatewayMessageId}`,
          segmentIndex: 1,
        },
      },
      update: {
        submitRecordId: submitRecord?.id ?? submitRecordId ?? null,
        channelId: data.channelId ?? message.channelId ?? null,
        sequenceId: data.sequenceId ?? null,
        gatewayMessageId: data.gatewayMessageId,
        receiptStatus: data.receiptStatus,
        rawStatus: data.rawStatus,
        errorCode: data.errorCode ?? null,
        deliveredAt,
      },
      create: {
        tenantId: message.tenantId,
        batchTaskId: message.batchTaskId,
        messageRecordId: message.id,
        submitRecordId: submitRecord?.id ?? submitRecordId ?? null,
        channelId: data.channelId ?? message.channelId ?? null,
        submitId: submitRecord?.submitId ?? message.submitId ?? `RECEIPT-AUDIT-${data.gatewayMessageId}`,
        attempt: 0,
        segmentTotal: Math.max(1, Number(message.billingUnits ?? 1)),
        segmentIndex: 1,
        sequenceId: data.sequenceId ?? null,
        gatewayMessageId: data.gatewayMessageId,
        submitStatus: submitRecord?.submitStatus ?? 'accepted',
        receiptStatus: data.receiptStatus,
        rawStatus: data.rawStatus,
        compensationType: 'receipt_recovered',
        errorCode: data.errorCode ?? null,
        deliveredAt,
      },
    });
  }

  private async aggregateReceiptSegments(
    message: {
      id: string;
      billingUnits?: number | null;
    },
    data: GatewayReceiptEventDto,
    deliveredAt: Date,
    submitRecordId?: string,
    submitId?: string,
  ) {
    const audits = await this.smsMessageSegmentAuditDelegate().findMany({
      where: submitRecordId
        ? { messageRecordId: message.id, submitRecordId }
        : submitId
          ? { messageRecordId: message.id, submitId }
          : { messageRecordId: message.id, gatewayMessageId: data.gatewayMessageId },
      orderBy: { segmentIndex: 'asc' },
    });
    if (audits.length === 0) {
      const status = data.receiptStatus === 'delivered'
        ? 'delivered'
        : data.receiptStatus === 'unknown'
          ? 'unknown'
          : 'failed';
      return {
        terminal: true,
        segmentTotal: 1,
        status,
        receiptStatus: data.receiptStatus,
        rawStatus: data.rawStatus,
        errorCode: data.errorCode,
        errorMessage: data.errorMessage,
        deliveredAt,
      };
    }

    const segmentTotal = Math.max(
      1,
      Number(message.billingUnits ?? 1),
      ...audits.map((audit) => Number(audit.segmentTotal ?? 1)),
    );
    const received = audits.filter((audit) => Boolean(audit.receiptStatus));
    const failed = received.find((audit) => !['delivered', 'unknown'].includes(audit.receiptStatus ?? ''));
    if (failed) {
      return {
        terminal: true,
        segmentTotal,
        status: 'failed',
        receiptStatus: failed.receiptStatus ?? 'undelivered',
        rawStatus: failed.rawStatus ?? data.rawStatus,
        errorCode: failed.errorCode ?? data.errorCode,
        errorMessage: failed.errorMessage ?? data.errorMessage,
        deliveredAt: failed.deliveredAt ?? deliveredAt,
      };
    }
    const delivered = received.filter((audit) => audit.receiptStatus === 'delivered');
    if (delivered.length >= segmentTotal) {
      const latest = delivered.reduce((current, audit) =>
        (audit.deliveredAt?.getTime() ?? 0) > (current.deliveredAt?.getTime() ?? 0) ? audit : current);
      return {
        terminal: true,
        segmentTotal,
        status: 'delivered',
        receiptStatus: 'delivered',
        rawStatus: latest.rawStatus ?? data.rawStatus,
        errorCode: latest.errorCode ?? undefined,
        errorMessage: undefined,
        deliveredAt: latest.deliveredAt ?? deliveredAt,
      };
    }
    if (received.length >= segmentTotal) {
      const latest = received[received.length - 1];
      return {
        terminal: true,
        segmentTotal,
        status: 'unknown',
        receiptStatus: 'unknown',
        rawStatus: latest.rawStatus ?? data.rawStatus,
        errorCode: latest.errorCode ?? data.errorCode,
        errorMessage: latest.errorMessage ?? data.errorMessage,
        deliveredAt: latest.deliveredAt ?? deliveredAt,
      };
    }
    return {
      terminal: false,
      segmentTotal,
      status: 'submitted',
      receiptStatus: data.receiptStatus,
      rawStatus: data.rawStatus,
      errorCode: data.errorCode,
      errorMessage: data.errorMessage,
      deliveredAt,
    };
  }

  private async findMessageByGatewayEvent(messageId?: string, gatewayMessageId?: string) {
    const conditions = [{ messageId }, gatewayMessageId ? { gatewayMessageId } : undefined].filter(
      Boolean,
    ) as Array<{
      messageId?: string;
      gatewayMessageId?: string;
    }>;
    if (conditions.length === 0) {
      return null;
    }
    return this.prisma.smsMessageRecord.findFirst({
      where: {
        OR: conditions,
      },
    });
  }

  private async requireMessageByGatewayEvent(messageId?: string, gatewayMessageId?: string) {
    const message = await this.findMessageByGatewayEvent(messageId, gatewayMessageId);
    if (!message) {
      throw new NotFoundException('SMS message record not found');
    }
    return message;
  }

  private async resolveReceiptMessage(data: GatewayReceiptEventDto) {
    const exactMessage = data.messageId
      ? await this.prisma.smsMessageRecord.findUnique({ where: { messageId: data.messageId } })
      : null;
    if (exactMessage) {
      const segmentAudit = data.gatewayMessageId
        ? await this.smsMessageSegmentAuditDelegate().findFirst({
            where: {
              messageRecordId: exactMessage.id,
              gatewayMessageId: data.gatewayMessageId,
            },
            orderBy: { updatedAt: 'desc' },
          })
        : null;
      if (segmentAudit) {
        return {
          message: exactMessage,
          messageId: exactMessage.messageId,
          submitRecordId: segmentAudit.submitRecordId ?? undefined,
          submitId: segmentAudit.submitId,
          channelId: segmentAudit.channelId ?? data.channelId,
        };
      }
      const submitRecord = await this.prisma.smsSubmitRecord.findFirst({
        where: {
          messageRecordId: exactMessage.id,
          channelId: data.channelId,
          gatewayMessageId: data.gatewayMessageId,
        },
        orderBy: { createdAt: 'desc' },
      });
      return {
        message: exactMessage,
        messageId: exactMessage.messageId,
        submitRecordId: submitRecord?.id,
        submitId: submitRecord?.submitId,
        channelId: submitRecord?.channelId ?? data.channelId,
      };
    }

    const phoneNumber = data.phoneNumber?.trim();
    const exactSubmits = await this.prisma.smsSubmitRecord.findMany({
      where: {
        channelId: data.channelId,
        gatewayMessageId: data.gatewayMessageId,
        ...(phoneNumber ? { messageRecord: { phoneNumber } } : {}),
      },
      include: { messageRecord: true },
      orderBy: { createdAt: 'desc' },
      take: 2,
    });
    if (exactSubmits.length === 1 && exactSubmits[0]?.messageRecord) {
      return {
        message: exactSubmits[0].messageRecord,
        messageId: exactSubmits[0].messageRecord.messageId,
        submitRecordId: exactSubmits[0].id,
        submitId: exactSubmits[0].submitId,
        channelId: exactSubmits[0].channelId,
      };
    }

    if (!phoneNumber) {
      throw new NotFoundException('SMS message record not found');
    }

    const incomingChannel = await this.prisma.smsChannel.findUnique({ where: { id: data.channelId } });
    if (!incomingChannel) {
      throw new NotFoundException('SMS message record not found');
    }
    const segmentMatches = await this.smsMessageSegmentAuditDelegate().findMany({
      where: {
        gatewayMessageId: data.gatewayMessageId,
        messageRecord: { phoneNumber },
      },
      include: { messageRecord: true, submitRecord: true, channel: true },
      orderBy: { createdAt: 'desc' },
      take: 10,
    });
    const exactSegmentMatches = segmentMatches.filter((candidate) => candidate.channelId === data.channelId);
    if (exactSegmentMatches.length === 1 && exactSegmentMatches[0]?.messageRecord) {
      return {
        message: exactSegmentMatches[0].messageRecord,
        messageId: exactSegmentMatches[0].messageRecord.messageId,
        submitRecordId: exactSegmentMatches[0].submitRecordId ?? undefined,
        submitId: exactSegmentMatches[0].submitRecord?.submitId ?? exactSegmentMatches[0].submitId,
        channelId: exactSegmentMatches[0].channelId,
      };
    }
    const sameSupplierSegments = segmentMatches.filter((candidate) =>
      candidate.channel && this.isSameSupplierConnection(incomingChannel, candidate.channel));
    if (sameSupplierSegments.length === 1 && sameSupplierSegments[0]?.messageRecord) {
      return {
        message: sameSupplierSegments[0].messageRecord,
        messageId: sameSupplierSegments[0].messageRecord.messageId,
        submitRecordId: sameSupplierSegments[0].submitRecordId ?? undefined,
        submitId: sameSupplierSegments[0].submitRecord?.submitId ?? sameSupplierSegments[0].submitId,
        channelId: sameSupplierSegments[0].channelId,
      };
    }
    const crossConnectionSubmits = await this.prisma.smsSubmitRecord.findMany({
      where: {
        gatewayMessageId: data.gatewayMessageId,
        messageRecord: { phoneNumber },
      },
      include: { messageRecord: true, channel: true },
      orderBy: { createdAt: 'desc' },
      take: 10,
    });
    const sameSupplierSubmits = crossConnectionSubmits.filter((candidate) =>
      candidate.channel && this.isSameSupplierConnection(incomingChannel, candidate.channel));
    if (sameSupplierSubmits.length === 1 && sameSupplierSubmits[0]?.messageRecord) {
      return {
        message: sameSupplierSubmits[0].messageRecord,
        messageId: sameSupplierSubmits[0].messageRecord.messageId,
        submitRecordId: sameSupplierSubmits[0].id,
        submitId: sameSupplierSubmits[0].submitId,
        channelId: sameSupplierSubmits[0].channelId,
      };
    }

    const deliveredAt = data.deliveredAt ? new Date(data.deliveredAt) : new Date();
    const submittedAfter = new Date(deliveredAt.getTime() - 72 * 60 * 60 * 1000);
    const candidates = await this.prisma.smsSubmitRecord.findMany({
      where: {
        channelId: data.channelId,
        gatewayMessageId: null,
        submitStatus: 'timeout',
        submittedAt: {
          gte: submittedAfter,
          lte: deliveredAt,
        },
        messageRecord: {
          phoneNumber,
        },
      },
      include: {
        messageRecord: true,
      },
      orderBy: {
        submittedAt: 'desc',
      },
      take: 10,
    });

    if (candidates.length !== 1 || !candidates[0]?.messageRecord) {
      throw new NotFoundException('SMS message record not found');
    }

    return {
      message: candidates[0].messageRecord,
      messageId: candidates[0].messageRecord.messageId,
      submitRecordId: candidates[0].id,
      submitId: candidates[0].submitId,
      channelId: candidates[0].channelId,
    };
  }

  private isSameSupplierConnection(
    left: { account: string; gatewayHost: string; gatewayPort: number; protocol: string; cmppVersion: string },
    right: { account: string; gatewayHost: string; gatewayPort: number; protocol: string; cmppVersion: string },
  ) {
    return left.account.trim() === right.account.trim()
      && left.gatewayHost.trim().toLowerCase() === right.gatewayHost.trim().toLowerCase()
      && left.gatewayPort === right.gatewayPort
      && left.protocol.trim().toUpperCase() === right.protocol.trim().toUpperCase()
      && left.cmppVersion.trim() === right.cmppVersion.trim();
  }

  private receiptEventKey(data: GatewayReceiptEventDto, channelId = data.channelId) {
    return createHash('sha256').update([
      channelId,
      data.gatewayMessageId,
      data.phoneNumber?.trim() ?? '',
      data.receiptStatus,
      data.rawStatus.trim(),
      data.errorCode ?? '',
    ].join('\u0000')).digest('hex');
  }

  private getSendQueue(): Queue<SendJob, unknown, 'send-message'> {
    if (!this.sendQueue) {
      this.sendQueue = new Queue<SendJob, unknown, 'send-message'>(SEND_QUEUE, { connection: bullmqConnection() });
    }
    return this.sendQueue;
  }

  private getGatewayQueue(): Queue {
    if (!this.gatewayQueue) {
      this.gatewayQueue = new Queue(GATEWAY_SUBMIT_QUEUE, { connection: bullmqConnection() });
    }
    return this.gatewayQueue;
  }

  private getRedis() {
    if (!this.redis) {
      this.redis = new IORedis(process.env.REDIS_URL ?? 'redis://127.0.0.1:6379', {
        maxRetriesPerRequest: null,
      });
    }
    return this.redis;
  }

  private async postGatewayControl(path: string, payload: unknown) {
    const baseUrl = (process.env.GATEWAY_CONTROL_URL ?? 'http://127.0.0.1:8090').replace(/\/$/, '');
    const response = await fetch(`${baseUrl}${path}`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(payload),
    });
    if (!response.ok) {
      const body = await response.text().catch(() => '');
      throw new Error(`Gateway control ${path} returned ${response.status}${body ? `: ${body}` : ''}`);
    }
    return response.json().catch(() => ({}));
  }

  private async publishGatewaySubmitCommand(command: unknown, idempotencyKey?: string) {
    const redis = this.getRedis();
    const stream = process.env.GATEWAY_SUBMIT_STREAM ?? GATEWAY_SUBMIT_STREAM;
    const payload = JSON.stringify(command);
    if (!idempotencyKey) {
      return redis.xadd(stream, '*', 'messageType', 'SubmitCommand', 'data', payload);
    }
    const result = await redis.eval(
      `local existing = redis.call('GET', KEYS[2])
if existing then return existing end
local streamId = redis.call('XADD', KEYS[1], '*', 'messageType', 'SubmitCommand', 'data', ARGV[1])
redis.call('SET', KEYS[2], streamId, 'EX', ARGV[2])
return streamId`,
      2,
      stream,
      idempotencyKey,
      payload,
      String(GATEWAY_SUBMIT_REQUEUE_IDEMPOTENCY_TTL_SECONDS),
    );
    return typeof result === 'string' ? result : String(result ?? '');
  }

}

function gatewaySubmitRequeueKey(deadLetterId: string, attempt: number) {
  return `gateway:submit:requeue:${deadLetterId}:${attempt}`;
}

function drainageRejectionReason(drainage?: { id: string; auditStatus: string }) {
  if (!drainage || drainage.auditStatus === 'approved') return undefined;
  return `短信内容匹配的引流资料 ${drainage.id} 当前为 ${drainage.auditStatus}，必须审核通过后才能发送`;
}

function statusFromRisk(status: string, scheduled: boolean) {
  if (status === 'rejected') {
    return 'rejected';
  }
  if (status === 'pending_review') {
    return 'pending_review';
  }
  if (scheduled) {
    return 'scheduled';
  }
  return 'ready';
}

function parseSchedule(data: CreateBatchTaskDto) {
  if (data.sendMode !== 'scheduled' && !data.scheduledAt) {
    return { scheduledAt: null };
  }
  if (!data.scheduledAt) {
    throw new BadRequestException('定时发送必须提供 scheduledAt');
  }
  const scheduledAt = new Date(data.scheduledAt);
  if (Number.isNaN(scheduledAt.getTime())) {
    throw new BadRequestException('scheduledAt 时间格式无效');
  }
  if (scheduledAt.getTime() <= Date.now()) {
    throw new BadRequestException('scheduledAt 必须晚于当前时间');
  }
  return { scheduledAt };
}

function isObjectRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null && !Array.isArray(value);
}

function asDateOrNull(value?: string | null) {
  if (!value) {
    return null;
  }
  const parsed = new Date(value);
  return Number.isNaN(parsed.getTime()) ? null : parsed;
}

function downstreamRetryDelayMs(retryCount = 1) {
  const base = downstreamRetryBaseDelayMs();
  const max = downstreamRetryMaxDelayMs();
  const attempt = Math.max(1, Math.floor(retryCount));
  const delay = base * Math.pow(2, Math.max(0, attempt - 1));
  return Math.min(delay, max);
}

function downstreamAckTimeoutMs() {
  const configured = Number(process.env.CMPP_DOWNSTREAM_ACK_TIMEOUT_SECONDS ?? 30);
  return Math.max(5, Number.isFinite(configured) ? configured : 30) * 1000;
}

function downstreamRetryBaseDelayMs() {
  const value = Number(process.env.CMPP_DOWNSTREAM_RETRY_DELAY_MS ?? DEFAULT_DOWNSTREAM_RETRY_DELAY_MS);
  return Number.isFinite(value) && value > 0 ? value : DEFAULT_DOWNSTREAM_RETRY_DELAY_MS;
}

function downstreamRetryMaxDelayMs() {
  const value = Number(process.env.CMPP_DOWNSTREAM_RETRY_MAX_DELAY_MS ?? DEFAULT_DOWNSTREAM_RETRY_MAX_DELAY_MS);
  return Number.isFinite(value) && value > 0 ? value : DEFAULT_DOWNSTREAM_RETRY_MAX_DELAY_MS;
}

function downstreamMaxRetries() {
  const value = Number(process.env.CMPP_DOWNSTREAM_MAX_RETRIES ?? DEFAULT_DOWNSTREAM_MAX_RETRIES);
  return Number.isFinite(value) && value > 0 ? Math.floor(value) : DEFAULT_DOWNSTREAM_MAX_RETRIES;
}

function downstreamPendingTimeoutHours() {
  const value = Number(process.env.CMPP_DOWNSTREAM_PENDING_TIMEOUT_HOURS ?? DEFAULT_DOWNSTREAM_PENDING_TIMEOUT_HOURS);
  return Number.isFinite(value) && value > 0 ? value : DEFAULT_DOWNSTREAM_PENDING_TIMEOUT_HOURS;
}

function downstreamControlFailureMessage(result: GatewayControlDeliveryResult) {
  const reason = String(result.errorMessage ?? '').trim();
  const code = String(result.reasonCode ?? '').trim();
  if (reason && code) return `${reason} (${code})`;
  if (reason) return reason;
  if (code) return `Gateway 未完成下游投递 (${code})`;
  return 'Gateway 未完成下游投递，等待自动重试';
}

function parseImportRows(content: string, delimiter?: ',' | '\t') {
  const normalized = content.replace(/^\uFEFF/, '');
  const lines = normalized.split(/\r?\n/).filter((line) => line.trim().length > 0);
  if (lines.length === 0) {
    return [];
  }
  const firstDelimiter = delimiter ?? (lines[0].includes(',') ? ',' : '\t');
  const firstCells = splitImportLine(lines[0], firstDelimiter);
  const hasHeader = firstCells.some((cell) => ['phone', 'phoneNumber', 'mobile', '手机号'].includes(cell));
  const headers = hasHeader ? firstCells : ['phoneNumber'];
  const dataLines = hasHeader ? lines.slice(1) : lines;
  return dataLines.map((line, index) => {
    const cells = splitImportLine(line, firstDelimiter);
    const row: { rowNumber: number; phoneNumber?: string; variables: Record<string, string> } = {
      rowNumber: (hasHeader ? index + 2 : index + 1),
      phoneNumber: hasHeader ? cellByHeader(headers, cells, ['phone', 'phoneNumber', 'mobile', '手机号']) : cells[0],
      variables: {},
    };
    headers.forEach((header, cellIndex) => {
      if (!['phone', 'phoneNumber', 'mobile', '手机号'].includes(header)) {
        row.variables[header] = cells[cellIndex] ?? '';
      }
    });
    return row;
  });
}

function splitImportLine(line: string, delimiter: ',' | '\t') {
  return line.split(delimiter).map((cell) => cell.trim().replace(/^"|"$/g, ''));
}

function cellByHeader(headers: string[], cells: string[], candidates: string[]) {
  const index = headers.findIndex((header) => candidates.includes(header));
  return index >= 0 ? cells[index] : undefined;
}

function normalizeCarrier(carrier?: string | null) {
  const value = String(carrier ?? '').trim().toLowerCase();
  if (['mobile', 'cmcc', '移动', '中国移动'].includes(value)) return 'mobile';
  if (['unicom', 'cucc', '联通', '中国联通'].includes(value)) return 'unicom';
  if (['telecom', 'ctcc', '电信', '中国电信'].includes(value)) return 'telecom';
  if (['all', 'tri', '三网', '全网'].includes(value)) return 'all';
  return value || 'mobile';
}

function normalizeQueuePriority(queuePriority?: string | null): QueuePriority {
  return queuePriority === 'priority' ? 'priority' : 'normal';
}

function getPositiveConfigInteger(config: unknown, key: string, fallback: number) {
  if (config && typeof config === 'object' && !Array.isArray(config) && key in config) {
    const value = Number((config as Record<string, unknown>)[key]);
    if (Number.isInteger(value) && value > 0) {
      return value;
    }
  }
  return fallback;
}

function getNonNegativeConfigInteger(config: unknown, key: string, fallback: number) {
  if (config && typeof config === 'object' && !Array.isArray(config) && key in config) {
    const value = Number((config as Record<string, unknown>)[key]);
    if (Number.isInteger(value) && value >= 0) {
      return value;
    }
  }
  return fallback;
}

function isCarrierCompatible(channelCarrier: string | null | undefined, targetCarrier: string) {
  const normalized = normalizeCarrier(channelCarrier);
  return normalized === 'all' || normalized === targetCarrier;
}

function normalizeRegion(region?: string | null) {
  return String(region ?? '').replace(/省|市|自治区|壮族|回族|维吾尔/g, '').trim();
}

function matchTemplateContent(templateContent: string, actualContent: string) {
  if (templateContent === actualContent) {
    return {} as Record<string, string>;
  }
  const tokenPattern = /\$\{([a-zA-Z0-9_]+)\}/g;
  const names: string[] = [];
  let cursor = 0;
  let pattern = '^';
  for (const match of templateContent.matchAll(tokenPattern)) {
    const index = match.index ?? 0;
    pattern += escapeRegularExpression(templateContent.slice(cursor, index));
    pattern += '([\\s\\S]+?)';
    names.push(match[1]);
    cursor = index + match[0].length;
  }
  if (names.length === 0) {
    return null;
  }
  pattern += `${escapeRegularExpression(templateContent.slice(cursor))}$`;
  const matched = new RegExp(pattern, 'u').exec(actualContent);
  if (!matched) {
    return null;
  }
  const variables: Record<string, string> = {};
  for (let index = 0; index < names.length; index += 1) {
    const name = names[index];
    const value = matched[index + 1];
    if (variables[name] !== undefined && variables[name] !== value) {
      return null;
    }
    variables[name] = value;
  }
  return variables;
}

function escapeRegularExpression(value: string) {
  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

function isNationalChannel(item: { province?: string | null; channel: { sendRegion?: string | null } }) {
  const itemProvince = normalizeRegion(item.province);
  const sendRegion = normalizeRegion(item.channel.sendRegion);
  return !itemProvince || itemProvince === '全国' || !sendRegion || sendRegion === '全国';
}

function isProvinceChannel(item: { province?: string | null; channel: { sendRegion?: string | null } }, province?: string | null) {
  if (!province) {
    return false;
  }
  const target = normalizeRegion(province);
  const itemProvince = normalizeRegion(item.province);
  const sendRegion = normalizeRegion(item.channel.sendRegion);
  return itemProvince === target || sendRegion === target;
}

function validateInboundApplicationSrcId(
  srcId: string | undefined,
  application: {
    cmppApplicationExtension?: string | null;
    cmppAccessNumberFillEnabled?: boolean | null;
    cmppAccessNumberFillPrefix?: string | null;
    cmppClientSrcId?: string | null;
  },
) {
  const submittedSrcId = srcId?.trim() ?? '';
  const applicationExtension = application.cmppApplicationExtension?.trim() ?? '';
  if (!applicationExtension) {
    return submittedSrcId || null;
  }

  const fillPrefix = application.cmppAccessNumberFillEnabled
    ? application.cmppAccessNumberFillPrefix?.trim() ?? ''
    : '';
  const expectedSrcId = application.cmppClientSrcId?.trim() || `${fillPrefix}${applicationExtension}`;
  if (!submittedSrcId || submittedSrcId !== expectedSrcId) {
    throw new BadRequestException(`CMPP Src_Id must equal the access number assigned to this application: ${expectedSrcId}`);
  }
  return submittedSrcId;
}

function composeUpstreamSrcId(baseSrcId: string, applicationExtension?: string | null) {
  const upstreamSrcId = `${baseSrcId.trim()}${applicationExtension?.trim() ?? ''}`;
  if (upstreamSrcId.length > 21) {
    throw new BadRequestException('channel base access number plus application extension must not exceed 21 digits');
  }
  return upstreamSrcId;
}

function positiveInteger(value: string | undefined, fallback: number) {
  const parsed = Number(value);
  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
}

function parseOptionalSequenceId(value: string | null | undefined) {
  if (!value) return undefined;
  const parsed = Number(value);
  return Number.isInteger(parsed) && parsed >= 0 && parsed <= 0xffffffff ? parsed : undefined;
}

function shanghaiDateKey(now = new Date()) {
  const parts = new Intl.DateTimeFormat('en-CA', {
    timeZone: 'Asia/Shanghai',
    year: 'numeric',
    month: '2-digit',
    day: '2-digit',
  }).formatToParts(now);
  const values = Object.fromEntries(parts.map((part) => [part.type, part.value]));
  return `${values.year}-${values.month}-${values.day}`;
}

function bullmqConnection() {
  const redisUrl = new URL(process.env.REDIS_URL ?? 'redis://127.0.0.1:6379');
  return {
    host: redisUrl.hostname,
    port: Number(redisUrl.port || 6379),
    username: redisUrl.username || undefined,
    password: redisUrl.password || undefined,
    maxRetriesPerRequest: null,
  };
}

function matchesApplicationSecret(data: GatewayInboundAuthDto, secretHash: string) {
  if (data.authSource && data.timestamp !== undefined) {
    const expected = createHash('md5')
      .update(Buffer.concat([
        Buffer.from(octetString(data.account, 6), 'binary'),
        Buffer.alloc(9),
        Buffer.from(secretHash),
        Buffer.from(String(data.timestamp).padStart(10, '0')),
      ]))
      .digest('base64');
    return expected === data.authSource;
  }
  if (!data.password) {
    return false;
  }
  return data.password === secretHash || createHash('sha256').update(data.password).digest('hex') === secretHash;
}

function octetString(value: string, fixedLength: number) {
  if (value.length === fixedLength) {
    return value;
  }
  if (value.length > fixedLength) {
    return value.slice(value.length - fixedLength);
  }
  return value + '\0'.repeat(fixedLength - value.length);
}

function hasRecoveryAuditStateChanged(
  previous: Record<string, unknown> | null,
  current: Record<string, unknown>,
) {
  if (!previous) {
    return true;
  }
  return ['state', 'gatewayInstanceId', 'lockOwner', 'failureCategory', 'lastError', 'lastSkipReason']
    .some((key) => (previous[key] ?? null) !== (current[key] ?? null));
}

function normalizeRecoveryFailureCategory(data: GatewayDownstreamRecoveryStatusDto) {
  const explicit = String(data.failureCategory ?? '').trim();
  if (explicit) {
    return explicit;
  }
  if (data.state === 'success' || data.state === 'running') {
    return null;
  }
  if (data.lastSkipReason === 'backoff') {
    return 'backoff';
  }
  if (data.lastSkipReason === 'locked') {
    return 'lock_contended';
  }
  if (data.lastSkipReason === 'lock_lost') {
    return 'lock_lost';
  }
  if (data.state === 'waiting_connection') {
    return 'client_disconnected';
  }
  if (data.state === 'partial') {
    return 'partial_delivery_failed';
  }
  if (data.state === 'failed' && data.lastError) {
    return 'flush_failed';
  }
  return data.state ? 'unknown' : null;
}