import { delGroupSuccess, buddy2 } from './../store/messenger/sync/actions';
import { Injectable, Inject } from '@angular/core';

import { tap, withLatestFrom, take } from 'rxjs/operators';

import { Store, select } from '@ngrx/store';

import {
  SSVC_TYPE_LOGOUT_RES,
  SSVC_TYPE_LOGOUT_REMOTE_NOTI,
  AuthenticationProtocolService,
  LogoutResponse,
  LogoutRemoteNotification,
  LogoutNotification,
  LoginResponse
} from '@ucap-webmessenger/protocol-authentication';

import { NGXLogger } from 'ngx-logger';
import {
  EventProtocolService,
  SSVC_TYPE_EVENT_SEND_NOTI,
  SendNotification,
  SSVC_TYPE_EVENT_READ_NOTI,
  SSVC_TYPE_EVENT_CANCEL_NOTI,
  SSVC_TYPE_EVENT_DEL_RES,
  SSVC_TYPE_EVENT_SEND_RES,
  SSVC_TYPE_EVENT_READ_RES,
  EventType
} from '@ucap-webmessenger/protocol-event';
import {
  InfoProtocolService,
  SSVC_TYPE_INFO_USER_NOTI,
  SSVC_TYPE_INFO_USER_RES,
  UserNotification
} from '@ucap-webmessenger/protocol-info';
import {
  RoomProtocolService,
  SSVC_TYPE_ROOM_INVITE_NOTI,
  SSVC_TYPE_ROOM_EXIT_NOTI,
  SSVC_TYPE_ROOM_EXIT_FORCING_NOTI,
  SSVC_TYPE_ROOM_FONT_UPD_NOTI,
  InviteNotification,
  UpdateNotification as RoomUpdateNotification,
  SSVC_TYPE_ROOM_UPD_RES,
  SSVC_TYPE_ROOM_EXIT_FORCING_RES,
  SSVC_TYPE_ROOM_EXIT_RES,
  SSVC_TYPE_ROOM_INVITE_RES,
  ExitForcingResponse,
  RoomInfo,
  UserInfo,
  UserInfoShort
} from '@ucap-webmessenger/protocol-room';
import {
  StatusProtocolService,
  SSVC_TYPE_STATUS_NOTI,
  StatusNotification
} from '@ucap-webmessenger/protocol-status';
import {
  ReadNotification,
  CancelNotification,
  DelNotification
} from '@ucap-webmessenger/protocol-event';
import {
  ExitNotification,
  ExitForcingNotification,
  UpdateFontNotification
} from '@ucap-webmessenger/protocol-room';
import {
  GroupProtocolService,
  SSVC_TYPE_GROUP_UPD_RES2,
  UpdateNotification as GroupUpdateNotification,
  SSVC_TYPE_GROUP_ADD_RES,
  AddNotification as GroupAddNotification,
  SSVC_TYPE_GROUP_DEL_RES,
  DelNotification as GroupDelNotification
} from '@ucap-webmessenger/protocol-group';
import {
  BuddyProtocolService,
  SSVC_TYPE_BUDDY_UPD_RES,
  UpdateNotification as BuddyUpdateNotification,
  SSVC_TYPE_BUDDY_ADD_RES,
  AddNotification as BuddyAddNotification,
  SSVC_TYPE_BUDDY_DEL_RES,
  DelNotification as BuddyDelNotification
} from '@ucap-webmessenger/protocol-buddy';
import {
  SyncProtocolService,
  PhoneBookSyncType,
  SSVC_TYPE_SYNC_PHONEBOOK_READY_NOTI,
  SSVC_TYPE_SYNC_PHONEBOOK_SND_NOTI,
  PhoneBookSndNotification,
  RoomUserData
} from '@ucap-webmessenger/protocol-sync';

import * as AppStore from '@app/store';
import * as AuthenticationStore from '@app/store/account/authentication';
import * as InfoStore from '@app/store/account/info';
import * as EventStore from '@app/store/messenger/event';
import * as SyncStore from '@app/store/messenger/sync';
import * as RoomStore from '@app/store/messenger/room';
import * as StatusStore from '@app/store/messenger/status';
import {
  NotificationRequest,
  NativeService,
  UCAP_NATIVE_SERVICE,
  NotificationType,
  WindowState
} from '@ucap-webmessenger/native';
import { StringUtil, DialogService } from '@ucap-webmessenger/ui';

