import { Injectable, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
import { PrismaService } from '../prisma/prisma.service';
import type { ApplicationListQuery, CreateSignatureMaterialDto, CreateSmsApplicationDto, CreateSmsDrainageInfoDto, CreateSmsSignatureDto, CreateSmsSignatureOptions, CreateSmsTemplateDto, CreateSmsTemplateOptions, DrainageInfoListQuery, GatewayDownstreamConnectionEventDto, ReplaceApplicationRouteRulesDto, ReviewDto, SignatureListQuery, StatusChangeDto, TemplateListQuery, UpdateSmsApplicationDto, UpdateSmsDrainageInfoDto, UpdateSmsSignatureDto, UpdateSmsTemplateDto } from './sms-config.contracts';
import { SmsApplicationConfigService } from './application-config.service';
import { SmsApplicationLifecycleService } from './application-lifecycle.service';
import { SmsAuditService } from './audit.service';
import { SmsDrainageService } from './drainage.service';
import { SmsReportValidationService } from './report-validation.service';
import { SmsSignatureService } from './signature.service';
import { SmsTemplateService } from './template.service';

/**
 * Stable compatibility facade for SMS configuration.
 * R3 moves business behavior into focused domain services while callers keep this API.
 */
@Injectable()
export class SmsConfigService implements OnModuleInit, OnModuleDestroy {
  private readonly lifecycle: SmsApplicationLifecycleService;
  private readonly applications: SmsApplicationConfigService;
  private readonly reportValidation: SmsReportValidationService;
  private readonly audit: SmsAuditService;
  private readonly signatures: SmsSignatureService;
  private readonly drainage: SmsDrainageService;
  private readonly templates: SmsTemplateService;

  constructor(prisma: PrismaService) {
    this.lifecycle = new SmsApplicationLifecycleService(prisma);
    this.applications = new SmsApplicationConfigService(prisma, this.lifecycle);
    this.reportValidation = new SmsReportValidationService(prisma, this.applications);
    this.audit = new SmsAuditService(prisma, this.lifecycle, this.reportValidation);
    this.signatures = new SmsSignatureService(prisma, this.reportValidation, this.audit);
    this.drainage = new SmsDrainageService(prisma, this.reportValidation, this.audit);
    this.templates = new SmsTemplateService(prisma, this.audit);
  }

  onModuleInit() {
    return this.lifecycle.onModuleInit();
  }

  onModuleDestroy() {
    return this.lifecycle.onModuleDestroy();
  }

  async listApplications(queryOrTenantId?: string | ApplicationListQuery) {
    return this.applications.listApplications(queryOrTenantId);
  }

  async listApplicationsPage(query: ApplicationListQuery) {
    return this.applications.listApplicationsPage(query);
  }

  listApplicationOptions(tenantId?: string) {
    return this.applications.listApplicationOptions(tenantId);
  }

  async getApplication(applicationId: string, tenantId?: string) {
    return this.applications.getApplication(applicationId, tenantId);
  }

  async getApplicationReportFields(applicationId?: string, reportType?: 'signature' | 'drainage') {
    return this.applications.getApplicationReportFields(applicationId, reportType);
  }

  async getClientApplicationReportFields(applicationId?: string, reportType?: 'signature' | 'drainage') {
    return this.applications.getClientApplicationReportFields(applicationId, reportType);
  }

  async createApplication(data: CreateSmsApplicationDto) {
    return this.applications.createApplication(data);
  }

  async updateApplication(applicationId: string, data: UpdateSmsApplicationDto) {
    return this.applications.updateApplication(applicationId, data);
  }

  async replaceApplicationRouteRules(applicationId: string, data: ReplaceApplicationRouteRulesDto) {
    return this.applications.replaceApplicationRouteRules(applicationId, data);
  }

  async resetApplicationSecret(applicationId: string, data: StatusChangeDto = {}) {
    return this.applications.resetApplicationSecret(applicationId, data);
  }

  async changeApplicationStatus(applicationId: string, data: StatusChangeDto) {
    return this.lifecycle.changeApplicationStatus(applicationId, data);
  }

  async getApplicationDeactivationPreview(applicationId: string) {
    return this.lifecycle.getApplicationDeactivationPreview(applicationId);
  }

  async listApplicationConnections(applicationId: string) {
    return this.lifecycle.listApplicationConnections(applicationId);
  }

  async getApplicationCmppParams(applicationId: string, tenantId?: string) {
    return this.applications.getApplicationCmppParams(applicationId, tenantId);
  }

  async recordDownstreamConnectionEvent(data: GatewayDownstreamConnectionEventDto) {
    return this.lifecycle.recordDownstreamConnectionEvent(data);
  }

  async markTimedOutDownstreamConnections(now = new Date()) {
    return this.lifecycle.markTimedOutDownstreamConnections(now);
  }

  async listSignatures(queryOrTenantId?: string | SignatureListQuery) {
    return this.signatures.listSignatures(queryOrTenantId);
  }

  async listSignaturesPage(query: SignatureListQuery) {
    return this.signatures.listSignaturesPage(query);
  }

  listSignatureOptions(tenantId?: string) {
    return this.signatures.listSignatureOptions(tenantId);
  }

  async listClientSignatures(tenantId?: string, signatureId?: string, query: { keyword?: string; applicationId?: string; status?: string; page?: number; pageSize?: number } = {}) {
    return this.signatures.listClientSignatures(tenantId, signatureId, query);
  }

  async getClientSignatureView(signatureId: string, tenantId?: string) {
    return this.signatures.getClientSignatureView(signatureId, tenantId);
  }

  async getClientSignatureWorkspace(tenantId?: string, query: { keyword?: string; applicationId?: string; status?: string; page?: number; pageSize?: number } = {}) {
    return this.signatures.getClientSignatureWorkspace(tenantId, query);
  }

  async listClientDrainageInfos(tenantId?: string, itemId?: string) {
    return this.drainage.listClientDrainageInfos(tenantId, itemId);
  }

  async getClientDrainageInfoView(itemId: string, tenantId?: string) {
    return this.drainage.getClientDrainageInfoView(itemId, tenantId);
  }

  async createSignature(data: CreateSmsSignatureDto, options: CreateSmsSignatureOptions = {}) {
    return this.signatures.createSignature(data, options);
  }

  async updateSignature(signatureId: string, data: UpdateSmsSignatureDto, tenantId?: string) {
    return this.signatures.updateSignature(signatureId, data, tenantId);
  }

  async updateClientSignature(signatureId: string, data: UpdateSmsSignatureDto, tenantId?: string) {
    return this.signatures.updateClientSignature(signatureId, data, tenantId);
  }

  listDrainageInfos(query: DrainageInfoListQuery = {}) {
    return this.drainage.listDrainageInfos(query);
  }

  async createDrainageInfo(signatureId: string, data: CreateSmsDrainageInfoDto, options: CreateSmsSignatureOptions = {}, tenantId?: string) {
    return this.drainage.createDrainageInfo(signatureId, data, options, tenantId);
  }

  async updateDrainageInfo(itemId: string, data: UpdateSmsDrainageInfoDto, options: CreateSmsSignatureOptions = {}, tenantId?: string) {
    return this.drainage.updateDrainageInfo(itemId, data, options, tenantId);
  }

  approveDrainageInfo(itemId: string, data: ReviewDto) {
    return this.drainage.approveDrainageInfo(itemId, data);
  }

  rejectDrainageInfo(itemId: string, data: ReviewDto) {
    return this.drainage.rejectDrainageInfo(itemId, data);
  }

  async changeDrainageInfoStatus(itemId: string, data: StatusChangeDto, tenantId?: string) {
    return this.drainage.changeDrainageInfoStatus(itemId, data, tenantId);
  }

  createSignatureMaterial(data: CreateSignatureMaterialDto) {
    return this.signatures.createSignatureMaterial(data);
  }

  async submitSignature(signatureId: string, tenantId?: string) {
    return this.signatures.submitSignature(signatureId, tenantId);
  }

  listTemplates(queryOrTenantId?: string | TemplateListQuery) {
    return this.templates.listTemplates(queryOrTenantId);
  }

  async listTemplatesPage(query: TemplateListQuery) {
    return this.templates.listTemplatesPage(query);
  }

  listClientTemplates(tenantId: string | undefined, includeHistory = false) {
    return this.templates.listClientTemplates(tenantId, includeHistory);
  }

  async createTemplate(data: CreateSmsTemplateDto, options: CreateSmsTemplateOptions = {}) {
    return this.templates.createTemplate(data, options);
  }

  async updateTemplate(templateId: string, data: UpdateSmsTemplateDto, tenantId?: string) {
    return this.templates.updateTemplate(templateId, data, tenantId);
  }

  async updateClientTemplate(templateId: string, data: UpdateSmsTemplateDto, tenantId?: string) {
    return this.templates.updateClientTemplate(templateId, data, tenantId);
  }

  async submitTemplate(templateId: string, tenantId?: string) {
    return this.templates.submitTemplate(templateId, tenantId);
  }

  listAuditRecords(targetType?: string, targetId?: string) {
    return this.audit.listAuditRecords(targetType, targetId);
  }

  approveSignature(signatureId: string, data: ReviewDto) {
    return this.audit.approveSignature(signatureId, data);
  }

  rejectSignature(signatureId: string, data: ReviewDto) {
    return this.audit.rejectSignature(signatureId, data);
  }

  approveTemplate(templateId: string, data: ReviewDto) {
    return this.audit.approveTemplate(templateId, data);
  }

  rejectTemplate(templateId: string, data: ReviewDto) {
    return this.audit.rejectTemplate(templateId, data);
  }

  async changeSignatureStatus(signatureId: string, data: StatusChangeDto, tenantId?: string) {
    return this.audit.changeSignatureStatus(signatureId, data, tenantId);
  }

  async changeTemplateStatus(templateId: string, data: StatusChangeDto, tenantId?: string) {
    return this.audit.changeTemplateStatus(templateId, data, tenantId);
  }

  /** Preserves the existing private test seam while the implementation lives in the lifecycle domain. */
  private runApplicationDisableScan() {
    return this.lifecycle.runApplicationDisableScan();
  }
}