import { EligibilityService } from './EligibilityService';
import { SmartMeterBookingClient } from '../clients/SmartMeterBookingClient';
import { UserDataState } from '../state/UserDataState';
import { Mock, It, IMock, Times } from 'typemoq';
import { address } from '../entities/Address.fixture';
import { AvailableAppointmentsResponse } from '../entities/Eligibility';
import { availableAppointmentsResponse, meterEligibilityResponse } from '../entities/Eligibility.fixture';
import { $q } from '../util/PromiseUtils';
import { expect } from 'chai';

describe('Eligibility service', () => {
  let smartMeterBookingClient: IMock<SmartMeterBookingClient>;
  let userDataState: UserDataState;
  let eligibilityService: EligibilityService;

  beforeEach(() => {
    smartMeterBookingClient = Mock.ofType<SmartMeterBookingClient>();
    userDataState = {} as UserDataState;
    eligibilityService = new EligibilityService(smartMeterBookingClient.object, userDataState, $q);
  });

  it('clears the eligibility state', () => {
    eligibilityService.eligibilityState = { status: 'MeterNotEligible', isIGT: false, smartMeterRequired: true };
    eligibilityService.clear();
    return expect(eligibilityService.eligibilityState).to.be.undefined;
  });

  it('returns the existing address eligibility', () => {
    eligibilityService.eligibilityState = { status: 'MeterNotEligible', isIGT: false, smartMeterRequired: true };
    return expect(eligibilityService.checkSupplyAddress()).to.eventually.deep.equal({ status: 'MeterNotEligible', isIGT: false, smartMeterRequired: true });
  });

  it('returns the meter eligibility when meter ineligible', () => {
    userDataState.supplyAddress = address;
    smartMeterBookingClient.setup(x => x.getMeterEligibility(It.isAny())).returns(() => Promise.resolve({ data: { ...meterEligibilityResponse, isEligible: false } }));
    return expect(eligibilityService.checkSupplyAddress()).to.eventually.deep.equal({
      status: 'MeterNotEligible',
      isIGT: false,
      smartMeterRequired: true
    });
  });

  it('returns the meter eligibility when smart meter is not required', () => {
    userDataState.supplyAddress = address;
    smartMeterBookingClient.setup(x => x.getMeterEligibility(It.isAny())).returns(() => Promise.resolve({ data: { ...meterEligibilityResponse, smartMeterRequired: false } }));
    return expect(eligibilityService.checkSupplyAddress()).to.eventually.deep.equal({
      status: 'Eligible',
      isIGT: false,
      smartMeterRequired: false
    });
  });

  it('returns the combined address eligibility when meter eligible', () => {
    userDataState.postcode = 'AB1 2CD';
    userDataState.supplyAddress = address;
    smartMeterBookingClient.setup(x => x.getMeterEligibility(It.isAny())).returns(() => Promise.resolve({ data: meterEligibilityResponse }));
    smartMeterBookingClient.setup(x => x.getAreaEligibility(It.isValue('AB1 2CD'))).returns(() => Promise.resolve({ data: { isEligible: false } }));
    return expect(eligibilityService.checkSupplyAddress()).to.eventually.deep.equal({
      status: 'AreaNotEligible',
      isIGT: false,
      smartMeterRequired: true
    });
  });

  it('returns the existing availability', () => {
    eligibilityService.availabilityState = { appointmentAvailability: 'None' };
    return expect(eligibilityService.checkAvailability()).to.eventually.deep.equal({
      appointmentAvailability: 'None'
    });
  });

  it('returns the availability for an address', () => {
    userDataState.supplyAddress = address;
    smartMeterBookingClient.setup(x => x.getAvailableAppointments(It.isAny())).returns(() => Promise.resolve({ data: availableAppointmentsResponse }));
    return expect(eligibilityService.checkAvailability()).to.eventually.deep.equal({
      appointmentAvailability: 'High',
      firstAppointment: {
        start: new Date("2017-09-18T12:00:00.000Z"),
        end: new Date("2017-09-18T16:00:00.000Z")
      }
    });
  });

  it('rejects the availability for an address without MPANs', () => {
    userDataState.supplyAddress = { ...address, mpans: [] };
    return expect(eligibilityService.checkAvailability()).to.be.rejected;
  });

  it('rejects the availability for dual fuel with an address without MPRNs', () => {
    userDataState.supplyAddress = { ...address, mprns: [] };
    userDataState.fuel = 'Dual';
    return expect(eligibilityService.checkAvailability()).to.be.rejected;
  });
});