import { expect } from 'chai';
import { Licence } from '../../../src/models/licence';

describe('Licence', () => {
	let licence: any;
	let licenceData: any;

	beforeEach(() => {
		licenceData = {
			id: 'licenceId',
			types: ['trial'],
			seatLimit: 100,
			status: 'active',
			allocatedSeats: 0,
			acquisitionContext: [{ displayName: 'Display Name' }],
			products: [{ name: 'FT.com Premium', code: 'P2' }],
			administrators: [{ userId: 'userId', licenceId: 'licenceId' }]
		};

		licence = new Licence(licenceData);
	});

	describe('on initialise', () => {

		beforeEach(() => {
			licence = new Licence(licenceData);
		});

		it('sets this.licenceId', () => {
			expect(licence.id).to.equal(licenceData.id);
		});

		it('sets this.allocatedSeats', () => {
			expect(licence.allocatedSeats).to.equal(licenceData.allocatedSeats);
		});

		it('sets this.seatLimit', () => {
			expect(licence.seatLimit).to.equal(licenceData.seatLimit);
		});

		it('sets this.status', () => {
			expect(licence.status).to.equal(licenceData.status);
		});

		it('sets this.types', () => {
			expect(licence.types).to.eql(['trial']);
		});

		it('sets this.acquisitionContext with an array of AcquisitionContext instances', () => {
			expect(licence.acquisitionContext).to.eql(licenceData.acquisitionContext);
		});

		it('sets this.product', () => {
			expect(licence.products).to.equal(licenceData.products);
		});

	});

	describe('isSubscribedWithGoogle', () => {
		it('returns FALSE if licence issueReason is not Subscribed with Google ', () => {
			licenceData.issueReason = 'Contract Signed';
			const invalidLicence = new Licence(licenceData);
			expect(invalidLicence.isSubscribedWithGoogle()).to.be.false;
		});

		it('returns TRUE if licence issueReason is Subscribed with Google', () => {
			licenceData.issueReason = 'Subscribed with Google';
			const licence = new Licence(licenceData);
			expect(licence.isSubscribedWithGoogle()).to.be.true;
		});
	});

	describe('isValid', () => {

		it('returns TRUE if licence is status is active', () => {
			const licence = new Licence(licenceData);
			expect(licence.isValid()).to.be.true;
		});

		it('returns FALSE if licence is status is NOT active', () => {
			licenceData.status = 'expired';
			const invalidLicence = new Licence(licenceData);
			expect(invalidLicence.isValid()).to.be.false;
		});

	});

	describe('isManagedTrial', () => {

		it('returns TRUE if licence type is trial', () => {
			const licence = new Licence(licenceData);
			expect(licence.isManagedTrial()).to.be.true;
		});

		it('returns FALSE if licence type is NOT trial', () => {
			licenceData.types = ['b2b-marketing-initiative'];
			const licence = new Licence(licenceData);
			expect(licence.isManagedTrial()).to.be.false;
		});

	});

	describe('isProspectTrial', () => {

		it('returns TRUE if licence type is b2b-marketing-initiative', () => {
			licenceData.types = ['b2b-marketing-initiative'];
			const licence = new Licence(licenceData);
			expect(licence.isProspectTrial()).to.be.true;
		});

		it('returns FALSE if licence type is NOT b2b-marketing-initiative', () => {
			const licence = new Licence(licenceData);
			expect(licence.isProspectTrial()).to.be.false;
		});

	});

	describe('isCompanyLicence', () => {

		it('returns TRUE if licence type is contract', () => {
			licenceData.types = ['contract'];
			const licence = new Licence(licenceData);
			expect(licence.isCompanyLicence()).to.be.true;
		});

		it('returns TRUE if licence type is newspaper-bundle', () => {
			licenceData.types = ['newspaper-bundle'];
			const licence = new Licence(licenceData);
			expect(licence.isCompanyLicence()).to.be.true;
		});

		it('returns TRUE if licence type is complimentary', () => {
			licenceData.types = ['complimentary'];
			const licence = new Licence(licenceData);
			expect(licence.isCompanyLicence()).to.be.true;
		});

		it('returns TRUE if licence type is business-development', () => {
			licenceData.types = ['business-development'];
			const licence = new Licence(licenceData);
			expect(licence.isCompanyLicence()).to.be.true;
		});

		it('returns TRUE if licence type is prospect', () => {
			licenceData.types = ['prospect'];
			const licence = new Licence(licenceData);
			expect(licence.isCompanyLicence()).to.be.true;
		});

		it('returns FALSE if licence type is NOT contract, newspaper-bundle, complimentary, business-development or prospect', () => {
			const licence = new Licence(licenceData);
			expect(licence.isCompanyLicence()).to.be.false;
		});

	});

	describe('isContractLicence', () => {

		it('returns TRUE if licence type is contract', () => {
			licenceData.types = ['contract'];
			const licence = new Licence(licenceData);
			expect(licence.isContractLicence()).to.be.true;
		});

		it('returns FALSE if licence type is NOT contract', () => {
			const licence = new Licence(licenceData);
			expect(licence.isContractLicence()).to.be.false;
		});

	});

	describe('isBundleLicence', () => {

		it('returns TRUE if licence type is newspaper-bundle', () => {
			licenceData.types = ['newspaper-bundle'];
			const licence = new Licence(licenceData);
			expect(licence.isBundleLicence()).to.be.true;
		});

		it('returns FALSE if licence type is NOT newspaper-bundle', () => {
			const licence = new Licence(licenceData);
			expect(licence.isBundleLicence()).to.be.false;
		});

	});

	describe('isComplimentaryLicence', () => {

		it('returns TRUE if licence type is complimentary', () => {
			licenceData.types = ['complimentary'];
			const licence = new Licence(licenceData);
			expect(licence.isComplimentaryLicence()).to.be.true;
		});

		it('returns FALSE if licence type is NOT complimentary', () => {
			const licence = new Licence(licenceData);
			expect(licence.isComplimentaryLicence()).to.be.false;
		});

	});

	describe('isBusinessDevelopmentLicence', () => {

		it('returns TRUE if licence type is business-development', () => {
			licenceData.types = ['business-development'];
			const licence = new Licence(licenceData);
			expect(licence.isBusinessDevelopmentLicence()).to.be.true;
		});

		it('returns FALSE if licence type is NOT business-development', () => {
			const licence = new Licence(licenceData);
			expect(licence.isBusinessDevelopmentLicence()).to.be.false;
		});

	});

	describe('isProspectLicence', () => {

		it('returns TRUE if licence type is prospect', () => {
			licenceData.types = ['prospect'];
			const licence = new Licence(licenceData);
			expect(licence.isProspectLicence()).to.be.true;
		});

		it('returns FALSE if licence type is NOT prospect', () => {
			const licence = new Licence(licenceData);
			expect(licence.isProspectLicence()).to.be.false;
		});

	});

	describe('isSubscriptionLicence', () => {

		it('returns TRUE if licence type is subscription', () => {
			licenceData.types = ['subscription'];
			const licence = new Licence(licenceData);
			expect(licence.isSubscriptionLicence()).to.be.true;
		});

		it('returns FALSE if licence type is NOT subscription', () => {
			const licence = new Licence(licenceData);
			expect(licence.isSubscriptionLicence()).to.be.false;
		});

	});

	describe('isB2cPartnershipLicence', () => {

		it('returns TRUE if licence type is b2c-partnership', () => {
			licenceData.types = ['b2c-partnership'];
			const licence = new Licence(licenceData);
			expect(licence.isB2cPartnershipLicence()).to.be.true;
		});

		it('returns FALSE if licence type is NOT b2c-partnership', () => {
			const licence = new Licence(licenceData);
			expect(licence.isB2cPartnershipLicence()).to.be.false;
		});

	});

	describe('isLongRoomLicence', () => {

		it('returns TRUE if licence type is longroom', () => {
			licenceData.types = ['longroom'];
			const licence = new Licence(licenceData);
			expect(licence.isLongRoomLicence()).to.be.true;
		});

		it('returns FALSE if licence type is NOT longroom', () => {
			const licence = new Licence(licenceData);
			expect(licence.isLongRoomLicence()).to.be.false;
		});

	});

	describe('isDeveloperPortalLicence', () => {

		it('returns TRUE if licence type is developer-portal', () => {
			licenceData.types = ['developer-portal'];
			const licence = new Licence(licenceData);
			expect(licence.isDeveloperPortalLicence()).to.be.true;
		});

		it('returns FALSE if licence type is NOT developer-portal', () => {
			const licence = new Licence(licenceData);
			expect(licence.isDeveloperPortalLicence()).to.be.false;
		});

	});

	describe('getAcquisitionContext', () => {
		it('should throw acquisition context is not an array', () => {
			licenceData.acquisitionContext = undefined;
			const licence = new Licence(licenceData);
			expect(() => {
				licence.getAcquisitionContext();
			}).to.throw();
		});

		it('should throw if there are no acquisitions contexts', () => {
			licenceData.acquisitionContext = [];
			const licence = new Licence(licenceData);
			expect(() => {
				licence.getAcquisitionContext();
			}).to.throw();
		});

		it('should return the first context in the array', () => {
			const first = {};
			const second = {};
			licenceData.acquisitionContext = [first, second];
			const licence = new Licence(licenceData);
			expect(licence.getAcquisitionContext()).to.equal(first);
		});
	});

	describe('isAllowedEmailDomain', () => {

		it('returns TRUE if email domain is allowed', () => {
			licenceData.acquisitionContext[0].isAllowedEmailDomain = () => true;
			const licence = new Licence(licenceData);
			expect(licence.isAllowedEmailDomain('email@email.email')).to.be.true;
		});

		it('returns FALSE if email domain is not allowed', () => {
			licenceData.acquisitionContext[0].isAllowedEmailDomain = () => false;
			const invalidLicence = new Licence(licenceData);
			expect(invalidLicence.isAllowedEmailDomain('email@email.email')).to.be.false;
		});

	});

	describe('isBlockedEmailDomain', () => {

		it('returns TRUE if email domain is blocked', () => {
			licenceData.acquisitionContext[0].isBlockedEmailDomain = () => true;
			const licence = new Licence(licenceData);
			expect(licence.isBlockedEmailDomain('email@email.email')).to.be.true;
		});

		it('returns FALSE if email domain is not blockec', () => {
			licenceData.acquisitionContext[0].isBlockedEmailDomain = () => false;
			const invalidLicence = new Licence(licenceData);
			expect(invalidLicence.isBlockedEmailDomain('email@email.email')).to.be.false;
		});

	});

	describe('isMarketingCampaign', () => {

		it('returns TRUE if marketing campaign', () => {
			licenceData.acquisitionContext[0].isMarketingCampaign = () => true;
			const licence = new Licence(licenceData);
			expect(licence.isMarketingCampaign()).to.be.true;
		});

		it('returns FALSE if not marketing campaign', () => {
			licenceData.acquisitionContext[0].isMarketingCampaign = () => false;
			const invalidLicence = new Licence(licenceData);
			expect(invalidLicence.isMarketingCampaign()).to.be.false;
		});
	});

	describe('isSeatAvailable', () => {

		it('returns TRUE if there is a seat available', () => {
			const licence = new Licence(licenceData);
			licence.seatLimit = 5;
			licence.allocatedSeats = 4;
			expect(licence.isSeatAvailable()).to.be.true;
		});

		it('returns TRUE by default if seatLimit and allocatedSeats are null', () => {
			const licence = new Licence(licenceData);
			licence.seatLimit = undefined;
			licence.allocatedSeats = undefined;
			expect(licence.isSeatAvailable()).to.be.true;
		});

		it('returns FALSE if a seat is not available', () => {
			const invalidLicence = new Licence(licenceData);
			invalidLicence.allocatedSeats = 5;
			invalidLicence.seatLimit = 5;
			expect(invalidLicence.isSeatAvailable()).to.be.false;
		});

	});

	context('allocate seat on licence', () => {
		let allocateSeat: any;

		beforeEach(() => {
			const licenceData = {
				id: 'id',
				userId: 'userId',
				joinedDate: '2019-06-11T13:33:08.641Z',
				seatExpiryDate: undefined
			};

			allocateSeat = new Licence(licenceData);
		});

		it('userId', () => {
			expect(allocateSeat.userId).to.equal('userId');
		});

		it('joinedDate', () => {
			expect(allocateSeat.joinedDate).to.equal('2019-06-11T13:33:08.641Z');
		});

		it('seatExpiryDate', () => {
			expect(allocateSeat.seatExpiryDate).to.equal(undefined);
		});

	});

	describe('isUserAnAdminstrator', () => {
		it('returns true if user is an administrator on the current licence', () => {
			expect(licence.isUserAnAdminstrator('userId')).to.be.true;
		});

		it('returns FALSE if user is not an administrator on the current licence', () => {
			expect(licence.isUserAnAdminstrator('anotherUserId')).to.be.false;
		});

		it('returns FALSE if the user\'s administrator licence is not this licence', () => {
			licenceData.administrators.push({ userId: 'userId', licenceId: 'anotherlicenceId' });
			expect(licence.isUserAnAdminstrator('anotherUserId')).to.be.false;
		});
	});
});