/**
 * WhatsApp Processor
 *
 * Processes WhatsApp messages from the Communication SQS queue by calling CommunicationService.
 */

import { Injectable } from '@nestjs/common';
import { QueueProcessor } from '../services/processor-registry.service';
import { QueueMessage, QueueProcessingResult, WhatsAppQueueMessage } from '../interfaces/queue-message.interface';
import { QUEUE_CONSTANTS } from '../constants/queue.constants';
import { CommunicationService } from 'src/communication/communication.service';
import { SendTemplateMessageDto } from 'src/communication/dto/whatsapp-communication.dto';
import { classifyQueueError } from '../utils/queue-error.util';
import { maskPhoneNumber } from '../utils/pii-mask.util';
import { AppLoggerService } from 'src/common/services/logger.service';

@Injectable()
export class WhatsAppProcessor implements QueueProcessor {
  constructor(
    private readonly communicationService: CommunicationService,
    private readonly logger: AppLoggerService,
  ) {}

  async process(message: QueueMessage): Promise<QueueProcessingResult> {
    const startTime = Date.now();

    if (
      message.queueType !== QUEUE_CONSTANTS.QUEUE_TYPES.COMMUNICATION ||
      message.subType !== QUEUE_CONSTANTS.COMMUNICATION_TYPES.WHATSAPP
    ) {
      return {
        success: false,
        messageId: message.messageId || 'unknown',
        queueType: message.queueType,
        processingTimeMs: Date.now() - startTime,
        error: {
          code: 'INVALID_MESSAGE_TYPE',
          message: `Expected whatsapp message, got: ${message.queueType}/${message.subType}`,
          retryable: false,
        },
      };
    }

    const waMessage = message as WhatsAppQueueMessage;

    try {
      this.logger.debug(
        `Processing WhatsApp message: ${maskPhoneNumber(waMessage.data.phoneNumber)} (Attempt: ${waMessage.attemptCount})`,
      );

      const dto: SendTemplateMessageDto = {
        whatsappNumber: waMessage.data.phoneNumber,
        templateName: waMessage.data.templateName,
        broadcastName: waMessage.data.broadcastName || waMessage.data.templateName,
        parameters: waMessage.data.parameters,
        trackinfo: waMessage.metadata?.registrationId
          ? {
              registrationId: Number(waMessage.metadata.registrationId),
              templateId: waMessage.metadata.templateId,
              createdBy: waMessage.metadata.createdBy,
              updatedBy: waMessage.metadata.updatedBy,
            }
          : undefined,
      };

      await this.communicationService.sendTemplateMessage(dto);

      const processingTime = Date.now() - startTime;
      this.logger.log(
        `Successfully sent WhatsApp message to: ${maskPhoneNumber(waMessage.data.phoneNumber)} in ${processingTime}ms`,
      );

      return {
        success: true,
        messageId: waMessage.messageId || 'unknown',
        queueType: waMessage.queueType,
        processingTimeMs: processingTime,
      };
    } catch (error) {
      const classified = classifyQueueError(error);

      this.logger.error(
        `Failed to send WhatsApp message to: ${maskPhoneNumber(waMessage.data.phoneNumber)}`,
        '',
        {
          error: classified.message,
          stack: classified.stack,
          phoneNumber: waMessage.data.phoneNumber,
          templateName: waMessage.data.templateName,
          attemptCount: waMessage.attemptCount,
        },
      );
      this.logger.error(`WhatsApp sending queue failed: ${JSON.stringify(error)}`);

      return {
        success: false,
        messageId: waMessage.messageId || 'unknown',
        queueType: waMessage.queueType,
        processingTimeMs: Date.now() - startTime,
        error: {
          code: classified.code,
          message: classified.message,
          stack: classified.stack,
          retryable: classified.retryable,
        },
      };
    }
  }
}