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

import { BioimpedanceCreditService, TeleconsultationsCreditService } from '../../../services/credits'
import { Campaign } from '../../../models/credits'
import { CampaignRepository, CreditPendingRepository } from '../../../repositories'
import { factory } from '../../../../test/factories'
import { MockedModule } from '../../../../test/types'

import { Credits } from './credits'

describe('Credits', () => {
  let subject: Credits
  let bioimpedanceCreditService: MockedModule<BioimpedanceCreditService>
  let teleconsultationsCreditService: MockedModule<TeleconsultationsCreditService>
  let campaignRepository: MockedModule<CampaignRepository>

  beforeAll(async () => {
    bioimpedanceCreditService = {
      createTransaction: jest.fn(),
    }
    teleconsultationsCreditService = {
      createTransaction: jest.fn(),
    }
    campaignRepository = {
      get: jest.fn(),
      checkIfPatientsAlreadyUsedCampaign: jest.fn(),
    }

    const app: TestingModule = await Test.createTestingModule({
      controllers: [],
      providers: [
        {
          provide: BioimpedanceCreditService,
          useValue: bioimpedanceCreditService,
        },
        {
          provide: TeleconsultationsCreditService,
          useValue: teleconsultationsCreditService,
        },
        {
          provide: CreditPendingRepository,
          useValue: null,
        },
        {
          provide: CampaignRepository,
          useValue: campaignRepository,
        },
        Credits,
      ],
    }).compile()

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

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

  describe('#addByCampaign', () => {
    const patientId = datatype.uuid()
    let campaign: Campaign

    beforeAll(async () => {
      campaign = await factory.build('campaign')
    })

    beforeEach(() => {
      campaignRepository.get.mockResolvedValue(campaign)
    })

    describe('when campaign is not valid', () => {
      beforeAll(() => {
        campaign.total_used = campaign.total_available
      })

      it('returns false', async () => {
        await expect(subject.addByCampaign(patientId, campaign.value)).resolves.toBeFalsy()
      })
    })

    describe('when campaign is valid', () => {
      beforeAll(() => {
        campaign.total_used = 0
      })

      describe('when patient already has used the campaign', () => {
        beforeAll(() => {
          campaignRepository.checkIfPatientsAlreadyUsedCampaign.mockResolvedValue(true)
        })

        it('returns false', async () => {
          await expect(subject.addByCampaign(patientId, campaign.value)).resolves.toBeFalsy()
        })
      })

      describe('when patiend has not used the campaign yet', () => {
        beforeAll(() => {
          campaignRepository.checkIfPatientsAlreadyUsedCampaign.mockResolvedValue(false)
        })

        it('creates a credit', async () => {
          await subject.addByCampaign(patientId, campaign.value)

          expect(subject['getCreditServiceByProduct'](campaign.product).createTransaction).toHaveBeenCalledWith(
            expect.objectContaining({ campaignValue: campaign.value, value: campaign.credit_quantity }),
          )
        })

        it('returns true', async () => {
          await expect(subject.addByCampaign(patientId, campaign.value)).resolves.toBeTruthy()
        })
      })
    })
  })
})