import { isNil } from 'lodash'

import { BioimpedanceWithWeight } from '../models'
import { CompetitionCompetitorRepository, CompetitionHistoryRepository } from '../../../repositories'
import { Competition, CompetitionCompetitor } from '../../../models/ranking'
import { RequiredArgumentError, UnprocessableEntityError } from '../../../errors'

import { CompetitionHistoryFactory } from './competition-history.factory'

type CompetitionCompetitorFactoryParams = {
  bioimpedance?: BioimpedanceWithWeight
  competition: Competition
  competitionCompetitorRepository: CompetitionCompetitorRepository
  competitionHistoryRepository?: CompetitionHistoryRepository
  patientId?: string
  position?: number
}

type BuildCompetitionHistoryParams = {
  bioimpedance: BioimpedanceWithWeight
  competition: Competition
  competitor: CompetitionCompetitor
  competitionHistoryRepository: CompetitionHistoryRepository
}

export class CompetitionCompetitorFactory {
  static async build({
    bioimpedance,
    competition,
    competitionCompetitorRepository,
    competitionHistoryRepository,
    patientId,
    position,
  }: CompetitionCompetitorFactoryParams): Promise<CompetitionCompetitor> {
    if (isNil(competition?.id)) throw new UnprocessableEntityError('Competition has not an id')
    if (isNil(competitionCompetitorRepository)) throw new RequiredArgumentError('competitionCompetitorRepository')

    const competitor = await competitionCompetitorRepository.create(
      CompetitionCompetitor.toInstance({
        competition_id: competition.id,
        patient_id: patientId || competition.patient_id,
        score: 0,
        position,
        created_at: new Date(),
      }),
    )

    if (!isNil(competitionHistoryRepository) && !isNil(bioimpedance))
      return this.buildAndAddHistory({ bioimpedance, competition, competitor, competitionHistoryRepository })

    return competitor
  }

  private static async buildAndAddHistory({
    bioimpedance,
    competition,
    competitor,
    competitionHistoryRepository,
  }: BuildCompetitionHistoryParams): Promise<CompetitionCompetitor> {
    const history = await CompetitionHistoryFactory.build({
      bioimpedance,
      competition,
      competitor,
      competitionHistoryRepository,
      position: competitor.position,
    })

    competitor.history = isNil(history?.value) ? [] : [history]
    competitor.score = history?.score

    return competitor
  }
}