import { createSelector } from 'reselect'
import * as moment from 'moment'
import { reverse, filter, uniq, map  } from 'lodash'

import * as PopupSelectors from '../popup/selectors'
import {
  IActivity,
  IActivityState,
  IGroupedActivities,
  ActivityType,
} from './interfaces'

export const root = (state: any): IActivityState => state.activity
export const activitiesLoading = (state: any) => root(state).loading
export const isLoaded = (state: any) => root(state).loaded
export const rawActivities = (state: any) => root(state).activities
export const rawActivitiesByEmail = (state: any) => root(state).activitiesByEmail


export const activities = createSelector([
  PopupSelectors.searchQuery,
  rawActivities,
  rawActivitiesByEmail,
], (
  query: string,
  activities: IActivity[],
  activitiesByEmail: IActivity[],
) => {
  return query ? activitiesByEmail : activities
})

export const conversationIds = createSelector([
  rawActivities,
], (activities: IActivity[]) => {
  const messagesActivities = filter(activities, { type: ActivityType.MESSAGE })
  const listOfConversationIds = map(messagesActivities, 'message.conversationId')
  return uniq(listOfConversationIds) as number[]
})

export const messageActivities = createSelector([
  rawActivities,
], (activities: IActivity[]) => filter(activities, { type: ActivityType.MESSAGE }))

const parseActivitiesIntoGroupedActivities = (activities: IActivity[], previousLastSeenAt: number) => {
  return reverse(activities.reduce((activityGroups, activity): IGroupedActivities[] => {
    const group: IGroupedActivities = activityGroups.length > 0 && activityGroups[activityGroups.length - 1]
    if (group && group.email === activity.email && moment(activity.at).isSame(moment(group.at), 'day')) {
      group.activities.unshift(activity)
      group.unseen = activity.at > previousLastSeenAt
    } else {
      activityGroups.push({
        date: moment(activity.at).format('YYYY-MM-DD'),
        at: activity.at,
        email: activity.email,
        activities: [activity],
        unseen: activity.at > previousLastSeenAt,
      })
    }
    return activityGroups
  }, []))
    .map((group, index, groups) => {
      group.firstOfDate = index === 0 || group.date !== groups[index - 1].date
      return group
    })
}

export const groupedActivities = createSelector([
  activities,
  PopupSelectors.previousLastSeenAt,
], (
  activities: IActivity[],
  previousLastSeenAt: number,
) => {
  return parseActivitiesIntoGroupedActivities(activities, previousLastSeenAt)
})