import { BadRequestException, NotFoundException } from '@nestjs/common';

import { Prisma } from '@prisma/client';

import { PrismaService } from '../prisma/prisma.service';
import type {
  CreateReportFieldDto,
  ReplaceReportFieldsDto,
  CreateReportMaterialDto,
  CreateReportTaskDto,
  ChangeReportTaskStatusesDto,
  CreateReportExportDto,
  CreateReceiptImportDto,
} from './channels.contracts';
import {
  parseReceiptContent,
  deriveReceiptStatus,
  ChannelReportDeliveryRow,
  summarizeChannelReportDelivery,
  latestDate,
  currentShanghaiDayRange,
  normalizeSpreadsheetSize,
  normalizeBusinessCarrier,
  normalizeChannelCarriers,
  normalizeReportType,
  summarizeReportStatuses,
} from './channels.helpers';

/** R5 channel domain service composed behind ChannelsService. */
export class ChannelReportingService {
  constructor(private readonly prisma: PrismaService) {}

  listReportFields(channelId?: string) {
    return this.prisma.channelReportField.findMany({
      where: channelId ? { channelId } : undefined,
      include: { drainageField: true },
      orderBy: [{ sortOrder: 'asc' }, { createdAt: 'desc' }],
    });
  }

  async createReportField(data: CreateReportFieldDto) {
    if (!data.drainageFieldId) throw new BadRequestException('drainageFieldId is required');
    const field = await this.prisma.drainageField.findUnique({ where: { id: data.drainageFieldId } });
    if (!field || field.status !== 'active') {
      throw new BadRequestException('报备字段库字段不存在或已停用');
    }
    const reportType = normalizeReportType(data.reportType);
    return this.prisma.channelReportField.create({
      data: {
        channelId: data.channelId,
        drainageFieldId: field.id,
        reportType,
        code: field.code,
        name: field.name,
        exportName: data.exportName?.trim() || field.name,
        fieldType: field.fieldType,
        required: data.required ?? field.required,
        description: data.description ?? field.description,
        sortOrder: data.sortOrder ?? 100,
        columnWidth: normalizeSpreadsheetSize(data.columnWidth, 18, 6, 80),
        imageWidth: normalizeSpreadsheetSize(data.imageWidth, 120, 24, 600),
        imageHeight: normalizeSpreadsheetSize(data.imageHeight, 80, 24, 600),
        defaultValue: data.defaultValue,
        transform: data.transform,
        status: data.status ?? 'active',
      },
    });
  }

  async replaceReportFields(channelId: string, reportType: 'signature' | 'drainage', data: ReplaceReportFieldsDto) {
    const channel = await this.prisma.smsChannel.findUnique({ where: { id: channelId } });
    if (!channel) throw new NotFoundException('Channel not found');
    const ids = data.fields.map((field) => field.drainageFieldId);
    if (new Set(ids).size !== ids.length) throw new BadRequestException('同一通道报备类型不能重复配置字段');
    const libraryFields = await this.prisma.drainageField.findMany({ where: { id: { in: ids }, status: 'active' } });
    if (libraryFields.length !== ids.length) throw new BadRequestException('报备字段库字段不存在或已停用');
    const fieldById = new Map(libraryFields.map((field) => [field.id, field]));
    return this.prisma.$transaction(async (tx) => {
      const oppositeType = reportType === 'signature' ? 'drainage' : 'signature';
      const [legacyBoth, oppositeFields] = await Promise.all([
        tx.channelReportField.findMany({ where: { channelId, reportType: 'both' } }),
        tx.channelReportField.findMany({ where: { channelId, reportType: oppositeType } }),
      ]);
      const oppositeCodes = new Set(oppositeFields.map((field) => field.code));
      await tx.channelReportField.deleteMany({ where: { channelId, reportType: { in: [reportType, 'both'] } } });
      for (const legacy of legacyBoth) {
        if (oppositeCodes.has(legacy.code)) continue;
        const { id: _id, createdAt: _createdAt, updatedAt: _updatedAt, ...legacyData } = legacy;
        void _id;
        void _createdAt;
        void _updatedAt;
        await tx.channelReportField.create({ data: { ...legacyData, reportType: oppositeType } });
      }
      for (const [index, configured] of data.fields.entries()) {
        const field = fieldById.get(configured.drainageFieldId)!;
        await tx.channelReportField.create({
          data: {
            channelId,
            drainageFieldId: field.id,
            reportType,
            code: field.code,
            name: field.name,
            exportName: configured.exportName?.trim() || field.name,
            fieldType: field.fieldType,
            required: configured.required ?? field.required,
            description: configured.description ?? field.description,
            sortOrder: configured.sortOrder ?? (index + 1) * 10,
            columnWidth: normalizeSpreadsheetSize(configured.columnWidth, 18, 6, 80),
            imageWidth: normalizeSpreadsheetSize(configured.imageWidth, 120, 24, 600),
            imageHeight: normalizeSpreadsheetSize(configured.imageHeight, 80, 24, 600),
            defaultValue: configured.defaultValue,
            transform: configured.transform,
            status: configured.status ?? 'active',
          },
        });
      }
      return tx.channelReportField.findMany({
        where: { channelId, reportType },
        include: { drainageField: true },
        orderBy: [{ sortOrder: 'asc' }, { createdAt: 'asc' }],
      });
    });
  }

