import { datatype, random } from 'faker'
import { sample } from 'lodash'

import { Competition, CompetitionCategories, CompetitionCompetitor } from '../../../models/ranking/competition'
import { CompetitionRepository, CompetitionCompetitorRepository } from '../../../repositories/ranking/competition'
import { MockedModule } from '../../../../test/types'
import { RequiredArgumentError } from '../../../errors/required_argument.error'

import { CompetitionFactory } from './competition.factory'
import { CompetitionCompetitorFactory } from './competition-competitor.factory'

describe('CompetitionFactory', () => {
  describe('#build', () => {
    const competitor = CompetitionCompetitor.toInstance({})
    const competition = Competition.toInstance({})
    let title: string
    let patientId: string
    let category: CompetitionCategories
    let willEndAt: Date
    let competitionRepository: MockedModule<CompetitionRepository>
    let competitionCompetitorRepository: MockedModule<CompetitionCompetitorRepository>
    let competitorFactory: jest.SpyInstance

    beforeAll(() => {
      competitionRepository = {
        create: jest.fn(),
      }
      competitionCompetitorRepository = {
        create: jest.fn(),
      }
      title = random.words()
      patientId = datatype.uuid()
      category = sample(Object.values(CompetitionCategories))
      willEndAt = new Date()
      competitorFactory = jest.spyOn(CompetitionCompetitorFactory, 'build')
    })

    beforeEach(() => {
      competitionRepository.create.mockResolvedValue(competition)
      competitorFactory.mockResolvedValue(competitor)
    })

    describe('when title is not given', () => {
      it('throws an error', async () => {
        await expect(
          CompetitionFactory.build({
            title: null,
            category,
            patientId,
            willEndAt,
            competitionRepository: competitionRepository as any,
            competitionCompetitorRepository: competitionCompetitorRepository as any,
          }),
        ).rejects.toThrowError(RequiredArgumentError)
      })
    })

    describe('when category is not given', () => {
      it('throws an error', async () => {
        await expect(
          CompetitionFactory.build({
            title,
            category: null,
            patientId,
            willEndAt,
            competitionRepository: competitionRepository as any,
            competitionCompetitorRepository: competitionCompetitorRepository as any,
          }),
        ).rejects.toThrowError(RequiredArgumentError)
      })
    })

    describe('when patientId is not given', () => {
      it('throws an error', async () => {
        await expect(
          CompetitionFactory.build({
            title,
            category,
            patientId: null,
            willEndAt,
            competitionRepository: competitionRepository as any,
            competitionCompetitorRepository: competitionCompetitorRepository as any,
          }),
        ).rejects.toThrowError(RequiredArgumentError)
      })
    })

    describe('when willEndAt is not given', () => {
      it('throws an error', async () => {
        await expect(
          CompetitionFactory.build({
            title,
            category,
            patientId,
            willEndAt: null,
            competitionRepository: competitionRepository as any,
            competitionCompetitorRepository: competitionCompetitorRepository as any,
          }),
        ).rejects.toThrowError(RequiredArgumentError)
      })
    })

    describe('when competitionRepository is not given', () => {
      it('throws an error', async () => {
        await expect(
          CompetitionFactory.build({
            title,
            category,
            patientId,
            willEndAt,
            competitionRepository: null,
            competitionCompetitorRepository: competitionCompetitorRepository as any,
          }),
        ).rejects.toThrowError(RequiredArgumentError)
      })
    })

    describe('when all arguments is given', () => {
      beforeAll(() => {
        competition.title = title
        competition.category = category
        competition.patient_id = patientId
        competition.will_end_at = willEndAt
      })

      it('creates a history data', async () => {
        await expect(
          CompetitionFactory.build({
            title,
            category,
            patientId,
            willEndAt,
            competitionRepository: competitionRepository as any,
            competitionCompetitorRepository: competitionCompetitorRepository as any,
          }),
        ).resolves.toEqual(
          expect.objectContaining({
            title,
            category,
            patient_id: patientId,
            will_end_at: willEndAt,
            competitors: [competitor],
          }),
        )
      })
    })
  })
})