import moment from 'moment';

import { Selector, createSelector } from '@ngrx/store';
import { EntityState, createEntityAdapter, Dictionary } from '@ngrx/entity';

import { RoomUserDetailData, RoomUserData } from '@ucap/protocol-sync';
import {
  RoomInfo,
  UserInfo as RoomUserInfo,
  UserInfoShort as RoomUserInfoShort
} from '@ucap/protocol-room';

export interface RoomState extends EntityState<RoomInfo> {
  syncDate: string;
}
export const adapterRoom = createEntityAdapter<RoomInfo>({
  selectId: (roomInfo) => roomInfo.roomId,
  sortComparer: (a, b) => {
    return (
      moment(b.finalEventDate).toDate().getTime() -
      moment(a.finalEventDate).toDate().getTime()
    );
  }
});

export interface RoomUserMap {
  roomId: string;
  userInfos: RoomUserInfo[];
}

export interface RoomUserShortMap {
  roomId: string;
  userInfos: RoomUserInfoShort[];
}

export interface RoomUserState extends EntityState<RoomUserMap> {}
export const adapterRoomUser = createEntityAdapter<RoomUserMap>({
  selectId: (roomUserDetailData) => roomUserDetailData.roomId
});

export interface RoomUserShortState extends EntityState<RoomUserShortMap> {}
export const adapterRoomUserShort = createEntityAdapter<RoomUserShortMap>({
  selectId: (roomUserShortData) => roomUserShortData.roomId
});

export interface State {
  rooms: RoomState;
  roomUsers: RoomUserState;
  roomUsersShort: RoomUserShortState;
}

const roomInitialState: RoomState = adapterRoom.getInitialState({
  syncDate: ''
});
const roomUserInitialState: RoomUserState = adapterRoomUser.getInitialState({});
const roomUserShortInitialState: RoomUserShortState = adapterRoomUserShort.getInitialState(
  {}
);

export const initialState: State = {
  rooms: roomInitialState,
  roomUsers: roomUserInitialState,
  roomUsersShort: roomUserShortInitialState
};

const {
  selectAll: selectAllForRoom,
  selectEntities: selectEntitiesForRoom,
  selectIds: selectIdsForRoom,
  selectTotal: selectTotalForRoom
} = adapterRoom.getSelectors();

const {
  selectAll: selectAllForRoomUser,
  selectEntities: selectEntitiesForRoomUser,
  selectIds: selectIdsForRoomUser,
  selectTotal: selectTotalForRoomUser
} = adapterRoomUser.getSelectors();

const {
  selectAll: selectAllForRoomUserShort,
  selectEntities: selectEntitiesForRoomUserShort,
  selectIds: selectIdsForRoomUserShort,
  selectTotal: selectTotalForRoomUserShort
} = adapterRoomUserShort.getSelectors();

export function selectors<S>(selector: Selector<any, State>) {
  const selectRooms = createSelector(selector, (state: State) => state.rooms);

  const selectRoomUsers = createSelector(
    selector,
    (state: State) => state.roomUsers
  );

  const selectRoomUsersShort = createSelector(
    selector,
    (state: State) => state.roomUsersShort
  );

  return {
    rooms: createSelector(selectRooms, selectAllForRoom),
    room: createSelector(
      selectRooms,
      (roomState: RoomState, roomId: string) => {
        return roomState.entities && roomState.entities[roomId];
      }
    ),
    roomsSyncDate: createSelector(
      selectRooms,
      (roomState) => roomState.syncDate
    ),
    roomUsers: createSelector(selectRoomUsers, selectAllForRoomUser),
    roomUser: createSelector(
      selectRoomUsers,
      (roomUserState: RoomUserState, roomId: string) => {
        return roomUserState.entities && roomUserState.entities[roomId];
      }
    ),
    roomUsersShort: createSelector(
      selectRoomUsersShort,
      selectAllForRoomUserShort
    ),
    roomUserShort: createSelector(
      selectRoomUsersShort,
      (roomUserShortState: RoomUserShortState, roomId: string) => {
        return (
          roomUserShortState.entities && roomUserShortState.entities[roomId]
        );
      }
    ),
    unreadTotal: createSelector(
      selectRooms,
      selectAllForRoom,
      (roomState: RoomState, rooms: RoomInfo[]) => {
        let unreadTotal = 0;
        for (const room of rooms) {
          unreadTotal += room.noReadCnt;
        }
        return unreadTotal;
      }
    )
  };
}