  listReportMaterials(signatureId?: string, channelId?: string) {
    return this.prisma.signatureReportMaterial.findMany({
      where: {
        signatureId,
        channelId,
      },
      orderBy: { createdAt: 'desc' },
    });
  }

  upsertReportMaterial(data: CreateReportMaterialDto) {
    return this.prisma.signatureReportMaterial.upsert({
      where: {
        signatureId_channelId_fieldCode: {
          signatureId: data.signatureId,
          channelId: data.channelId,
          fieldCode: data.fieldCode,
        },
      },
      update: {
        fieldValue: data.fieldValue,
        fileObjectId: data.fileObjectId,
      },
      create: {
        signatureId: data.signatureId,
        channelId: data.channelId,
        fieldCode: data.fieldCode,
        fieldValue: data.fieldValue,
        fileObjectId: data.fileObjectId,
      },
    });
  }

  async listReportTasks(tenantId?: string, status?: string, channelId?: string, reportType?: string) {
    const tasks = await this.prisma.channelSignatureReportTask.findMany({
      where: {
        tenantId,
        status:
          status === 'reporting' || status === 'exporting'
            ? { in: ['reporting', 'exporting'] }
            : status === 'failed'
              ? { in: ['failed', 'rejected'] }
              : status,
        channelId,
        reportType,
        signature: { auditStatus: { not: 'deleted' } },
      },
      include: {
        signature: { include: { tenant: true, application: true } },
        channel: true,
        drainageInfo: true,
        exportItems: {
          include: { exportFile: true, batchItem: { include: { batch: true } } },
          orderBy: { id: 'desc' },
          take: 1,
        },
        records: { orderBy: { createdAt: 'desc' }, take: 20 },
      },
      orderBy: { createdAt: 'desc' },
    });
    if (tasks.length === 0) {
      return tasks;
    }

    const channelIds = [...new Set(tasks.map((task) => task.channelId))];
    const signatureIds = [...new Set(tasks.map((task) => task.signatureId))];
    const day = currentShanghaiDayRange();
    const rows = await this.prisma.$queryRaw<ChannelReportDeliveryRow[]>(Prisma.sql`
      WITH base AS (
        SELECT
          submit."channelId" AS channel_id,
          message."signatureId" AS signature_id,
          message."drainageInfoId" AS drainage_info_id,
          submit."submitStatus" AS submit_status,
          COALESCE(submit."submittedAt", submit."createdAt") AS attempted_at,
          CASE
            WHEN segment_summary.segment_count > 0
              AND segment_summary.delivered_count = segment_summary.segment_count
              THEN segment_summary.completed_at
            WHEN segment_summary.segment_count = 0 THEN delivered_receipt.delivered_at
          END AS successful_at,
          CASE
            WHEN submit."submitStatus" <> 'accepted' THEN 'submit_failed'
            WHEN segment_summary.segment_count > 0 AND segment_summary.failure_count > 0 THEN 'failure'
            WHEN segment_summary.segment_count > 0
              AND segment_summary.delivered_count = segment_summary.segment_count THEN 'success'
            WHEN segment_summary.segment_count = 0 AND failed_receipt.failed_at IS NOT NULL THEN 'failure'
            WHEN segment_summary.segment_count = 0 AND delivered_receipt.delivered_at IS NOT NULL THEN 'success'
            ELSE 'unknown'
          END AS delivery_status
        FROM "SmsSubmitRecord" submit
        JOIN "SmsMessageRecord" message ON message.id = submit."messageRecordId"
        LEFT JOIN LATERAL (
          SELECT
            COUNT(*)::integer AS segment_count,
            COUNT(*) FILTER (WHERE segment."receiptStatus" = 'delivered')::integer AS delivered_count,
            COUNT(*) FILTER (WHERE segment."receiptStatus" = 'undelivered')::integer AS failure_count,
            MAX(segment."deliveredAt") FILTER (WHERE segment."receiptStatus" = 'delivered') AS completed_at
          FROM "SmsMessageSegmentAudit" segment
          WHERE segment."submitRecordId" = submit.id
        ) segment_summary ON TRUE
        LEFT JOIN LATERAL (
          SELECT MIN(receipt."deliveredAt") AS delivered_at
          FROM "SmsReceiptRecord" receipt
          WHERE receipt."gatewayMessageId" = submit."gatewayMessageId"
            AND receipt."channelId" = submit."channelId"
            AND receipt."receiptStatus" = 'delivered'
        ) delivered_receipt ON TRUE
        LEFT JOIN LATERAL (
          SELECT MIN(receipt."deliveredAt") AS failed_at
          FROM "SmsReceiptRecord" receipt
          WHERE receipt."gatewayMessageId" = submit."gatewayMessageId"
            AND receipt."channelId" = submit."channelId"
            AND receipt."receiptStatus" = 'undelivered'
        ) failed_receipt ON TRUE
        WHERE submit."submitStatus" IN ('accepted', 'rejected', 'timeout')
          AND submit."channelId" IN (${Prisma.join(channelIds)})
          AND message."signatureId" IN (${Prisma.join(signatureIds)})
      )
      SELECT
        channel_id AS "channelId",
        signature_id AS "signatureId",
        drainage_info_id AS "drainageInfoId",
        COUNT(*) FILTER (
          WHERE attempted_at >= ${day.startAt} AND attempted_at < ${day.endAt}
        )::integer AS total,
        COUNT(*) FILTER (
          WHERE attempted_at >= ${day.startAt} AND attempted_at < ${day.endAt}
            AND submit_status = 'accepted'
        )::integer AS "acceptedCount",
        COUNT(*) FILTER (
          WHERE attempted_at >= ${day.startAt} AND attempted_at < ${day.endAt}
            AND delivery_status = 'submit_failed'
        )::integer AS "submitFailureCount",
        COUNT(*) FILTER (
          WHERE attempted_at >= ${day.startAt} AND attempted_at < ${day.endAt}
            AND delivery_status = 'success'
        )::integer AS "successCount",
        COUNT(*) FILTER (
          WHERE attempted_at >= ${day.startAt} AND attempted_at < ${day.endAt}
            AND delivery_status = 'unknown'
        )::integer AS "unknownCount",
        COUNT(*) FILTER (
          WHERE attempted_at >= ${day.startAt} AND attempted_at < ${day.endAt}
            AND delivery_status = 'failure'
        )::integer AS "failureCount",
        MAX(successful_at) FILTER (WHERE delivery_status = 'success') AS "lastSuccessfulSentAt"
      FROM base
      GROUP BY channel_id, signature_id, drainage_info_id
    `);

    return tasks.map((task) => {
      const taskRows = rows.filter(
        (row) =>
          row.channelId === task.channelId &&
          row.signatureId === task.signatureId &&
          ((task.reportType ?? 'signature') === 'signature' || row.drainageInfoId === task.drainageItemId),
      );
      const deliveryStats = summarizeChannelReportDelivery(taskRows);
      return {
        ...task,
        deliveryStats,
        lastSuccessfulSentAt: latestDate(taskRows.map((row) => row.lastSuccessfulSentAt)),
      };
    });
  }

