/**
 * Bulk WhatsApp Processor
 *
 * Processes bulk-whatsapp messages from the Communication SQS queue by sending the whole batch
 * via WATI's bulk template endpoint (CommunicationService.sendBulkTemplateMessage). Per-recipient
 * communication track rows are written by the service using each recipient's registrationId + the
 * batch's templateId (carried in message metadata).
 */

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

@Injectable()
export class BulkWhatsAppProcessor 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.BULK_WHATSAPP
    ) {
      return {
        success: false,
        messageId: message.messageId || 'unknown',
        queueType: message.queueType,
        processingTimeMs: Date.now() - startTime,
        error: {
          code: 'INVALID_MESSAGE_TYPE',
          message: `Expected bulk-whatsapp message, got: ${message.queueType}/${message.subType}`,
          retryable: false,
        },
      };
    }

    const bulkMessage = message as BulkWhatsAppQueueMessage;
    const recipientCount = bulkMessage.data.recipients?.length ?? 0;

    try {
      this.logger.debug(`Processing bulk-whatsapp message: ${recipientCount} recipients`);

      const dto: SendBulkTemplateMessageDto = {
        recipients: bulkMessage.data.recipients.map((recipient) => ({
          whatsappNumber: recipient.whatsappNumber,
          customParams: recipient.customParams,
          registrationId: recipient.registrationId,
        })),
        templateName: bulkMessage.data.templateName,
        broadcastName: bulkMessage.data.broadcastName,
        globalParameters: bulkMessage.data.globalParameters,
        trackinfo: {
          templateId: bulkMessage.metadata?.templateId,
          createdBy: bulkMessage.metadata?.createdBy,
          updatedBy: bulkMessage.metadata?.updatedBy,
        },
      };

      await this.communicationService.sendBulkTemplateMessage(dto);

      const processingTime = Date.now() - startTime;
      this.logger.log(
        `Successfully sent bulk whatsapp to ${recipientCount} recipients in ${processingTime}ms`,
      );

      return {
        success: true,
        messageId: bulkMessage.messageId || 'unknown',
        queueType: bulkMessage.queueType,
        processingTimeMs: processingTime,
      };
    } catch (error) {
      const classified = classifyQueueError(error);
      this.logger.error(`Failed to send bulk whatsapp to ${recipientCount} recipients`, '', {
        error: classified.message,
        stack: classified.stack,
        templateName: bulkMessage.data.templateName,
        attemptCount: bulkMessage.attemptCount,
      });

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