import {
  LocalStorageService,
  SessionStorageService
} from '@ucap-webmessenger/web-storage';
import { AppUserInfo, KEY_APP_USER_INFO } from '@app/types/app-user-info.type';

import { environment } from '../../environments/environment';
import { NotificationMethod } from '@ucap-webmessenger/core';
import { Dictionary } from '@ngrx/entity';
import { MessageType } from '@ucap-webmessenger/api-message';
import { LogoutInfo, KEY_LOGOUT_INFO } from '@app/types';
import { TranslateService } from '@ngx-translate/core';
import { deleteMessageSuccess } from '@app/store/messenger/message';
import { ServerErrorCode } from '@ucap-webmessenger/protocol';
import {
  OptionProtocolService,
  SSVC_TYPE_OPTION_REG_UPD_RES,
  RegUpdateResponse,
  RegUpdateNotification
} from '@ucap-webmessenger/protocol-option';
import {
  GeneralSetting,
  Settings,
  NotificationSetting,
  ChatSetting
} from '@ucap-webmessenger/ui-settings';
import clone from 'clone';

@Injectable()
export class AppNotificationService {
  constructor(
    private authenticationProtocolService: AuthenticationProtocolService,
    private eventProtocolService: EventProtocolService,
    private infoProtocolService: InfoProtocolService,
    private roomProtocolService: RoomProtocolService,
    private groupProtocolService: GroupProtocolService,
    private buddyProtocolService: BuddyProtocolService,
    private statusProtocolService: StatusProtocolService,
    private translateService: TranslateService,
    private syncProtocolService: SyncProtocolService,
    private optionProtocolService: OptionProtocolService,
    // 쪽지 비활성화 2020-0226
    // private umgProtocolService: UmgProtocolService,
    private localStorageService: LocalStorageService,
    private sessionStorageService: SessionStorageService,
    @Inject(UCAP_NATIVE_SERVICE) private nativeService: NativeService,
    private dialogService: DialogService,
    private store: Store<any>,
    private logger: NGXLogger
  ) {}