  async listReportTasksPage(query: {
    tenantId?: string;
    applicationId?: string;
    status?: string;
    channelId?: string;
    reportType?: string;
    keyword?: string;
    carrier?: string;
    todaySendMin?: number;
    todaySendMax?: number;
    sort?: string;
    createdAtFrom?: string;
    createdAtTo?: string;
    page?: number;
    pageSize?: number;
  }) {
    const page = Math.max(1, Math.floor(Number(query.page) || 1));
    const pageSize = Math.min(100, Math.max(1, Math.floor(Number(query.pageSize) || 10)));
    const keyword = query.keyword?.trim();
    const from = query.createdAtFrom ? new Date(`${query.createdAtFrom}T00:00:00+08:00`) : undefined;
    const to = query.createdAtTo ? new Date(`${query.createdAtTo}T23:59:59.999+08:00`) : undefined;
    const all = await this.listReportTasks(query.tenantId, query.status, query.channelId, query.reportType);
    const filtered = all.filter((task) => {
      const createdAt = task.createdAt instanceof Date ? task.createdAt : new Date(task.createdAt);
      const total = (task as typeof task & { deliveryStats?: { total: number } }).deliveryStats?.total ?? 0;
      if (query.applicationId && task.signature.applicationId !== query.applicationId) return false;
      if (query.carrier && task.carrier !== query.carrier) return false;
      if (from && createdAt < from) return false;
      if (to && createdAt > to) return false;
      if (Number.isFinite(query.todaySendMin) && total < Number(query.todaySendMin)) return false;
      if (Number.isFinite(query.todaySendMax) && total > Number(query.todaySendMax)) return false;
      if (!keyword) return true;
      return [
        task.id,
        task.channel.name,
        task.signature.name,
        task.signature.tenant.name,
        task.signature.application?.name,
        task.drainageInfo?.siteName,
        task.drainageInfo?.url,
      ].some((value) => String(value ?? '').includes(keyword));
    });
    filtered.sort((left, right) =>
      query.sort === 'todaySendDesc'
        ? ((right as typeof right & { deliveryStats?: { total: number } }).deliveryStats?.total ?? 0) -
            ((left as typeof left & { deliveryStats?: { total: number } }).deliveryStats?.total ?? 0) ||
          right.updatedAt.getTime() - left.updatedAt.getTime()
        : right.createdAt.getTime() - left.createdAt.getTime(),
    );
    return { items: filtered.slice((page - 1) * pageSize, page * pageSize), total: filtered.length, page, pageSize };
  }

