import { Request } from 'express';
import { DyFM_Error, DyFM_DBFilter } from '@futdevpro/fsm-dynamo';
import {
  DyFM_Msg_Message,
  DyFM_msgMessage_dataParams,
  DyFM_Msg_Status,
} from '@futdevpro/fsm-dynamo/messaging';

import { DyNTS_DataService } from '../../../_services/base/data.service';
import { DyNTS_global_settings } from '../../../_collections/global-settings.const';

/**
 * Message Data Service
 * Handles CRUD operations for messages
 */
export class DyNTS_Msg_Message_DataService extends DyNTS_DataService<DyFM_Msg_Message> {
  
  constructor(
    set: {
      message?: DyFM_Msg_Message;
      issuer: string;
    }
  ) {
    super(
      new DyFM_Msg_Message(set?.message),
      DyFM_msgMessage_dataParams,
      set.issuer
    );
  }
  
  /**
   * Get messages for a conversation
   */
  async getConversationMessages(
    conversationId: string,
    limit?: number,
    skip?: number
  ): Promise<DyFM_Msg_Message[]> {
    try {
      const maxLimit = DyNTS_global_settings.messaging_settings?.maxMessagesPerLoad || 50;
      const actualLimit = limit && limit < maxLimit ? limit : maxLimit;
      
      await this.dataDBService
        .find({ conversationId, __deleted: { $exists: false } } as DyFM_DBFilter<DyFM_Msg_Message>)
        .then((res: DyFM_Msg_Message[]) => {
          this.dataList = res
            .sort((a, b) => (b.sentAt?.getTime() || 0) - (a.sentAt?.getTime() || 0))
            .slice(skip || 0, (skip || 0) + actualLimit);
        });
      
      return this.dataList;
    } catch (error) {
      throw new DyFM_Error({
        ...this.getDefaultErrorSettings('getConversationMessages', error),
        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-MSG-GCM`,
        userMessage: 'Failed to retrieve conversation messages.',
      });
    }
  }
  
  /**
   * Mark message as delivered
   */
  async markAsDelivered(messageId: string): Promise<void> {
    try {
      const message = await this.getDataById(messageId);
      
      if (!message) {
        throw new Error('Message not found');
      }
      
      message.status = DyFM_Msg_Status.delivered;
      message.deliveredAt = new Date();
      
      await this.saveData(message);
    } catch (error) {
      throw new DyFM_Error({
        ...this.getDefaultErrorSettings('markAsDelivered', error),
        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-MSG-MAD`,
        userMessage: 'Failed to mark message as delivered.',
      });
    }
  }
  
  /**
   * Mark message as read
   */
  async markAsRead(messageId: string, userId: string): Promise<void> {
    try {
      const message = await this.getDataById(messageId);
      
      if (!message) {
        throw new Error('Message not found');
      }
      
      message.status = DyFM_Msg_Status.read;
      message.readAt = new Date();
      
      await this.saveData(message);
    } catch (error) {
      throw new DyFM_Error({
        ...this.getDefaultErrorSettings('markAsRead', error),
        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-MSG-MAR`,
        userMessage: 'Failed to mark message as read.',
      });
    }
  }
  
  /**
   * Get thread messages
   */
  async getThreadMessages(threadId: string): Promise<DyFM_Msg_Message[]> {
    try {
      await this.dataDBService
        .find({ parentMessageId: threadId, __deleted: { $exists: false } } as DyFM_DBFilter<DyFM_Msg_Message>)
        .then((res: DyFM_Msg_Message[]) => {
          this.dataList = res.sort((a, b) => (a.sentAt?.getTime() || 0) - (b.sentAt?.getTime() || 0));
        });
      
      return this.dataList;
    } catch (error) {
      throw new DyFM_Error({
        ...this.getDefaultErrorSettings('getThreadMessages', error),
        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-MSG-GTM`,
        userMessage: 'Failed to retrieve thread messages.',
      });
    }
  }
}