doneit-web/src/app/module/chat/domain/use-case/room/room-set-last-message.service.ts

import { Injectable } from '@angular/core';
import { IMessageSocketRepository } from 'src/app/core/chat/repository/message/message-socket-repository';
import { IRoomLocalRepository } from 'src/app/core/chat/repository/room/room-local-repository';
import { filter, map } from 'rxjs/operators';
import { InstanceId } from '../../chat-service.service';
import { MessageEntity } from 'src/app/core/chat/entity/message';
import { SessionStore } from 'src/app/store/session.service';
import { HttpAdapter } from 'src/app/infra/http/adapter';
import { IMessageGetAllByRoomIdOutPut } from 'src/app/core/chat/usecase/message/message-get-all-by-room-Id';
import { RoomEntity } from 'src/app/core/chat/entity/group';

@Injectable({
  providedIn: 'root'
})
export class RoomSetLastMessageService {

  constructor(
    private roomLocalRepository: IRoomLocalRepository,
    private messageSocketRepository: IMessageSocketRepository,
    private http: HttpAdapter,
  ) {
    this.listenToIncomingMessage()
    this.listenToOnSendDataToSocket()
    this.loadHistory()
  }

  private listenToIncomingMessage() {
    return this.messageSocketRepository.listenToMessages().pipe(
      filter((message) => !message?.requestId?.startsWith(InstanceId)), // get all message not send by me
      map(message => Object.assign(new MessageEntity(), message))
    ).subscribe(async (message) => {
      const result = await this.roomLocalRepository.update(message.roomId, {
        messages: [message]
      })

      if(result.isErr()) {
        console.log('failed to update last message')
      } else {
        console.log('set last message')
      }

    });

  }

  private listenToOnSendDataToSocket() {
    this.messageSocketRepository.listenToSendMessage().subscribe(async (e) => {

      e.data['sender']  = {
        userPhoto: '',
        wxeMail: SessionStore.user.Email,
        wxFullName: SessionStore.user.FullName,
        wxUserId: SessionStore.user.UserId
      }
      e.data['sentAt'] = new Date().toISOString()
      const result = await this.roomLocalRepository.update(e.data.roomId, {
        messages: [e.data]
      })

      if(result.isErr()) {
        console.log(result.error)
      }

    })
  }

  private loadHistory() {
    const regex = new RegExp("Room\\/([0-9a-fA-F]{8})-([0-9a-fA-F]{4})-([0-9a-fA-F]{4})-([0-9a-fA-F]{4})-([0-9a-fA-F]{12})\\/Messages");

    return this.http.listen().pipe(
      filter((response: any)=> {
        return response?.isOk() && regex.test(response.value.url) && response.value.url.endsWith('/Messages')
      }),
      map((response: any) => response.value.data as IMessageGetAllByRoomIdOutPut)
    ).subscribe(async (data)=> {
      const loadHistoryFirstMessage = data.data[0]
      if(loadHistoryFirstMessage) {

        const roomId = loadHistoryFirstMessage.roomId

        const room = await this.roomLocalRepository.findOne({id: roomId})

        if(room.isOk()) {
          const roomEntity = new RoomEntity(room.value)
          if(!roomEntity.hasLastMessage()) {
            await this.roomLocalRepository.update(loadHistoryFirstMessage.roomId, {
              messages: [loadHistoryFirstMessage]
            })
          } else if (roomEntity.hasLastMessage()) {
            const localLastMessageDate = new Date(room.value.messages[0].sentAt).getTime()
            const loadHistoryLastMessageDate = new Date(loadHistoryFirstMessage.sentAt).getTime()

            if(loadHistoryLastMessageDate>localLastMessageDate) {
              console.log('update by load history')
              await this.roomLocalRepository.update(loadHistoryFirstMessage.roomId, {
                messages: [loadHistoryFirstMessage]
              })
            } else if(loadHistoryLastMessageDate == localLastMessageDate) {
              // console.log('same', loadHistoryFirstMessage, roomEntity)
            } else {
              // console.log('bug!', loadHistoryFirstMessage, roomEntity)
            }

          }

        }

      }
    })
  }

}