  async listReportDetailsPage(query: {
    tenantId?: string;
    applicationId?: string;
    signatureId?: string;
    channelId?: string;
    carrier?: string;
    status?: string;
    reportType?: string;
    keyword?: string;
    createdAtFrom?: string;
    createdAtTo?: string;
    page?: number;
    pageSize?: number;
  }) {
    const page = Math.max(1, Math.floor(Number(query.page) || 1));
    const pageSize = Math.min(100, Math.max(1, Math.floor(Number(query.pageSize) || 10)));
    const signatures = await this.prisma.smsSignature.findMany({
      where: {
        id: query.signatureId,
        tenantId: query.tenantId,
        applicationId: query.applicationId,
        auditStatus: 'approved',
      },
      include: {
        tenant: true,
        application: true,
        drainageItems: { where: { auditStatus: 'approved' } },
        reportTasks: {
          include: {
            channel: true,
            drainageInfo: true,
            exportItems: {
              include: { exportFile: true, batchItem: { include: { batch: true } } },
              orderBy: { id: 'desc' },
              take: 1,
            },
            records: { orderBy: { createdAt: 'desc' }, take: 20 },
          },
        },
      },
      orderBy: [{ updatedAt: 'desc' }, { id: 'desc' }],
    });
    const applicationIds = [
      ...new Set(signatures.map((item) => item.applicationId).filter((id): id is string => Boolean(id))),
    ];
    const routes = applicationIds.length
      ? await this.prisma.channelRouteRule.findMany({
          where: { applicationId: { in: applicationIds }, status: 'active' },
          include: { group: { include: { items: { include: { channel: true } } } } },
        })
      : [];
    const details = signatures
      .flatMap((signature) => {
        const channels = [
          ...new Map(
            routes
              .filter((route) => route.applicationId === signature.applicationId && route.group.status === 'active')
              .flatMap((route) => route.group.items.map((item) => item.channel))
              .filter((channel) => channel.status === 'active')
              .map((channel) => [channel.id, channel]),
          ).values(),
        ];
        const signatureDetails = channels.flatMap((channel) =>
          normalizeChannelCarriers(channel.carriers, channel.carrier).map((carrier) => {
            const existing = signature.reportTasks.find(
              (task) =>
                task.reportType === 'signature' &&
                task.channelId === channel.id &&
                (task.carrier === carrier || (!task.carrier && task.approvalScope === 'legacy_channel')),
            );
            return existing
              ? { ...existing, signature }
              : {
                  id: `virtual:${signature.id}:${channel.id}:${carrier}`,
                  tenantId: signature.tenantId,
                  signatureId: signature.id,
                  channelId: channel.id,
                  carrier,
                  approvalScope: 'carrier_specific',
                  reportType: 'signature',
                  drainageItemId: null,
                  status: 'pending',
                  reason: null,
                  approvedAt: null,
                  createdAt: signature.reportChangedAt ?? signature.updatedAt,
                  updatedAt: signature.reportChangedAt ?? signature.updatedAt,
                  createdById: null,
                  signature,
                  channel,
                  drainageInfo: null,
                  exportItems: [],
                  records: [],
                  virtual: true,
                };
          }),
        );
        const drainageDetails = signature.drainageItems.flatMap((drainageInfo) =>
          channels
            .map((channel) => {
              const existing = signature.reportTasks.find(
                (task) =>
                  task.reportType === 'drainage' &&
                  task.channelId === channel.id &&
                  task.drainageItemId === drainageInfo.id,
              );
              return existing ? { ...existing, signature } : undefined;
            })
            .filter(Boolean),
        );
        return [...signatureDetails, ...drainageDetails];
      })
      .filter((task) => {
        if (!task) return false;
        if (query.channelId && task.channelId !== query.channelId) return false;
        if (query.carrier && task.carrier !== query.carrier) return false;
        if (query.status && task.status !== query.status) return false;
        if (query.reportType && task.reportType !== query.reportType) return false;
        const changedAt = new Date(task.updatedAt);
        if (query.createdAtFrom && changedAt < new Date(`${query.createdAtFrom}T00:00:00+08:00`)) return false;
        if (query.createdAtTo && changedAt > new Date(`${query.createdAtTo}T23:59:59.999+08:00`)) return false;
        if (!query.keyword?.trim()) return true;
        const keyword = query.keyword.trim();
        return [
          task.id,
          task.signature.name,
          task.signature.tenant.name,
          task.signature.application?.name,
          task.channel.name,
          task.drainageInfo?.siteName,
          task.drainageInfo?.url,
        ].some((value) => String(value ?? '').includes(keyword));
      });
    return { items: details.slice((page - 1) * pageSize, page * pageSize), total: details.length, page, pageSize };
  }

