import { Prisma } from '@prisma/client';
import { BadRequestException } from '@nestjs/common';
import { moneyToNumber } from '../common/money';
import type { MessageQuery, TraceQuery, OperationLogQuery, GatewaySubmitDeadLetterQuery, DownstreamDeliveryQuery, DownstreamDeliveryDashboardQuery, DownstreamRecoveryStatusQuery, MessageSegmentAuditQuery, SignatureQualityQuery } from './operations.contracts';

// Pure query builders and response mappers shared by the R2 query domains.
export function messageWhere(query: MessageQuery): Prisma.SmsMessageRecordWhereInput {
  const statusWhere = query.status === 'submit_failed'
    ? { OR: [{ status: 'submit_failed' }, { submitStatus: { in: ['rejected', 'timeout'] } }] }
    : query.status === 'failed'
      ? { status: 'failed', submitStatus: 'accepted' }
      : query.status
        ? { status: query.status }
        : {};
  return {
    tenantId: query.tenantId,
    applicationId: query.applicationId,
    channelId: query.channelId,
    batchTaskId: query.taskId,
    messageId: query.messageId,
    phoneNumber: query.phoneNumber,
    ...carrierWhere(query.carrier),
    ...statusWhere,
    ...(query.hasDrainage === 'true' ? { hasDrainageContent: true }
      : query.hasDrainage === 'false' ? { hasDrainageContent: false }
        : query.hasDrainage === 'unknown' ? { hasDrainageContent: null }
          : {}),
    ...(query.contentKeyword ? { content: { contains: query.contentKeyword, mode: 'insensitive' } } : {}),
    ...(query.channelKeyword ? { channel: { name: { contains: query.channelKeyword, mode: 'insensitive' } } } : {}),
    ...(query.queuedAtFrom || query.queuedAtTo ? {
      queuedAt: {
        ...(query.queuedAtFrom ? { gte: startOfShanghaiDay(query.queuedAtFrom) } : {}),
        ...(query.queuedAtTo ? { lte: endOfShanghaiDay(query.queuedAtTo) } : {}),
      },
    } : {}),
  };
}