  public subscribe(): void {
    this.authenticationProtocolService.logoutNotification$
      .pipe(
        tap(notiOrRes => {
          switch (notiOrRes.SSVC_TYPE) {
            case SSVC_TYPE_LOGOUT_RES:
              {
                const res = notiOrRes as LogoutNotification;
                this.logger.debug(
                  'Notification::authenticationProtocolService::LogoutResponse',
                  res
                );

                this.sessionStorageService.set<LogoutInfo>(KEY_LOGOUT_INFO, {
                  personLogout: true,
                  reasonCode: res.reasonCode,
                  ip: res.ip,
                  mac: res.mac
                } as LogoutInfo);
              }
              break;
            case SSVC_TYPE_LOGOUT_REMOTE_NOTI:
              {
                const noti = notiOrRes as LogoutRemoteNotification;
                this.logger.debug(
                  'Notification::authenticationProtocolService::LogoutRemoteNotification',
                  noti
                );

                this.sessionStorageService.set<LogoutInfo>(KEY_LOGOUT_INFO, {
                  personLogout: true,
                  reasonCode: ServerErrorCode.ERRCD_FORCE_INIT,
                  forceType: noti.requestDeviceType
                } as LogoutInfo);
              }
              break;
            default:
              break;
          }
          this.dialogService.closeAll();

          this.store.dispatch(AuthenticationStore.loginRedirect());
        })
      )
      .subscribe();

    this.eventProtocolService.notification$
      .pipe(
        withLatestFrom(
          this.store.pipe(
            select((state: any) => state.messenger.room.roomInfo as RoomInfo)
          ),
          this.store.pipe(
            select(
              (state: any) =>
                state.messenger.sync.room.entities as Dictionary<RoomInfo>
            )
          ),
          this.store.pipe(
            select(
              (state: any) =>
                state.messenger.sync.roomUserShort.entities as Dictionary<
                  RoomUserData
                >
            )
          )
        ),
        tap(([notiOrRes, curRoomInfo, roomList, roomUserShorts]) => {
          switch (notiOrRes.SSVC_TYPE) {
            case SSVC_TYPE_EVENT_SEND_RES:
            case SSVC_TYPE_EVENT_SEND_NOTI:
              {
                const noti = notiOrRes as SendNotification;
                this.logger.debug(
                  'Notification::eventProtocolService::SendNotification',
                  noti
                );

                this.store.dispatch(
                  EventStore.sendNotification({
                    noti
                  })
                );

                // notification..
                if (notiOrRes.SSVC_TYPE === SSVC_TYPE_EVENT_SEND_NOTI) {
                  let doNoti = true;

                  // 방별 알림이 꺼져 있으면 노티 안함.
                  if (
                    !!roomList[noti.roomSeq] &&
                    !roomList[noti.roomSeq].receiveAlarm
                  ) {
                    doNoti = false;
                  }

                  const windowState = this.nativeService.getWindowState();

                  // 현재 열려 있는 방일경우 노티 안함.
                  if (
                    !!curRoomInfo &&
                    !!curRoomInfo.roomSeq &&
                    curRoomInfo.roomSeq === noti.roomSeq &&
                    !!windowState &&
                    windowState !== WindowState.Minimized &&
                    windowState !== WindowState.Hidden
                  ) {
                    doNoti = false;
                  }

                  if (doNoti) {
                    // const dd = roomUserShorts..filter(u => u.seq === noti.SENDER_SEQ );
                    const roomUsers = roomUserShorts[noti.roomSeq];
                    let senderUser: UserInfoShort;

                    const senderUserTemp = roomUsers.userInfos.filter(
                      userInfo => {
                        if (!!userInfo && !!userInfo.seq) {
                          return userInfo.seq === noti.SENDER_SEQ;
                        }
                      }
                    );

                    senderUser = senderUserTemp[0];
                    const appUserInfo = this.localStorageService.encGet<
                      AppUserInfo
                    >(KEY_APP_USER_INFO, environment.customConfig.appKey);

                    if (appUserInfo.settings.notification.use) {
                      if (
                        appUserInfo.settings.notification.method ===
                        NotificationMethod.Sound
                      ) {
                        const audio = new Audio(
                          'assets/sounds/messageAlarm.mp3'
                        );
                        audio.play();
                      } else {
                        // const userTemp = userInfoList.filter(user => { user.seq === noti.SENDER_SEQ });
                        let contents = StringUtil.convertFinalEventMessage(
                          noti.eventType,
                          noti.info.sentMessageJson
                        );

                        if (!appUserInfo.settings.notification.preView) {
                          contents = '';
                        }

                        if (!!contents || contents === '') {
                          const notiReq: NotificationRequest = {
                            type: NotificationType.Event,
                            seq: noti.roomSeq,
                            title:
                              senderUser.name +
                              '<br/>' +
                              this.translateService.instant(
                                'notification.titleChatEventArrived'
                              ),
                            contents,
                            image: senderUser.profileImageFile,
                            useSound: [
                              NotificationMethod.Sound,
                              NotificationMethod.SoundAndAlert
                            ].some(
                              n =>
                                n === appUserInfo.settings.notification.method
                            )
                              ? true
                              : false,
                            displayTime:
                              appUserInfo.settings.notification
                                .alertExposureTime * 1000
                          };
                          this.nativeService.notify(notiReq);
                        }
                      }
                    }
                  }
                }
              }
              break;
            case SSVC_TYPE_EVENT_READ_RES:
            case SSVC_TYPE_EVENT_READ_NOTI:
              {
                // 대화방 unread count 처리.
                const noti = notiOrRes as ReadNotification;
                this.logger.debug(
                  'Notification::eventProtocolService::ReadNotification',
                  noti
                );
                this.store.dispatch(EventStore.readNotification(noti));
              }
              break;
            case SSVC_TYPE_EVENT_CANCEL_NOTI:
              {
                const noti = notiOrRes as CancelNotification;
                this.logger.debug(
                  'Notification::eventProtocolService::CancelNotification',
                  noti
                );
                this.store.dispatch(
                  EventStore.cancelNotification({
                    noti
                  })
                );
              }
              break;
            case SSVC_TYPE_EVENT_DEL_RES:
              {
                const noti = notiOrRes as DelNotification;
                this.logger.debug(
                  'Notification::eventProtocolService::DelNotification',
                  noti
                );
                this.store.dispatch(
                  EventStore.delNotification({
                    noti
                  })
                );
              }
              break;
            default:
              break;
          }
        })
      )
      .subscribe();
    this.infoProtocolService.notification$
      .pipe(
        tap(notiOrRes => {
          switch (notiOrRes.SSVC_TYPE) {
            case SSVC_TYPE_INFO_USER_NOTI:
            case SSVC_TYPE_INFO_USER_RES:
              {
                const noti = notiOrRes as UserNotification;
                this.logger.debug(
                  'Notification::infoProtocolService::UserNotification',
                  noti
                );
                this.store.dispatch(
                  InfoStore.userNotification({
                    noti
                  })
                );
              }
              break;
            default:
              break;
          }
        })
      )
      .subscribe();
    this.groupProtocolService.notification$
      .pipe(
        withLatestFrom(
          this.store.pipe(
            select(
              (state: any) => state.messenger.sync.group2.syncDate as string
            )
          )
        ),
        tap(([notiOrRes, syncDate]) => {
          switch (notiOrRes.SSVC_TYPE) {
            case SSVC_TYPE_GROUP_UPD_RES2:
              {
                const noti = notiOrRes as GroupUpdateNotification;
                this.logger.debug(
                  'Notification::groupProtocolService::GroupUpdateNotification',
                  noti
                );
                this.store.dispatch(
                  SyncStore.group2({
                    syncDate
                  })
                );
              }
              break;
            case SSVC_TYPE_GROUP_ADD_RES:
              {
                const noti = notiOrRes as GroupAddNotification;
                this.logger.debug(
                  'Notification::groupProtocolService::GroupAddNotification',
                  noti
                );
                this.store.dispatch(SyncStore.createGroupSuccess(noti));
              }
              break;
            case SSVC_TYPE_GROUP_DEL_RES:
              {
                const noti = notiOrRes as GroupDelNotification;
                this.logger.debug(
                  'Notification::groupProtocolService::GroupDelNotification',
                  noti
                );
                this.store.dispatch(SyncStore.delGroupSuccess(noti));
              }
              break;

            default:
              break;
          }
        })
      )
      .subscribe();
    this.buddyProtocolService.notification$
      .pipe(
        withLatestFrom(
          this.store.pipe(
            select(
              (state: any) => state.messenger.sync.buddy2.syncDate as string
            )
          )
        ),
        tap(([notiOrRes, syncDate]) => {
          switch (notiOrRes.SSVC_TYPE) {
            case SSVC_TYPE_BUDDY_UPD_RES:
              {
                const noti = notiOrRes as BuddyUpdateNotification;
                this.logger.debug(
                  'Notification::groupProtocolService::BuddyUpdateNotification',
                  noti
                );
                this.store.dispatch(SyncStore.updateBuddySuccess(noti));
              }
              break;
            case SSVC_TYPE_BUDDY_ADD_RES:
              {
                const noti = notiOrRes as BuddyAddNotification;
                this.logger.debug(
                  'Notification::groupProtocolService::BuddyAddNotification',
                  noti
                );
                this.store.dispatch(SyncStore.buddy2({ syncDate }));
              }
              break;
            case SSVC_TYPE_BUDDY_DEL_RES:
              {
                const noti = notiOrRes as BuddyDelNotification;
                this.logger.debug(
                  'Notification::groupProtocolService::BuddyDelNotification',
                  noti
                );
                this.store.dispatch(SyncStore.delBuddySuccess(noti));
              }
              break;

            default:
              break;
          }
        })
      )
      .subscribe();
    this.roomProtocolService.notification$
      .pipe(
        withLatestFrom(
          this.store.pipe(
            select(
              (state: any) =>
                state.account.authentication.loginRes as LoginResponse
            )
          )
        ),
        tap(([notiOrRes, loginResInfo]) => {
          switch (notiOrRes.SSVC_TYPE) {
            case SSVC_TYPE_ROOM_INVITE_RES:
            case SSVC_TYPE_ROOM_INVITE_NOTI:
              {
                const noti = notiOrRes as InviteNotification;
                this.logger.debug(
                  'Notification::roomProtocolService::InviteNotification',
                  noti
                );
                this.store.dispatch(
                  RoomStore.inviteNotification({
                    noti
                  })
                );
              }
              break;
            case SSVC_TYPE_ROOM_UPD_RES:
              {
                const noti = notiOrRes as RoomUpdateNotification;
                this.logger.debug(
                  'Notification::roomProtocolService::RoomUpdateNotification',
                  noti
                );
                this.store.dispatch(
                  RoomStore.updateSuccess({
                    res: {
                      roomSeq: noti.roomSeq,
                      roomName:
                        noti.roomName.trim().length === 0
                          ? ' '
                          : noti.roomName.trim(),
                      receiveAlarm: noti.receiveAlarm,
                      syncAll: false
                    }
                  })
                );
              }
              break;
            case SSVC_TYPE_ROOM_EXIT_RES:
            case SSVC_TYPE_ROOM_EXIT_NOTI:
              {
                const noti = notiOrRes as ExitNotification;
                this.logger.debug(
                  'Notification::roomProtocolService::ExitNotification',
                  noti
                );

                if (noti.SENDER_SEQ === loginResInfo.userSeq) {
                  this.store.dispatch(
                    RoomStore.exitNotification({
                      noti
                    })
                  );
                } else {
                  this.store.dispatch(
                    RoomStore.exitNotificationOthers({
                      roomSeq: noti.roomSeq,
                      trgtUser: [noti.SENDER_SEQ]
                    })
                  );

                  if (!!noti && !!noti.SENDER_SEQ) {
                    this.store.dispatch(
                      SyncStore.clearRoomUsers({
                        roomSeq: noti.roomSeq,
                        userSeqs: [noti.SENDER_SEQ]
                      })
                    );
                  }
                }
              }
              break;
            case SSVC_TYPE_ROOM_EXIT_FORCING_RES:
              {
                // 내가 강퇴 진행.
                const res = notiOrRes as ExitForcingResponse;
                this.logger.debug(
                  'Notification::roomProtocolService::ExitForcingNotification RES',
                  res
                );
                this.store.dispatch(
                  RoomStore.exitForcingSuccess({
                    res
                  })
                );
              }
              break;
            case SSVC_TYPE_ROOM_EXIT_FORCING_NOTI:
              {
                const noti = notiOrRes as ExitForcingNotification;
                this.logger.debug(
                  'Notification::roomProtocolService::ExitForcingNotification NOTI',
                  noti
                );

                if (noti.userSeqs.indexOf(loginResInfo.userSeq) >= 0) {
                  // 강퇴 대상이 본인이면 열려 있는 대화방을 닫고, 대화리스트에서 삭제.
                  this.store.dispatch(
                    RoomStore.exitForcingNotification({
                      noti
                    })
                  );
                } else {
                  // ROOM::열려 있는 대화방에서 강퇴 인원의 isJoinRoom = false 로 변경.
                  this.store.dispatch(
                    RoomStore.exitNotificationOthers({
                      roomSeq: noti.roomSeq,
                      trgtUser: noti.userSeqs
                    })
                  );

                  // SYNC::대화리스트의 대화자정보에서 강퇴 인원의 isJoinRoom = false 로 변경.
                  this.store.dispatch(
                    SyncStore.clearRoomUsers({
                      roomSeq: noti.roomSeq,
                      userSeqs: noti.userSeqs
                    })
                  );
                }
              }
              break;
            case SSVC_TYPE_ROOM_FONT_UPD_NOTI:
              {
                const noti = notiOrRes as UpdateFontNotification;
                this.logger.debug(
                  'Notification::roomProtocolService::UpdateFontNotification',
                  noti
                );
                this.store.dispatch(
                  RoomStore.updateFontNotification({
                    noti
                  })
                );
              }
              break;
            default:
              break;
          }
        })
      )
      .subscribe();
    this.statusProtocolService.notification$
      .pipe(
        tap(notiOrRes => {
          switch (notiOrRes.SSVC_TYPE) {
            case SSVC_TYPE_STATUS_NOTI:
              {
                const noti = notiOrRes as StatusNotification;
                this.logger.debug(
                  'Notification::statusProtocolService::StatusNotification',
                  noti
                );
                this.store.dispatch(
                  StatusStore.statusNotification({
                    noti
                  })
                );
              }
              break;
            default:
              break;
          }
        })
      )
      .subscribe();
    this.optionProtocolService.notification$
      .pipe(
        tap(notiOrRes => {
          switch (notiOrRes.SSVC_TYPE) {
            case SSVC_TYPE_OPTION_REG_UPD_RES:
              {
                const noti = notiOrRes as RegUpdateNotification;
                this.logger.debug(
                  'Notification::optionProtocolService::RegUpdateNotification',
                  noti
                );

                const appUserInfo: AppUserInfo = this.localStorageService.encGet<
                  AppUserInfo
                >(KEY_APP_USER_INFO, environment.customConfig.appKey);

                const modifiedSettings: Settings = clone(appUserInfo.settings);
                // 모바일에서 해당 값만 수정함.
                modifiedSettings.notification.receiveForMobile =
                  noti.mobileNotification;
                appUserInfo.settings = modifiedSettings;

                this.localStorageService.encSet<AppUserInfo>(
                  KEY_APP_USER_INFO,
                  appUserInfo,
                  environment.customConfig.appKey
                );
              }
              break;
            default:
              break;
          }
        })
      )
      .subscribe();
    this.syncProtocolService.notification$
      .pipe(
        tap(notiOrRes => {
          switch (notiOrRes.SSVC_TYPE) {
            case SSVC_TYPE_SYNC_PHONEBOOK_READY_NOTI:
              {
                this.logger.debug(
                  'Notification::syncProtocolService::SSVC_TYPE_SYNC_PHONEBOOK_READY_NOTI',
                  notiOrRes
                );

                // destination ?: PhoneBookSyncType;
                // // (W: 전체(Whole)) (W: 부분(Part))
                // syncType ?:
                // PhoneBook ready ok dispatch
                this.store.dispatch(
                  SyncStore.phoneBookReadyOk({
                    req: {
                      syncReadyOk: PhoneBookSyncType.OK_Y,
                      syncType: PhoneBookSyncType.SYNC_TYPE_WHOLE
                    }
                  })
                );
              }
              break;
            case SSVC_TYPE_SYNC_PHONEBOOK_SND_NOTI:
              {
                this.logger.debug(
                  'Notification::syncProtocolService::SSVC_TYPE_SYNC_PHONEBOOK_SND_NOTI',
                  notiOrRes
                );
                // PhoneBook sed noti dispatch (data parse)
                const noti = notiOrRes as PhoneBookSndNotification;
                this.store.dispatch(
                  SyncStore.phoneBookSndNotification({
                    noti
                  })
                );
              }
              break;
            default:
              break;
          }
        })
      )
      .subscribe();
  }
}