  async createReportTask(data: CreateReportTaskDto) {
    const reportType = data.reportType ?? 'signature';
    if (reportType === 'drainage' && !data.drainageItemId) throw new BadRequestException('drainageItemId is required');
    if (reportType === 'drainage') {
      const drainageInfo = await this.prisma.smsDrainageInfo.findUnique({ where: { id: data.drainageItemId! } });
      if (!drainageInfo || drainageInfo.signatureId !== data.signatureId)
        throw new NotFoundException('Drainage info not found');
      if (drainageInfo.auditStatus !== 'approved') throw new BadRequestException('引流信息审核通过后才能进入通道报备');
      throw new BadRequestException('引流信息通道报备任务由运营审核通过后按应用路由自动生成');
    }
    const channel = await this.prisma.smsChannel.findUnique({ where: { id: data.channelId } });
    if (!channel) throw new NotFoundException('Channel not found');
    if (!data.carrier) throw new BadRequestException('签名报备任务必须指定运营商');
    const carrier = normalizeBusinessCarrier(data.carrier);
    if (!normalizeChannelCarriers(channel.carriers, channel.carrier).includes(carrier)) {
      throw new BadRequestException('报备运营商不在通道支持范围内');
    }
    const existing = await this.prisma.channelSignatureReportTask.findFirst({
      where: {
        signatureId: data.signatureId,
        channelId: data.channelId,
        carrier,
        reportType: 'signature',
        drainageItemId: null,
      },
    });
    if (existing) throw new BadRequestException('该签名在当前通道和运营商下已存在报备任务');
    const task = await this.prisma.channelSignatureReportTask.create({
      data: {
        tenantId: data.tenantId,
        signatureId: data.signatureId,
        channelId: data.channelId,
        carrier,
        approvalScope: 'carrier_specific',
        reportType,
        drainageItemId: undefined,
        createdById: data.createdById,
        status: 'pending',
      },
    });
    await this.recordReportTask(task.id, task.channelId, 'create', undefined, 'pending');
    return task;
  }