export const recognizedCarrierValues = [
  'mobile', 'cmcc', '移动', '中国移动',
  'unicom', 'cucc', '联通', '中国联通',
  'telecom', 'ctcc', '电信', '中国电信',
];
export function carrierWhere(carrier?: string): Prisma.SmsMessageRecordWhereInput {
  if (!carrier) return {};
  // Keep historical aliases queryable while treating null and future/nonstandard values as unrecognized.
  if (carrier === 'unknown') {
    return {
      AND: [
        {
          OR: [
            { carrier: null },
            { carrier: { notIn: recognizedCarrierValues } },
          ],
        },
      ],
    };
  }
  const valuesByCarrier: Record<string, string[]> = {
    mobile: ['mobile', 'cmcc', '移动', '中国移动'],
    unicom: ['unicom', 'cucc', '联通', '中国联通'],
    telecom: ['telecom', 'ctcc', '电信', '中国电信'],
  };
  return valuesByCarrier[carrier] ? { carrier: { in: valuesByCarrier[carrier] } } : {};
}
export function startOfShanghaiDay(value: string) {
  return new Date(`${value}T00:00:00+08:00`);
}
export function endOfShanghaiDay(value: string) {
  return new Date(`${value}T23:59:59.999+08:00`);
}
export function qualityBusinessDay(value?: string) {
  const key = value || shanghaiDateKey();
  if (!/^\d{4}-\d{2}-\d{2}$/.test(key)) {
    throw new BadRequestException('统计日期格式必须为 YYYY-MM-DD');
  }
  const startAt = startOfShanghaiDay(key);
  if (Number.isNaN(startAt.getTime()) || shanghaiDateKey(startAt) !== key) {
    throw new BadRequestException('统计日期无效');
  }
  return {
    key,
    startAt,
    endAt: new Date(startAt.getTime() + 24 * 60 * 60 * 1000),
  };
}
export function shanghaiDateKey(value = new Date()) {
  const parts = new Intl.DateTimeFormat('en-CA', {
    timeZone: 'Asia/Shanghai',
    year: 'numeric',
    month: '2-digit',
    day: '2-digit',
  }).formatToParts(value);
  const byType = new Map(parts.map((part) => [part.type, part.value]));
  return `${byType.get('year')}-${byType.get('month')}-${byType.get('day')}`;
}
export function normalizeGroupBy(groupBy?: string) {
  if (groupBy === 'tenant' || groupBy === 'tenantId') {
    return 'tenantId';
  }
  if (groupBy === 'application' || groupBy === 'applicationId') {
    return 'applicationId';
  }
  return 'channelId';
}
export function returnedTransactionWhere(since: Date, tenantId?: string): Prisma.AccountTransactionWhereInput {
  return {
    tenantId,
    createdAt: { gte: since },
    OR: [
      { transactionType: 'refunded' },
      { transactionType: 'released', relatedType: 'sms_message_record' },
    ],
  };
}
export function createdAtRange(range?: string): Prisma.DateTimeFilter | undefined {
  if (!range || range === 'all') {
    return undefined;
  }
  const date = new Date();
  date.setHours(0, 0, 0, 0);
  if (range === '7d') {
    date.setDate(date.getDate() - 6);
  } else if (range === '30d') {
    date.setDate(date.getDate() - 29);
  }
  return { gte: date };
}
export function downstreamAlertPendingMinutes() {
  const value = Number(process.env.CMPP_DOWNSTREAM_ALERT_PENDING_MINUTES ?? 10);
  return Number.isFinite(value) && value > 0 ? value : 10;
}
export function downstreamAlertRecentFailedHours() {
  const value = Number(process.env.CMPP_DOWNSTREAM_ALERT_RECENT_FAILED_HOURS ?? 1);
  return Number.isFinite(value) && value > 0 ? value : 1;
}
export function downstreamAlertWindows(now = new Date()) {
  return {
    now,
    stalledPendingAt: new Date(now.getTime() - downstreamAlertPendingMinutes() * 60_000),
    recentFailedAt: new Date(now.getTime() - downstreamAlertRecentFailedHours() * 60 * 60_000),
  };
}
export function downstreamAlertWhere(
  scopedWhere: Prisma.CmppDownstreamDeliveryWhereInput,
  window: ReturnType<typeof downstreamAlertWindows>,
): Prisma.CmppDownstreamDeliveryWhereInput {
  return {
    AND: [
      scopedWhere,
      {
        OR: [
          stalledPendingWhere(window.stalledPendingAt),
          { status: 'awaiting_ack', ackDeadlineAt: { lte: window.now } },
          { status: { in: ['failed', 'unconfirmed', 'rejected'] }, updatedAt: { gte: window.recentFailedAt } },
        ],
      },
    ],
  };
}
export function stalledPendingWhere(cutoff: Date): Prisma.CmppDownstreamDeliveryWhereInput {
  return {
    status: 'pending',
    OR: [
      { lastRetriedAt: null, createdAt: { lte: cutoff } },
      { lastRetriedAt: { lte: cutoff } },
    ],
  };
}
export function downstreamDeliveryScopedWhere(query: DownstreamDeliveryDashboardQuery): Prisma.CmppDownstreamDeliveryWhereInput {
  const createdAtFrom = parseDateBoundary(query.createdAtFrom, false);
  const createdAtTo = parseDateBoundary(query.createdAtTo, true);
  return {
    tenantId: query.tenantId,
    applicationId: query.applicationId,
    deliveryType: query.deliveryType && query.deliveryType !== 'all' ? query.deliveryType : undefined,
    createdAt: createdAtFrom || createdAtTo ? { gte: createdAtFrom, lte: createdAtTo } : undefined,
  };
}
export function parseDateBoundary(value?: string, endOfDay = false) {
  if (!value) return undefined;
  const parsed = new Date(`${value}T${endOfDay ? '23:59:59.999' : '00:00:00.000'}+08:00`);
  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
}
export function downstreamRecoveryStatusWhere(query: DownstreamRecoveryStatusQuery) {
  const updatedAtFrom = parseDateBoundary(query.updatedAtFrom, false);
  const updatedAtTo = parseDateBoundary(query.updatedAtTo, true);
  return {
    tenantId: query.tenantId,
    applicationId: query.applicationId,
    state: query.state && query.state !== 'all' ? query.state : undefined,
    failureCategory: query.failureCategory && query.failureCategory !== 'all' ? query.failureCategory : undefined,
    updatedAt: updatedAtFrom || updatedAtTo ? { gte: updatedAtFrom, lte: updatedAtTo } : undefined,
    OR: query.keyword ? [
      { account: { contains: query.keyword } },
      { gatewayInstanceId: { contains: query.keyword } },
      { lastError: { contains: query.keyword } },
      { lastSkipReason: { contains: query.keyword } },
      { tenant: { name: { contains: query.keyword } } },
      { application: { name: { contains: query.keyword } } },
    ] : undefined,
  };
}
export function escapeCsvCell(value: string) {
  let normalized = value.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
  if (/^[=+\-@]/.test(normalized)) {
    normalized = `'${normalized}`;
  }
  if (normalized.includes(',') || normalized.includes('"') || normalized.includes('\n')) {
    return `"${normalized.replace(/"/g, '""')}"`;
  }
  return normalized;
}
export function formatCsvDate(value?: Date | string | null) {
  if (!value) {
    return '';
  }
  return value instanceof Date ? value.toISOString() : value;
}
export function formatExportTimestamp(date: Date) {
  const parts = [
    date.getFullYear(),
    String(date.getMonth() + 1).padStart(2, '0'),
    String(date.getDate()).padStart(2, '0'),
    String(date.getHours()).padStart(2, '0'),
    String(date.getMinutes()).padStart(2, '0'),
    String(date.getSeconds()).padStart(2, '0'),
  ];
  return `${parts[0]}${parts[1]}${parts[2]}-${parts[3]}${parts[4]}${parts[5]}`;
}
export function clientApplicationView(application?: Record<string, any> | null) {
  if (!application) return null;
  return { id: application.id, name: application.name };
}
export function clientReceiptView(receipt: Record<string, any>) {
  return {
    id: receipt.id,
    messageId: receipt.messageId,
    receiptStatus: receipt.receiptStatus,
    rawStatus: receipt.rawStatus,
    errorCode: receipt.errorCode ?? null,
    errorMessage: receipt.errorMessage ?? null,
    deliveredAt: receipt.deliveredAt,
    createdAt: receipt.createdAt,
  };
}
export function clientMessageView(message: Record<string, any>) {
  return {
    id: message.id,
    batchTaskId: message.batchTaskId ?? null,
    applicationId: message.applicationId ?? null,
    messageId: message.messageId,
    phoneNumber: message.phoneNumber,
    carrier: message.carrier ?? null,
    province: message.province ?? null,
    content: message.content,
    billingUnits: message.billingUnits,
    amountCents: moneyToNumber(message.amountCents),
    status: message.status,
    submitStatus: message.submitStatus ?? null,
    receiptStatus: message.receiptStatus ?? null,
    errorCode: message.errorCode ?? null,
    errorMessage: message.errorMessage ?? null,
    queuedAt: message.queuedAt,
    submittedAt: message.submittedAt ?? null,
    deliveredAt: message.deliveredAt ?? null,
    application: clientApplicationView(message.application),
    receiptRecords: Array.isArray(message.receiptRecords) ? message.receiptRecords.map(clientReceiptView) : [],
  };
}
export function clientBatchTaskView(task: Record<string, any>) {
  return {
    id: task.id,
    taskNo: task.taskNo,
    applicationId: task.applicationId ?? null,
    templateId: task.templateId ?? null,
    content: task.content,
    category: task.category ?? null,
    phoneTotal: task.phoneTotal,
    status: task.status,
    auditStatus: task.auditStatus ?? null,
    reviewReason: task.reviewReason ?? null,
    rejectReason: task.rejectReason ?? null,
    progressTotal: task.progressTotal,
    progressSent: task.progressSent ?? 0,
    progressDelivered: task.progressDelivered ?? 0,
    progressFailed: task.progressFailed ?? 0,
    submittedTotal: task.submittedTotal ?? 0,
    successTotal: task.successTotal ?? 0,
    failedTotal: task.failedTotal ?? 0,
    unknownTotal: task.unknownTotal ?? 0,
    timeoutTotal: task.timeoutTotal ?? 0,
    scheduledAt: task.scheduledAt ?? null,
    canceledAt: task.canceledAt ?? null,
    createdAt: task.createdAt,
    application: clientApplicationView(task.application),
    messages: Array.isArray(task.messages) ? task.messages.map(clientMessageView) : [],
  };
}
export function clientUplinkView(message: Record<string, any>) {
  return {
    id: message.id,
    applicationId: message.applicationId ?? null,
    messageRecordId: message.messageRecordId ?? null,
    messageId: message.messageId ?? null,
    gatewayMessageId: message.gatewayMessageId ?? null,
    phoneNumber: message.phoneNumber,
    destId: message.destId,
    content: message.content,
    matchStatus: message.matchStatus,
    matchReason: message.matchReason ?? null,
    receivedAt: message.receivedAt,
    createdAt: message.createdAt,
    application: clientApplicationView(message.application),
    messageRecord: message.messageRecord ? clientMessageView(message.messageRecord) : null,
  };
}
export function clientAccountView(account: Record<string, any>) {
  return {
    id: account.id,
    tenantId: account.tenantId,
    balanceCents: moneyToNumber(account.balanceCents),
    creditCents: moneyToNumber(account.creditCents),
    status: account.status,
    updatedAt: account.updatedAt,
    tenant: account.tenant ? { id: account.tenant.id, name: account.tenant.name, status: account.tenant.status } : null,
  };
}
export function clientRechargeView(order: Record<string, any>) {
  return {
    id: order.id,
    orderNo: order.orderNo,
    amountCents: moneyToNumber(order.amountCents),
    status: order.status,
    payMethod: order.payMethod,
    remark: order.remark ?? null,
    createdAt: order.createdAt,
    completedAt: order.completedAt ?? null,
  };
}
export function summarizeMessageGroups(groups: Array<{ status: string; _count: { _all: number }; _sum: { amountCents: number | bigint | null; billingUnits: number | null } }>) {
  return groups.reduce(
    (summary, group) => {
      const count = group._count._all;
      summary.total += count;
      summary.amountCents += moneyToNumber(group._sum.amountCents);
      summary.billingUnits += group._sum.billingUnits ?? 0;
      if (group.status === 'delivered') {
        summary.delivered += count;
      } else if (['undelivered', 'submit_failed', 'timeout', 'failed', 'rejected'].includes(group.status)) {
        summary.failed += count;
      } else if (group.status === 'unknown') {
        summary.unknown += count;
      }
      return summary;
    },
    { total: 0, delivered: 0, failed: 0, unknown: 0, amountCents: 0, billingUnits: 0 },
  );
}
export function groupDownstreamByType(
  groups: Array<{ deliveryType: string; status: string; _count: { _all: number } }>,
) {
  return groups.reduce<Record<string, { total: number; pending: number; awaitingAck: number; delivered: number; failed: number; unconfirmed: number; rejected: number }>>((accumulator, item) => {
    const current = accumulator[item.deliveryType] ?? { total: 0, pending: 0, awaitingAck: 0, delivered: 0, failed: 0, unconfirmed: 0, rejected: 0 };
    current.total += item._count._all;
    if (item.status === 'pending') {
      current.pending += item._count._all;
    } else if (item.status === 'awaiting_ack') {
      current.awaitingAck += item._count._all;
    } else if (item.status === 'delivered') {
      current.delivered += item._count._all;
    } else if (item.status === 'failed') {
      current.failed += item._count._all;
    } else if (item.status === 'unconfirmed') {
      current.unconfirmed += item._count._all;
    } else if (item.status === 'rejected') {
      current.rejected += item._count._all;
    }
    accumulator[item.deliveryType] = current;
    return accumulator;
  }, {});
}
export function groupDownstreamByApplication(
  groups: Array<{ applicationId: string; status: string; _count: { _all: number } }>,
  applicationMap: Map<string, string>,
  applicationAlertMap: Map<string, number>,
) {
  const summaryMap = new Map<string, { applicationId: string; name: string; pending: number; awaitingAck: number; failed: number; unconfirmed: number; rejected: number; delivered: number; alertCount: number }>();
  groups.forEach((item) => {
    const current = summaryMap.get(item.applicationId) ?? {
      applicationId: item.applicationId,
      name: applicationMap.get(item.applicationId) ?? item.applicationId,
      pending: 0,
      awaitingAck: 0,
      failed: 0,
      unconfirmed: 0,
      rejected: 0,
      delivered: 0,
      alertCount: 0,
    };
    if (item.status === 'pending') {
      current.pending += item._count._all;
    } else if (item.status === 'awaiting_ack') {
      current.awaitingAck += item._count._all;
    } else if (item.status === 'failed') {
      current.failed += item._count._all;
    } else if (item.status === 'unconfirmed') {
      current.unconfirmed += item._count._all;
    } else if (item.status === 'rejected') {
      current.rejected += item._count._all;
    } else if (item.status === 'delivered') {
      current.delivered += item._count._all;
    }
    current.alertCount = applicationAlertMap.get(item.applicationId) ?? 0;
    summaryMap.set(item.applicationId, current);
  });
  return [...summaryMap.values()];
}
export function positiveInteger(value: number | undefined, fallback: number) {
  const normalized = Number(value);
  return Number.isInteger(normalized) && normalized > 0 ? normalized : fallback;
}
export function operationLogLevelWhere(level: string): Prisma.OperationLogWhereInput {
  const error: Prisma.OperationLogWhereInput = {
    OR: [
      { action: { contains: 'failed' } },
      { action: { contains: 'reject' } },
      { detail: { path: ['result'], string_contains: 'fail' } },
      { detail: { path: ['status'], string_contains: 'fail' } },
    ],
  };
  const warning: Prisma.OperationLogWhereInput = {
    OR: [
      { action: { contains: 'warning' } },
      { action: { contains: 'risk' } },
    ],
  };
  const success: Prisma.OperationLogWhereInput = {
    OR: [
      { action: { contains: 'approve' } },
      { action: { contains: 'recharge' } },
      { action: { contains: 'connected' } },
    ],
  };
  if (level === 'error') {
    return error;
  }
  if (level === 'warning') {
    return { AND: [{ NOT: error }, warning] };
  }
  if (level === 'success') {
    return { AND: [{ NOT: error }, { NOT: warning }, success] };
  }
  if (level === 'info') {
    return { NOT: { OR: [error, warning, success] } };
  }
  return {};
}
export function normalizeOperationLog(log: Prisma.OperationLogGetPayload<{ include: { tenant: true; user: true } }>) {
  const detail = (log.detail ?? {}) as Record<string, unknown>;
  const result = String(detail.result ?? detail.status ?? '');
  const level = result.includes('fail') || log.action.includes('failed') || log.action.includes('reject')
    ? 'error'
    : log.action.includes('warning') || log.action.includes('risk')
      ? 'warning'
      : log.action.includes('approve') || log.action.includes('recharge') || log.action.includes('connected')
        ? 'success'
        : 'info';
  return {
    id: log.id,
    time: log.createdAt,
    level,
    tenant: log.tenant?.name ?? (log.tenantId ? log.tenantId : '平台'),
    module: log.resource,
    operator: log.user?.displayName ?? log.user?.username ?? log.userId ?? 'system',
    action: log.action,
    resourceId: log.resourceId ?? '',
    detail,
    ip: log.ipAddress ?? '',
    userAgent: log.userAgent ?? '',
  };
}
export function sanitizeGatewaySubmitException(
  item: Prisma.GatewaySubmitDeadLetterGetPayload<{ include: { tenant: true; application: true; channel: true } }>,
  messageState?: { status: string; submitStatus: string | null; receiptStatus: string | null; phoneNumber: string; content: string },
) {
  const { rawPayload, commandPayload, tenant, application, channel, ...record } = item;
  return {
    ...record,
    tenant: tenant ? { id: tenant.id, name: tenant.name, code: tenant.code, status: tenant.status } : null,
    application: application ? { id: application.id, tenantId: application.tenantId, name: application.name, status: application.status } : null,
    channel: channel ? {
      id: channel.id,
      code: channel.code,
      name: channel.name,
      status: channel.status,
      carrier: channel.carrier,
      sendRegion: channel.sendRegion,
      rateLimitPerSecond: channel.rateLimitPerSecond,
    } : null,
    rawPayloadAvailable: Boolean(rawPayload),
    commandPayload: redactGatewayCommandValue(commandPayload),
    messageState: messageState ?? null,
  };
}
export function redactGatewayCommandValue(value: Prisma.JsonValue | null): Prisma.JsonValue | null {
  if (Array.isArray(value)) {
    return value.map((item) => redactGatewayCommandValue(item));
  }
  if (value && typeof value === 'object') {
    const redacted: Record<string, Prisma.JsonValue | null> = {};
    for (const [key, child] of Object.entries(value)) {
      const normalizedKey = key.toLowerCase();
      redacted[key] = [
        'password', 'passwordcipher', 'secret', 'secrethash', 'authsource',
        'token', 'apikey', 'accesskey', 'secretkey',
      ].includes(normalizedKey)
        ? '[REDACTED]'
        : redactGatewayCommandValue(child as Prisma.JsonValue);
    }
    return redacted;
  }
  return value;
}