import { Injectable } from '@nestjs/common';
import { PrismaService } from '../prisma/prisma.service';
import type { DownstreamDeliveryDashboardQuery, DownstreamDeliveryQuery, DownstreamRecoveryStatusQuery, GatewaySubmitDeadLetterQuery, MessageQuery, MessageSegmentAuditQuery, OperationLogQuery, ReceiptAnomalyQuery, SignatureQualityQuery, TraceQuery } from './operations.contracts';
import { OperationsMessageQueries } from './queries/messages.queries';
import { OperationsUplinkQueries } from './queries/uplink.queries';
import { OperationsDashboardQueries } from './queries/dashboard.queries';
import { OperationsQualityQueries } from './queries/quality.queries';
import { OperationsLogQueries } from './queries/logs.queries';
import { OperationsDownstreamQueries } from './queries/downstream.queries';
import { OperationsTraceQueries } from './queries/trace.queries';

export * from './operations.contracts';

@Injectable()
export class OperationsService {
  private readonly messagesQueries: OperationsMessageQueries;
  private readonly uplinkQueries: OperationsUplinkQueries;
  private readonly dashboardQueries: OperationsDashboardQueries;
  private readonly qualityQueries: OperationsQualityQueries;
  private readonly logsQueries: OperationsLogQueries;
  private readonly downstreamQueries: OperationsDownstreamQueries;
  private readonly traceQueries: OperationsTraceQueries;

  constructor(prisma: PrismaService) {
    this.messagesQueries = new OperationsMessageQueries(prisma);
    this.uplinkQueries = new OperationsUplinkQueries(prisma);
    this.dashboardQueries = new OperationsDashboardQueries(prisma);
    this.qualityQueries = new OperationsQualityQueries(prisma);
    this.logsQueries = new OperationsLogQueries(prisma);
    this.downstreamQueries = new OperationsDownstreamQueries(prisma);
    this.traceQueries = new OperationsTraceQueries(prisma);
  }

  // Stable controller facade: routes and public method signatures remain unchanged.
  listBatchTasks(query: { tenantId?: string; status?: string }) {
    return this.messagesQueries.listBatchTasks(query);
  }

  async listClientBatchTasks(query: { tenantId?: string; status?: string }) {
    return this.messagesQueries.listClientBatchTasks(query);
  }

  listMessages(query: MessageQuery) {
    return this.messagesQueries.listMessages(query);
  }

  async listMessagesPage(query: MessageQuery) {
    return this.messagesQueries.listMessagesPage(query);
  }

  async exportMessages(query: MessageQuery) {
    return this.messagesQueries.exportMessages(query);
  }

  async listClientMessages(query: MessageQuery) {
    return this.messagesQueries.listClientMessages(query);
  }

  async listClientMessagesPage(query: MessageQuery) {
    return this.messagesQueries.listClientMessagesPage(query);
  }

  listUplinkMessages(query: { tenantId?: string; channelId?: string; applicationId?: string; phoneNumber?: string; keyword?: string; startTime?: string; endTime?: string; page?: number; pageSize?: number }) {
    return this.uplinkQueries.listUplinkMessages(query);
  }

  async listClientUplinkMessages(query: { tenantId?: string; applicationId?: string; phoneNumber?: string; keyword?: string; startTime?: string; endTime?: string; page?: number; pageSize?: number }) {
    return this.uplinkQueries.listClientUplinkMessages(query);
  }

  async listUplinkMessagesPage(query: { tenantId?: string; channelId?: string; applicationId?: string; phoneNumber?: string; keyword?: string; startTime?: string; endTime?: string; page?: number; pageSize?: number }, clientView = false) {
    return this.uplinkQueries.listUplinkMessagesPage(query, clientView);
  }

  async monitor(query: { tenantId?: string; channelId?: string }) {
    return this.uplinkQueries.monitor(query);
  }

  async dashboard(query: { tenantId?: string }) {
    return this.dashboardQueries.dashboard(query);
  }

  pendingAudits(tenantId?: string) {
    return this.dashboardQueries.pendingAudits(tenantId);
  }

  async clientDashboard(query: { tenantId?: string }) {
    return this.dashboardQueries.clientDashboard(query);
  }

  async statistics(query: { tenantId?: string; groupBy?: string }) {
    return this.qualityQueries.statistics(query);
  }

  async sendQuality(date?: string) {
    return this.qualityQueries.sendQuality(date);
  }

  async signatureQuality(query: SignatureQualityQuery) {
    return this.qualityQueries.signatureQuality(query);
  }

  async auditLogs(query: { tenantId?: string; userId?: string; page?: number; pageSize?: number }) {
    return this.logsQueries.auditLogs(query);
  }

  async systemLogs(query: OperationLogQuery) {
    return this.logsQueries.systemLogs(query);
  }

  async exportSystemLogs(query: OperationLogQuery, clientUserId?: string) {
    return this.logsQueries.exportSystemLogs(query, clientUserId);
  }

  async listGatewaySubmitDeadLetters(query: GatewaySubmitDeadLetterQuery) {
    return this.downstreamQueries.listGatewaySubmitDeadLetters(query);
  }

  async listReceiptAnomalies(query: ReceiptAnomalyQuery) {
    return this.downstreamQueries.listReceiptAnomalies(query);
  }

  async listDownstreamDeliveries(query: DownstreamDeliveryQuery) {
    return this.downstreamQueries.listDownstreamDeliveries(query);
  }

  async downstreamDeliveryDashboard(query: DownstreamDeliveryDashboardQuery) {
    return this.downstreamQueries.downstreamDeliveryDashboard(query);
  }

  async listDownstreamRecoveryStatuses(query: DownstreamRecoveryStatusQuery) {
    return this.downstreamQueries.listDownstreamRecoveryStatuses(query);
  }

  async listMessageSegmentAudits(query: MessageSegmentAuditQuery) {
    return this.downstreamQueries.listMessageSegmentAudits(query);
  }

  async getDownstreamRecoveryStatus(id: string) {
    return this.downstreamQueries.getDownstreamRecoveryStatus(id);
  }

  async exportDownstreamRecoveryStatuses(query: DownstreamRecoveryStatusQuery) {
    return this.downstreamQueries.exportDownstreamRecoveryStatuses(query);
  }

  auditSummary(query: { tenantId?: string }) {
    return this.traceQueries.auditSummary(query);
  }

  async trace(query: TraceQuery) {
    return this.traceQueries.trace(query);
  }

  async reconciliation(query: { tenantId?: string; taskId?: string }) {
    return this.traceQueries.reconciliation(query);
  }
}