  async changeReportTaskStatuses(data: ChangeReportTaskStatusesDto) {
    if (!data.items.length) throw new BadRequestException('items is required');
    const allowed = new Set([
      'pending',
      'waiting_material',
      'reporting',
      'approved',
      'failed',
      'rejected',
      'abandoned',
    ]);
    for (const item of data.items) {
      if (!allowed.has(item.status)) throw new BadRequestException('unsupported report task status');
    }
    const sourceEntry = data.sourceEntry ?? 'report_task';
    if (!['enterprise_signature', 'report_task', 'channel_report'].includes(sourceEntry)) {
      throw new BadRequestException('unsupported report task source entry');
    }
    return this.prisma.$transaction(async (tx) => {
      const signatureIds = [
        ...new Set(
          data.items.filter((item) => (item.reportType ?? 'signature') === 'signature').map((item) => item.signatureId),
        ),
      ];
      const drainageResults: Array<{
        signatureId: string;
        reportType: 'drainage';
        drainageItemId: string;
        channelId: string;
        status: string;
      }> = [];
      for (const item of data.items) {
        const reportType = item.reportType ?? 'signature';
        if (reportType === 'drainage' && !item.drainageItemId)
          throw new BadRequestException('drainageItemId is required');
        const signature = await tx.smsSignature.findUnique({ where: { id: item.signatureId } });
        const channel = await tx.smsChannel.findUnique({ where: { id: item.channelId } });
        if (!signature || !channel) throw new NotFoundException('Signature or channel not found');
        if (reportType === 'drainage') {
          const drainageInfo = await tx.smsDrainageInfo.findUnique({ where: { id: item.drainageItemId! } });
          if (!drainageInfo || drainageInfo.signatureId !== item.signatureId)
            throw new NotFoundException('Drainage info not found');
          if (drainageInfo.auditStatus !== 'approved')
            throw new BadRequestException('引流信息审核通过后才能修改通道报备状态');
        }
        const carrier = reportType === 'signature' && item.carrier ? normalizeBusinessCarrier(item.carrier) : null;
        if (carrier && !normalizeChannelCarriers(channel.carriers, channel.carrier).includes(carrier)) {
          throw new BadRequestException('报备运营商不在通道支持范围内');
        }
        const existing = await tx.channelSignatureReportTask.findFirst({
          where: {
            signatureId: item.signatureId,
            channelId: item.channelId,
            reportType,
            drainageItemId: reportType === 'drainage' ? item.drainageItemId : null,
            carrier: reportType === 'signature' ? carrier : null,
          },
        });
        if (reportType === 'drainage' && !existing)
          throw new BadRequestException('引流信息通道报备任务不存在，请先完成运营审核');
        if (reportType === 'signature' && !carrier && !existing)
          throw new BadRequestException('签名报备状态必须指定运营商');
        const approvedAt =
          item.status === 'approved'
            ? existing?.status === 'approved'
              ? (existing.approvedAt ?? new Date())
              : new Date()
            : null;
        const task = existing
          ? await tx.channelSignatureReportTask.update({
              where: { id: existing.id },
              data: { status: item.status, reason: data.reason, ...(reportType === 'signature' ? { approvedAt } : {}) },
            })
          : await tx.channelSignatureReportTask.create({
              data: {
                tenantId: signature.tenantId,
                signatureId: item.signatureId,
                channelId: item.channelId,
                carrier,
                approvalScope: 'carrier_specific',
                approvedAt,
                reportType,
                drainageItemId: reportType === 'drainage' ? item.drainageItemId : undefined,
                status: item.status,
                reason: data.reason,
                createdById: data.operatorId,
              },
            });
        await tx.channelSignatureReportRecord.create({
          data: {
            taskId: task.id,
            channelId: item.channelId,
            action: 'manual_status_change',
            statusBefore: existing?.status,
            statusAfter: item.status,
            reason: data.reason,
            operatorId: data.operatorId,
            sourceEntry,
          },
        });
        if (reportType === 'drainage')
          drainageResults.push({
            signatureId: item.signatureId,
            reportType,
            drainageItemId: item.drainageItemId!,
            channelId: item.channelId,
            status: item.status,
          });
      }
      const summaries = [];
      for (const signatureId of signatureIds)
        summaries.push(await this.recomputeSignatureReportSummary(tx, signatureId));
      return [...summaries, ...drainageResults];
    });
  }

