import { datatype } from 'faker'

import { BioimpedanceWithWeight } from '../models/bioimpedance-with-weight.model'
import { Competition, CompetitionCompetitor, CompetitionHistory } from '../../../models/ranking/competition'
import {
  CompetitionCompetitorRepository,
  CompetitionHistoryRepository,
} from '../../../repositories/ranking/competition'
import { MockedModule } from '../../../../test/types'
import { RequiredArgumentError, UnprocessableEntityError } from '../../../errors'

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

describe('CompetitionCompetitorFactory', () => {
  describe('#buildAndAddHistory', () => {
    const bioimpedance = BioimpedanceWithWeight.toInstance({})
    const competition = Competition.toInstance({})
    const competitor = CompetitionCompetitor.toInstance({})
    let history = CompetitionHistory.toInstance({})
    let competitionHistoryRepository: MockedModule<CompetitionHistoryRepository>
    let historyFactorySpy: jest.SpyInstance

    beforeAll(() => {
      competitionHistoryRepository = {
        create: jest.fn(),
      }
      historyFactorySpy = jest.spyOn(CompetitionHistoryFactory, 'build')
    })

    beforeEach(() => {
      historyFactorySpy.mockResolvedValue(history)
    })

    describe('when history is created', () => {
      beforeAll(() => {
        history.value = datatype.number({ min: 1 })
        history.score = datatype.number()
      })

      it('returns competitor with your first history', async () => {
        await expect(
          CompetitionCompetitorFactory['buildAndAddHistory']({
            bioimpedance,
            competition,
            competitor,
            competitionHistoryRepository: competitionHistoryRepository as any,
          }),
        ).resolves.toEqual(
          expect.objectContaining({
            history: [history],
            score: history.score,
          }),
        )
      })
    })

    describe('when history is not created', () => {
      beforeAll(() => {
        history = null
      })

      it('returns competitor with no history', async () => {
        await expect(
          CompetitionCompetitorFactory['buildAndAddHistory']({
            bioimpedance,
            competition,
            competitor,
            competitionHistoryRepository: competitionHistoryRepository as any,
          }),
        ).resolves.toEqual(
          expect.objectContaining({
            history: [],
          }),
        )
      })
    })
  })

  describe('#build', () => {
    const bioimpedance = BioimpedanceWithWeight.toInstance({})
    const competition = Competition.toInstance({})
    const history = CompetitionHistory.toInstance({})
    const competitor = CompetitionCompetitor.toInstance({})
    let competitionCompetitorRepository: MockedModule<CompetitionCompetitorRepository>
    let competitionHistoryRepository: MockedModule<CompetitionHistoryRepository>
    let historyFactorySpy: jest.SpyInstance

    beforeAll(() => {
      competitionCompetitorRepository = {
        create: jest.fn(),
      }
      competitionHistoryRepository = {
        create: jest.fn(),
      }
      historyFactorySpy = jest.spyOn(CompetitionHistoryFactory, 'build')
    })

    beforeEach(() => {
      competitionCompetitorRepository.create.mockResolvedValue(competitor)
      historyFactorySpy.mockResolvedValue(history)
    })

    describe('when competitor has not an id', () => {
      beforeAll(() => {
        competition.id = null
      })

      it('throws an error', async () => {
        await expect(
          CompetitionCompetitorFactory.build({
            competition,
            competitionCompetitorRepository: competitionCompetitorRepository as any,
          }),
        ).rejects.toThrowError(UnprocessableEntityError)
      })
    })

    describe('when compositionCompetitorRepository is not given', () => {
      beforeAll(() => {
        competition.id = datatype.uuid()
      })

      it('throws an error', async () => {
        await expect(
          CompetitionCompetitorFactory.build({
            competition,
            competitionCompetitorRepository: null,
          }),
        ).rejects.toThrowError(RequiredArgumentError)
      })
    })

    describe('when all arguments is given', () => {
      beforeAll(() => {
        competitor.competition_id = competition.id = datatype.uuid()
        competitor.patient_id = competition.patient_id = datatype.uuid()
      })

      it('creates the competitor data', async () => {
        await expect(
          CompetitionCompetitorFactory.build({
            competition,
            competitionCompetitorRepository: competitionCompetitorRepository as any,
          }),
        ).resolves.toEqual(
          expect.objectContaining({
            competition_id: competition.id,
            patient_id: competition.patient_id,
          }),
        )
      })

      describe('when patientId is given', () => {
        const patientId = datatype.uuid()

        beforeAll(() => {
          competitor.patient_id = patientId
        })

        it('creates a history data', async () => {
          await expect(
            CompetitionCompetitorFactory.build({
              competition,
              competitionCompetitorRepository: competitionCompetitorRepository as any,
              patientId,
            }),
          ).resolves.toEqual(
            expect.objectContaining({
              competition_id: competition.id,
              patient_id: patientId,
            }),
          )
        })
      })

      describe('when the bioimpedance is given', () => {
        beforeAll(() => {
          history.value = datatype.number({ min: 1 })
          history.score = datatype.number()
        })

        it('add a history', async () => {
          await expect(
            CompetitionCompetitorFactory.build({
              competition,
              bioimpedance,
              competitionCompetitorRepository: competitionCompetitorRepository as any,
              competitionHistoryRepository: competitionHistoryRepository as any,
            }),
          ).resolves.toEqual(
            expect.objectContaining({
              history: expect.arrayContaining([expect.any(CompetitionHistory)]),
            }),
          )
        })
      })
    })
  })
})