doneit-web/src/app/module/chat/data/repository/room-repository.service.ts

import { Injectable } from '@angular/core';
import { RoomRemoteDataSourceService } from '../data-source/room/room-remote-data-source.service'
import { RoomInputDTO } from '../dto/room/roomInputDTO';
import { AddMemberToRoomInputDTO } from '../dto/room/addMemberToRoomInputDto';
import { RoomLocalDataSourceService } from '../data-source/room/rooom-local-data-source.service';
import { RoomByIdInputDTO } from '../dto/room/roomByIdInputDTO';
import { roomListDetermineChanges } from '../async/list/rooms/roomListChangeDetector';
import { UserRemoveListInputDTO } from '../dto/room/userRemoveListInputDTO';
import { roomMemberListDetermineChanges } from '../async/list/rooms/roomMembersChangeDetector';
import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
import { RoomUpdateInputDTO } from '../dto/room/roomUpdateInputDTO';
import { SessionStore } from 'src/app/store/session.service';
import { RoomLiveDataSourceService } from '../data-source/room/room-live-data-source.service';
import { isHttpResponse } from 'src/app/services/http.service';
import { MessageLiveDataSourceService } from '../data-source/message/message-live-data-source.service';
import { MemberListUPdateStatusInputDTO } from '../../domain/use-case/socket/member-list-update-status-use-case.service';
import { MemberSetAdminDTO } from '../../domain/use-case/member-admin-use-case.service';
import { MemberListMapper } from '../../domain/mapper/memberLIstMapper';
import { SignalRService } from '../../infra/socket/signal-r.service';


function date(isoDateString) {
  let date = new Date(isoDateString);

  const tzOffset = -date.getTimezoneOffset(); // in minutes
  const diff = tzOffset >= 0 ? '+' : '-';
  const pad = (n: number) => (n < 10 ? '0' : '') + n;

  return date.getFullYear() +
      '-' + pad(date.getMonth() + 1) +
      '-' + pad(date.getDate()) +
      'T' + pad(date.getHours()) +
      ':' + pad(date.getMinutes()) +
      ':' + pad(date.getSeconds()) +
      diff + pad(Math.floor(Math.abs(tzOffset) / 60)) +
      ':' + pad(Math.abs(tzOffset) % 60);
}
@Injectable({
  providedIn: 'root'
})
export class RoomRepositoryService {

  constructor(
    private roomRemoteDataSourceService: RoomRemoteDataSourceService,
    // private roomMemoryDataSourceService: Store<RoomRemoteDataSourceState>,
    private roomLocalDataSourceService: RoomLocalDataSourceService,
    private roomLiveSignalRDataSourceService: RoomLiveDataSourceService,
  ) {}

  @captureAndReraiseAsync('RoomRepositoryService/list')
  async list()  {
    const result = await this.roomRemoteDataSourceService.getRoomList()

    const localList = await this.roomLocalDataSourceService.getRoomList()

    if(result.isOk()) {
     const { roomsToDelete, roomsToInsert, roomsToUpdate } = roomListDetermineChanges(result.value.data, localList)

      for( const roomData of  roomsToInsert) {
        this.roomLocalDataSourceService.createRoom(roomData.chatRoom)
      }

      for( const roomData of  roomsToUpdate) {
        this.roomLocalDataSourceService.updateRoom(roomData.chatRoom)
      }

      for( const roomData of  roomsToDelete) {
        this.roomLocalDataSourceService.deleteRoomById(roomData.id)
      }

      try {
        const rooms = roomsToInsert.concat(roomsToUpdate)

        for(const room of rooms) {
          const expirationDate = new Date(room.chatRoom.expirationDate);
          const now = new Date();
          if (room.chatRoom.expirationDate != null && expirationDate.getTime() >= now.getTime()) {
            const timeRemaining = expirationDate.getTime() - now.getTime();
            setTimeout(() => {
              this.list()
            }, timeRemaining)
          }

        }
      } catch (error) {
        console.log(error)
      }


    }
    return result
  }

  @captureAndReraiseAsync('RoomRepositoryService/updateRoomBy')
  async updateRoomBy(data: RoomUpdateInputDTO) {

    const result = await this.roomRemoteDataSourceService.updateRoom(data)

    if(result.isOk()) {
      const localList = await this.roomLocalDataSourceService.getRoomList()
      // const { roomsToDelete, roomsToInsert, roomsToUpdate } = roomListDetermineChanges([result.value.data], localList)

      // for( const roomData of  roomsToUpdate) {
      //   if(!roomData.chatRoom.createdBy?.wxUserId) {
      //     delete roomData.chatRoom.createdBy;
      //   }

      //   this.roomLocalDataSourceService.updateRoom(roomData.chatRoom)
      // }

    }

    return result
  }