/*
쪽지 비활성화 2020-0226
this.umgProtocolService.notification$
  .pipe(
    tap(notiOrRes => {
      switch (notiOrRes.SSVC_TYPE) {
        case SSVC_TYPE_UMG_NOTI:
          {
            const noti = notiOrRes as UmgNotiNotification;
            this.logger.debug(
              'Notification::umgProtocolService::UmgNotiNotification',
              noti
            );

            // unreadCount refresh..
            this.store.dispatch(MessageStore.retrieveUnreadCount({}));

            // Receive Message List refresh..
            this.store.dispatch(
              MessageStore.retrieveMessage({
                messageType: MessageType.Receive
              })
            );

            // notification..
            const appUserInfo = this.localStorageService.encGet<AppUserInfo>(
              KEY_APP_USER_INFO,
              environment.customConfig.appKey
            );

            if (appUserInfo.settings.notification.use) {
              if (
                appUserInfo.settings.notification.method ===
                NotificationMethod.Sound
              ) {
                const audio = new Audio('assets/sounds/messageAlarm.mp3');
                audio.play();
              } else {
                const notiReq: NotificationRequest = {
                  type: NotificationType.Message,
                  seq: noti.keyId,
                  title: this.translateService.instant(
                    'notification.titleMessageArrived'
                  ),
                  contents: noti.text,
                  image: noti.senderInfo.profileImageFile,
                  useSound: [
                    NotificationMethod.Sound,
                    NotificationMethod.SoundAndAlert
                  ].some(n => n === appUserInfo.settings.notification.method)
                    ? true
                    : false,
                  displayTime:
                    appUserInfo.settings.notification.alertExposureTime * 1000
                };
                this.nativeService.notify(notiReq);
              }
            }

            // direct open detail
            if (appUserInfo.settings.notification.receiveForMessage) {
              this.store.dispatch(
                MessageStore.detailMessage({
                  messageType: MessageType.Receive,
                  msgId: Number(noti.keyId)
                })
              );
            }
          }
          break;
        case SSVC_TYPE_UMG_DELETE_NOTI:
          {
            const noti = notiOrRes as UmgDeleteNotiNotification;
            this.logger.debug(
              'Notification::umgProtocolService::UmgDeleteNotiNotification',
              noti
            );

            // Remove one Receive Message
            if (!!noti && !!noti.keyId) {
              // clear badge in left navi
              this.store.dispatch(MessageStore.retrieveUnreadCount({}));

              // delete message in receive message list
              this.store.dispatch(
                deleteMessageSuccess({
                  messageType: MessageType.Receive,
                  msgList: [
                    {
                      msgId: Number(noti.keyId)
                    }
                  ]
                })
              );
            }
          }
          break;

        default:
          break;
      }
    })
  )
  .subscribe();
*/