  async recomputeSignatureReportSummary(tx: Prisma.TransactionClient, signatureId: string) {
    const signature = await tx.smsSignature.findUnique({ where: { id: signatureId } });
    if (!signature) throw new NotFoundException('Signature not found');
    const routes = signature.applicationId
      ? await tx.channelRouteRule.findMany({
          where: { applicationId: signature.applicationId, status: 'active' },
          include: { group: { include: { items: { include: { channel: true } } } } },
        })
      : [];
    const configuredChannels = routes
      .flatMap((route) => route.group.items.map((item) => item.channel))
      .filter((channel) => channel.status !== 'deleted');
    const tasks = await tx.channelSignatureReportTask.findMany({
      where: { signatureId, reportType: 'signature' },
      include: { channel: true },
    });
    const channels = configuredChannels.length ? configuredChannels : tasks.map((task) => task.channel);
    const uniqueChannels = [...new Map(channels.map((channel) => [channel.id, channel])).values()];
    const carrierReportSummary = Object.fromEntries(
      ['mobile', 'unicom', 'telecom'].map((carrier) => {
        const targets = uniqueChannels.filter((channel) =>
          normalizeChannelCarriers(channel.carriers, channel.carrier).includes(carrier),
        );
        const statuses = targets.map((channel) => {
          const task =
            tasks.find((candidate) => candidate.channelId === channel.id && candidate.carrier === carrier) ??
            tasks.find(
              (candidate) =>
                candidate.channelId === channel.id &&
                candidate.carrier === null &&
                candidate.approvalScope === 'legacy_channel',
            );
          return task?.status ?? 'pending';
        });
        return [carrier, summarizeReportStatuses(statuses)];
      }),
    );
    const allStatuses = ['mobile', 'unicom', 'telecom'].flatMap((carrier) => {
      const targets = uniqueChannels.filter((channel) =>
        normalizeChannelCarriers(channel.carriers, channel.carrier).includes(carrier),
      );
      return targets.map(
        (channel) =>
          tasks.find((candidate) => candidate.channelId === channel.id && candidate.carrier === carrier)?.status ??
          tasks.find(
            (candidate) =>
              candidate.channelId === channel.id &&
              candidate.carrier === null &&
              candidate.approvalScope === 'legacy_channel',
          )?.status ??
          'pending',
      );
    });
    const reportStatus = summarizeReportStatuses(allStatuses).status;
    await tx.smsSignature.update({ where: { id: signatureId }, data: { reportStatus } });
    return { signatureId, reportStatus, carrierReportSummary };
  }

  async createReportExport(taskId: string, data: CreateReportExportDto) {
    const task = await this.getReportTaskOrThrow(taskId);
    const exported = await this.prisma.reportExportFile.create({
      data: {
        taskId,
        fileObjectId: data.fileObjectId,
        fileName: data.fileName,
        rowCount: data.rowCount ?? 0,
      },
    });
    await this.updateReportTaskStatus(taskId, task.channelId, task.status, 'exporting', 'export');
    return exported;
  }

  async importReportReceipt(taskId: string, data: CreateReceiptImportDto) {
    const task = await this.getReportTaskOrThrow(taskId);
    const parsed = data.fileContent ? parseReceiptContent(data.fileContent, data.delimiter) : undefined;
    const rowCount = data.rowCount ?? parsed?.rowCount ?? 0;
    const successCount = data.successCount ?? parsed?.successCount ?? 0;
    const failedCount = data.failedCount ?? parsed?.failedCount ?? 0;
    const statusAfter = data.statusAfter ?? deriveReceiptStatus(rowCount, successCount, failedCount);
    const imported = await this.prisma.reportReceiptImport.create({
      data: {
        taskId,
        fileObjectId: data.fileObjectId,
        fileName: data.fileName,
        rowCount,
        successCount,
        failedCount,
        status: 'imported',
        result: (data.result ?? parsed?.result) as Prisma.InputJsonValue | undefined,
      },
    });
    await this.updateReportTaskStatus(taskId, task.channelId, task.status, statusAfter, 'receipt_import', data.reason);
    if ((task.reportType ?? 'signature') === 'signature') {
      await this.recomputeSignatureReportSummary(this.prisma as unknown as Prisma.TransactionClient, task.signatureId);
    }
    return imported;
  }

  listReportRecords(taskId?: string, channelId?: string) {
    return this.prisma.channelSignatureReportRecord.findMany({
      where: { taskId, channelId },
      include: { channel: true, task: { include: { signature: true, drainageInfo: true } } },
      orderBy: { createdAt: 'desc' },
    });
  }