  @captureAndReraiseAsync('RoomRepositoryService/getRoomById')
  async getRoomById(id: RoomByIdInputDTO) {
    const result = await this.roomRemoteDataSourceService.getRoom(id)

    if(result.isOk()) {

      const localListRoom = await this.roomLocalDataSourceService.getRoomList()
      const object = {
        chatRoom: result.value.data
      }
      const { roomsToDelete, roomsToInsert, roomsToUpdate } = roomListDetermineChanges([object], localListRoom)

      for( const roomData of  roomsToUpdate) {
        this.roomLocalDataSourceService.updateRoom(roomData.chatRoom)
      }

      // ============================
      const localList = await this.roomLocalDataSourceService.getRoomMemberById(id)

      const { membersToInsert, membersToUpdate, membersToDelete } = roomMemberListDetermineChanges(result.value.data.members, localList, id)

      for (const user of membersToInsert) {
        await this.roomLocalDataSourceService.addMember(MemberListMapper(user, id))
      }

      for (const user of membersToUpdate) {
        await this.roomLocalDataSourceService.updateMemberRole(MemberListMapper(user, id))
      }

      for(const user of membersToDelete) {
        await this.roomLocalDataSourceService.removeMemberFromRoom(user.$roomIdUserId)
      }

    } else if (isHttpResponse(result.error) ) {
      if(result.error.status == 404) {
        await this.roomLocalDataSourceService.deleteRoomById(id)
      }
      // this.httpErrorHandle.httpStatusHandle(result.error)
    }

    return result
  }

  @captureAndReraiseAsync('RoomRepositoryService/deleteRoomById')
  async deleteRoomById(id: RoomByIdInputDTO) {
    const result = await this.roomRemoteDataSourceService.deleteRoom(id)

    if(result.isOk()) {

      const  result =  await this.roomLocalDataSourceService.deleteRoomById(id)
      // this.messageLiveDataSourceService.sendMessage({
      //   type: 'createRoom',
      //   payload: {a: '5'}
      // })

      return result
    } else if (isHttpResponse(result.error)) {
      if(result.error.status == 404) {
        await this.roomLocalDataSourceService.deleteRoomById(id)
      }
      // this.httpErrorHandle.httpStatusHandle(result.error)
    }

    return result
  }

  @captureAndReraiseAsync('RoomRepositoryService/create')
  async create(data: RoomInputDTO) {

    const result = await this.roomRemoteDataSourceService.createRoom(data)
    if(result.isOk()) {

      if(!result.value.data.createdBy) {

        let dataObject;

        result.value.data.createdBy = {
          wxeMail: SessionStore.user.Email,
          wxFullName: SessionStore.user.FullName,
          wxUserId: SessionStore.user.UserId,
        }

        dataObject = result.value.data
        dataObject.lastMessage = {
          sentAt: date(new Date()),
          message: "",
          sender: {
            wxUserId: "",
            wxFullName: "",
          },
        }
      }

      // this.roomMemoryDataSourceService.dispatch(addRoom(result.value))
      const localResult = await this.roomLocalDataSourceService.createRoom(result.value.data)

      // this.messageLiveDataSourceService.sendMessage({
      //   type: 'createRoom',
      //   payload: {a: '5'}
      // })

      return localResult.map(e => result.value)
    }

    return result
  }


  @captureAndReraiseAsync('RoomRepositoryService/addMemberToRoom')
  async addMemberToRoom(data: AddMemberToRoomInputDTO) {

    return this.roomLiveSignalRDataSourceService.addMemberToRoom(data)

    // const result = await this.roomRemoteDataSourceService.addMemberToRoom(data)

    // return result
  }

  async updateMemberStatus(data: MemberListUPdateStatusInputDTO) {
    const result = await this.roomLocalDataSourceService.updateMembersStatus(data)

    return result
  }


  @captureAndReraiseAsync('RoomRepositoryService/removeMemberToRoom')
  async removeMemberToRoom(data: UserRemoveListInputDTO) {
    const result = await this.roomRemoteDataSourceService.removeMemberFromRoom(data)

    return result
  }

  setAdmin(input: MemberSetAdminDTO) {
    return this.roomRemoteDataSourceService.setAmin(input);
  }



  async leaveRoom(data: UserRemoveListInputDTO) {
    const result = await this.roomRemoteDataSourceService.removeMemberFromRoom(data)

    if(result.isOk()) {
      this.roomLocalDataSourceService.leaveRoom(data.id)
    } else if (isHttpResponse(result.error)) {
      if(result.error.status == 404) {
        await this.roomLocalDataSourceService.deleteRoomById(data.id)

      }
      // this.httpErrorHandle.httpStatusHandle(result.error)
    }

    return result
  }

  getItemsLive() {
    return this.roomLocalDataSourceService.getItemsLive()
  }

  getItemByIdLive(id: any) {
    return this.roomLocalDataSourceService.getRoomByIdLive(id)
  }


  getRoomMemberByIdLive(roomId: any) {
    return this.roomLocalDataSourceService.getRoomMemberByIdLive(roomId)
  }

  getRoomMemberById(roomId: any) {
    return this.roomLocalDataSourceService.getRoomMemberById(roomId)
  }


  getRoomStatus(roomId:string) {
    return this.roomLocalDataSourceService.allMemberOnline(roomId);
  }


  getRoomMemberNoneAdminByIdLive(roomId) {
    return this.roomLocalDataSourceService.getRoomMemberNoneAdminByIdLive(roomId)
  }
}