const config = require('config')
const { findLast, isEmpty, maxBy, get, flatMap, last } = require('lodash')

const { features = {}, recommendations: configRecommendations } = config

const Fragment = require('./Fragment')

class Collection {
  constructor({ collection = {} }) {
    this.collection = collection
  }

  async updateStatusByRecommendation({
    recommendation,
    isHandlingEditor = false,
    fragments,
  }) {
    let newStatus
    if (isHandlingEditor) {
      newStatus = 'pendingApproval'
      if (['minor', 'major'].includes(recommendation)) {
        newStatus = 'revisionRequested'
      }
    } else {
      if (recommendation === 'minor') {
        newStatus = this.hasAtLeastOneReviewReport(fragments)
          ? 'reviewCompleted'
          : 'heAssigned'
      }

      if (recommendation === 'major') {
        newStatus = 'underReview'
      }
    }

    return this.updateStatus({ newStatus })
  }

  async updateFinalStatusByRecommendation({ recommendation }) {
    let newStatus
    switch (recommendation) {
      case 'reject':
        newStatus = 'rejected'
        break
      case 'publish':
        newStatus = 'accepted'
        break
      case 'return-to-handling-editor':
        newStatus = 'reviewCompleted'
        break
      default:
        break
    }

    await this.updateStatus({ newStatus })
  }

  async updateStatus({ newStatus }) {
    this.collection.status = newStatus
    await this.collection.save()
  }

  async addHandlingEditor({ user, invitation }) {
    this.collection.handlingEditor = {
      id: user.id,
      name: `${user.firstName} ${user.lastName}`,
      invitedOn: invitation.invitedOn,
      respondedOn: invitation.respondedOn,
      email: user.email,
      hasAnswer: invitation.hasAnswer,
      isAccepted: invitation.isAccepted,
    }
    await this.updateStatus({ newStatus: 'heInvited' })
  }

  async updateHandlingEditor({ isAccepted }) {
    const { collection: { handlingEditor } } = this
    handlingEditor.hasAnswer = true
    handlingEditor.isAccepted = isAccepted
    handlingEditor.respondedOn = Date.now()

    const newStatus = isAccepted ? 'heAssigned' : 'submitted'

    await this.updateStatus({ newStatus })
  }

  async updateStatusByNumberOfReviewers({ invitations }) {
    const reviewerInvitations = invitations.filter(
      inv => inv.role === 'reviewer',
    )
    if (reviewerInvitations.length === 0)
      await this.updateStatus({ newStatus: 'heAssigned' })
  }

  async updateStatusOnRecommendation({ isEditorInChief, recommendation }) {
    if (isEditorInChief) {
      if (recommendation === 'return-to-handling-editor') {
        return this.updateStatus({ newStatus: 'reviewCompleted' })
      }
      return this.updateFinalStatusByRecommendation({
        recommendation,
      })
    }
    return this.updateStatusByRecommendation({
      recommendation,
      isHandlingEditor: true,
    })
  }

  getHELastName() {
    const [firstName, lastName] = this.collection.handlingEditor.name.split(' ')
    return lastName || firstName
  }

  async getReviewerNumber({ userId }) {
    const allCollectionFragments = await this.collection.getFragments()
    const allCollectionInvitations = flatMap(
      allCollectionFragments,
      fragment => fragment.invitations,
    )
    const allNumberedInvitationsForUser = allCollectionInvitations
      .filter(invite => invite.userId === userId)
      .filter(invite => invite.reviewerNumber)

    if (isEmpty(allNumberedInvitationsForUser)) {
      const maxReviewerNumber = get(
        maxBy(allCollectionInvitations, 'reviewerNumber'),
        'reviewerNumber',
        0,
      )
      return maxReviewerNumber + 1
    }
    return allNumberedInvitationsForUser[0].reviewerNumber
  }

  // eslint-disable-next-line class-methods-use-this
  hasAtLeastOneReviewReport(fragments) {
    return fragments.some(fragment =>
      new Fragment({ fragment }).hasReviewReport(),
    )
  }

  canHEMakeRecommendation(fragments, fragmentHelper) {
    if (this.collection.fragments.length === 1) {
      return fragmentHelper.hasReviewReport()
    }
    const previousVersionRecommendations = get(
      fragments[fragments.length - 2],
      'recommendations',
      [],
    )

    const lastEditorRecommendation = findLast(
      previousVersionRecommendations,
      recommendation =>
        recommendation.recommendationType === 'editorRecommendation',
    )

    if (lastEditorRecommendation.recommendation === 'minor') {
      return this.hasAtLeastOneReviewReport(fragments)
    } else if (lastEditorRecommendation.recommendation === 'major') {
      return fragmentHelper.hasReviewReport()
    }

    return false
  }

  async getAllFragments({ FragmentModel }) {
    return Promise.all(
      this.collection.fragments.map(async fragment =>
        FragmentModel.find(fragment),
      ),
    )
  }

  isLatestVersion(fragmentId) {
    return last(this.collection.fragments) === fragmentId
  }
}

module.exports = Collection