  async listReportRecordsPage(query: {
    taskId?: string;
    channelId?: string;
    batchNo?: string;
    statusAfter?: string;
    action?: string;
    sourceEntry?: string;
    operatorKeyword?: string;
    keyword?: string;
    reportType?: string;
    createdAtFrom?: string;
    createdAtTo?: string;
    page?: number;
    pageSize?: number;
  }) {
    const page = Math.max(1, Math.floor(Number(query.page) || 1));
    const pageSize = Math.min(100, Math.max(1, Math.floor(Number(query.pageSize) || 10)));
    const keyword = query.keyword?.trim();
    const operatorKeyword = query.operatorKeyword?.trim();
    const operatorIds = operatorKeyword
      ? (
          await this.prisma.user.findMany({
            where: {
              OR: [{ username: { contains: operatorKeyword } }, { displayName: { contains: operatorKeyword } }],
            },
            select: { id: true },
          })
        ).map((item) => item.id)
      : undefined;
    const where: Prisma.ChannelSignatureReportRecordWhereInput = {
      taskId: query.taskId,
      channelId: query.channelId,
      statusAfter: query.statusAfter,
      action: query.action,
      sourceEntry: query.sourceEntry,
      operatorId: operatorIds ? { in: operatorIds } : undefined,
      task:
        query.reportType || query.batchNo
          ? {
              reportType: query.reportType,
              exportItems: query.batchNo
                ? { some: { batchItem: { batch: { batchNo: { contains: query.batchNo.trim() } } } } }
                : undefined,
            }
          : undefined,
      createdAt:
        query.createdAtFrom || query.createdAtTo
          ? {
              gte: query.createdAtFrom ? new Date(`${query.createdAtFrom}T00:00:00+08:00`) : undefined,
              lte: query.createdAtTo ? new Date(`${query.createdAtTo}T23:59:59.999+08:00`) : undefined,
            }
          : undefined,
      OR: keyword
        ? [
            { taskId: { contains: keyword } },
            { action: { contains: keyword } },
            { reason: { contains: keyword } },
            { channel: { name: { contains: keyword } } },
            { task: { signature: { name: { contains: keyword } } } },
            { task: { drainageInfo: { siteName: { contains: keyword } } } },
            { task: { drainageInfo: { url: { contains: keyword } } } },
          ]
        : undefined,
    };
    const [items, total] = await Promise.all([
      this.prisma.channelSignatureReportRecord.findMany({
        where,
        include: { channel: true, task: { include: { signature: true, drainageInfo: true } } },
        orderBy: [{ createdAt: 'desc' }, { id: 'desc' }],
        skip: (page - 1) * pageSize,
        take: pageSize,
      }),
      this.prisma.channelSignatureReportRecord.count({ where }),
    ]);
    const userIds = [...new Set(items.map((item) => item.operatorId).filter((id): id is string => Boolean(id)))];
    const operators = userIds.length
      ? await this.prisma.user.findMany({
          where: { id: { in: userIds } },
          select: { id: true, username: true, displayName: true },
        })
      : [];
    const operatorMap = new Map(operators.map((item) => [item.id, item]));
    return {
      items: items.map((item) => ({
        ...item,
        operator: item.operatorId ? operatorMap.get(item.operatorId) : undefined,
      })),
      total,
      page,
      pageSize,
    };
  }

  async getReportTaskOrThrow(taskId: string) {
    const task = await this.prisma.channelSignatureReportTask.findUnique({
      where: { id: taskId },
      include: { drainageInfo: true },
    });
    if (!task) {
      throw new NotFoundException('Report task not found');
    }
    if (task.reportType === 'drainage' && task.drainageInfo?.auditStatus !== 'approved') {
      throw new BadRequestException('引流信息审核通过后才能处理通道报备任务');
    }
    return task;
  }

  async updateReportTaskStatus(
    taskId: string,
    channelId: string,
    statusBefore: string,
    statusAfter: string,
    action: string,
    reason?: string,
  ) {
    await this.prisma.channelSignatureReportTask.update({
      where: { id: taskId },
      data: {
        status: statusAfter,
        reason,
        ...((
          await this.prisma.channelSignatureReportTask.findUnique({
            where: { id: taskId },
            select: { reportType: true, status: true, approvedAt: true },
          })
        )?.reportType === 'signature'
          ? { approvedAt: statusAfter === 'approved' ? (statusBefore === 'approved' ? undefined : new Date()) : null }
          : {}),
      },
    });
    await this.recordReportTask(taskId, channelId, action, statusBefore, statusAfter, reason);
  }

  recordReportTask(
    taskId: string,
    channelId: string,
    action: string,
    statusBefore: string | undefined,
    statusAfter: string,
    reason?: string,
  ) {
    return this.prisma.channelSignatureReportRecord.create({
      data: {
        taskId,
        channelId,
        action,
        statusBefore,
        statusAfter,
        reason,
      },
    });
  }
}