import {tolerant_selector} from './base'
import {get_users} from './users'
import moment from '../common/moment'
import {with_recipient} from '../common/messages'
import {array_from_hash} from '../common/utilities'

const get_recruiter_users = (state) => state.users.recruiter_users
const get_muted_users = (state) => state.mutes.muted_users
const get_raw_messages = (state) => state.messages.messages
const get_raw_recruiters = (state) => state.recruiters.recruiters
const get_raw_users = (state) => state.users.users

export const get_messages = tolerant_selector(
  [get_raw_messages, get_raw_recruiters, get_raw_users],
  (messages, recruiters, users) => array_from_hash(messages).map((message) => ({
    ...message,
    sender: message.sender_type == 'User' ? users[message.sender_id] : recruiters[message.sender_id],
  }))
)

const get_conversations = tolerant_selector(
  [get_messages],
  (messages) => messages.reduce((conversations, message) => {
    let user = message.recipient_type == 'User' ? message.recipient_id : message.sender_id
    let conversation = conversations[user]
    if (!conversation) {
      conversation = []
    }
    return {
      ...conversations,
      [user]: [
        ...conversation,
        message,
      ],
    }
  }, {})
)

export const get_recipients = tolerant_selector(
  [get_users, get_recruiter_users, get_messages],
  (users, recruiter_users, messages) => (
    recruiter_users.filter((user) => users[user]).map((user_id) => {
      let agency_messages = messages.filter((message) => with_recipient(message, user_id))
      let last_message
      if (agency_messages.length == 0) {
        last_message = {}
      } else {
        last_message = agency_messages.reduce((last_message, message) => moment(message.created_at).isAfter(last_message.created_at) ? message : last_message)
      }
      let unread_messages = agency_messages.reduce((unread_messages, message) => {
        if (message.recipient_type === 'Agency' && message.read_at == null) {
          return unread_messages + 1
        } else {
          return unread_messages
        }
      }, 0)
      return {
        ...users[user_id],
        last_message,
        unread_messages
      }
    })
    .sort((u1, u2) => u2.last_message.created_at && u1.last_message.created_at ? (moment(u2.last_message.created_at).isAfter(u1.last_message.created_at) ? 1 : -1) : (u2.last_message.created_at ? 1 : -1))
  )
)

export const get_unread_messages = tolerant_selector(
  [get_recipients],
  (recipients) => recipients.reduce((unread_messages, recipient) => unread_messages + recipient.unread_messages, 0)
)