import { Test, TestingModule } from '@nestjs/testing'
import { datatype } from 'faker'

import { Anthropometry, Bioimpedance } from '../../../models'
import { AnthropometryRepository } from '../../../repositories/anthropometry.repository'
import { factory } from '../../../../test/factories'
import { MockedModule } from '../../../../test/types'

import { BioimpedanceHelper } from './bioimpendance.helper'

describe('BioimpedanceHelper', () => {
  let subject: BioimpedanceHelper
  let anthropometryRepository: MockedModule<AnthropometryRepository>

  beforeAll(async () => {
    anthropometryRepository = {
      findByPatientSince: jest.fn(),
      getWithBioimpedance: jest.fn(),
    }

    const app: TestingModule = await Test.createTestingModule({
      providers: [
        {
          provide: AnthropometryRepository,
          useValue: anthropometryRepository,
        },
        BioimpedanceHelper,
      ],
    }).compile()

    subject = app.get<BioimpedanceHelper>(BioimpedanceHelper)
  })

  afterEach(() => {
    jest.clearAllMocks()
  })

  afterAll(() => {
    jest.restoreAllMocks()
  })

  describe('#getLastBioimpedanceFromLast30Days', () => {
    const patientId = datatype.uuid()

    describe('when repository returns an empty array', () => {
      beforeEach(() => {
        anthropometryRepository.findByPatientSince.mockResolvedValue([])
      })

      it('returns null', async () => {
        await expect(subject.getLastBioimpedanceFromLast30Days(patientId)).resolves.toBeNull()
      })
    })

    describe('when repository returns anthropometries', () => {
      let anthropometries: Anthropometry[]

      beforeEach(async () => {
        anthropometries = await factory.buildMany('anthropometry', datatype.number({ min: 1, max: 10 }))
        anthropometryRepository.findByPatientSince.mockResolvedValue(anthropometries)

        anthropometries.forEach(anthropometry => {
          anthropometry.weight = datatype.number({ min: 1 })
          anthropometry.bioimpedance = Bioimpedance.toInstance({ bfm: datatype.number({ min: 1 }) })
        })
      })

      it('returns the last bioimpedance done', async () => {
        await expect(subject.getLastBioimpedanceFromLast30Days(patientId)).resolves.toEqual(
          expect.objectContaining({ weight: anthropometries[0].weight, bfm: anthropometries[0].bioimpedance?.bfm }),
        )
      })

      describe('when the anthropometry does not have a bioimpedance', () => {
        beforeEach(async () => {
          anthropometries = await factory.buildMany('anthropometry', 1)
          delete anthropometries[0].bioimpedance_id
          anthropometryRepository.findByPatientSince.mockResolvedValue(anthropometries)
        })

        it('returns null', async () => {
          await expect(subject.getLastBioimpedanceFromLast30Days(patientId)).resolves.toBeNull()
        })
      })
    })
  })

  describe('#getBioimpedanceByAnthropometry', () => {
    const patientId = datatype.uuid()

    describe('when repository returns empty', () => {
      beforeEach(() => {
        anthropometryRepository.findByPatientSince.mockResolvedValue(null)
      })

      it('returns null', async () => {
        await expect(subject.getBioimpedanceByAnthropometry(patientId)).resolves.toBeNull()
      })
    })

    describe('when repository returns the anthropometry', () => {
      let anthropometry: Anthropometry

      beforeEach(async () => {
        anthropometry = await factory.build('anthropometry', {
          weight: datatype.number({ min: 1 }),
          bioimpedance: Bioimpedance.toInstance({ bfm: datatype.number({ min: 1 }) }),
        })
        anthropometryRepository.getWithBioimpedance.mockResolvedValue(anthropometry)
      })

      it('returns the last bioimpedance done', async () => {
        await expect(subject.getBioimpedanceByAnthropometry(patientId)).resolves.toEqual(
          expect.objectContaining({ weight: anthropometry.weight, bfm: anthropometry.bioimpedance?.bfm }),
        )
      })

      describe('when the anthropometry does not have a bioimpedance', () => {
        beforeEach(async () => {
          anthropometry = await factory.build('anthropometry')
          delete anthropometry.bioimpedance_id
          anthropometryRepository.getWithBioimpedance.mockResolvedValue(anthropometry)
        })

        it('returns null', async () => {
          await expect(subject.getBioimpedanceByAnthropometry(patientId)).resolves.toBeNull()
        })
      })
    })
  })
})