import { expect } from 'chai';
import { AcquisitionContext } from '../../../src/models/acquisition-context';

describe('Acquisition Context', () => {
	let acquisitionContext: any;
	let acquisitionContextData: any;

	beforeEach(() => {
		acquisitionContextData = {
			displayName: 'Display Name',
			name: 'Name',
			hasRestrictIpRanges: true,
			accessLicenceId: 'lienceId',
			hasRestrictEmailDomains: true,
			allowedEmailDomains: ['ExamPle.com', 'Example_2.com'],
			hasRestrictBlockedEmailDomains: true,
			blockedEmailDomains: ['BLOCKED.com'],
			signupWelcomeText: 'Welcome to your free trial'
		};
	});

	context('initialises with licence data', () => {

		beforeEach(() => {
			acquisitionContext = new AcquisitionContext(acquisitionContextData);
		});

		it('setting this.displayName', () => {
			const expectedResult = acquisitionContextData.displayName;
			expect(acquisitionContext.displayName).to.equal(expectedResult);
		});

		it('setting this.name', () => {
			const expectedResult = acquisitionContextData.name;
			expect(acquisitionContext.name).to.equal(expectedResult);
		});

		it('setting this.hasRestrictIpRanges', () => {
			expect(acquisitionContext.hasRestrictIpRanges).to.be.true;
		});

		it('setting this.accessLicenceId', () => {
			const expectedResult = acquisitionContext.accessLicenceId;
			expect(acquisitionContext.accessLicenceId).to.equal(expectedResult);
		});

		it('setting this.hasRestrictEmailDomains', () => {
			expect(acquisitionContext.hasRestrictEmailDomains).to.be.true;
		});

		it('setting this.allowedEmailDomains', () => {
			const expectedResult = acquisitionContextData.allowedEmailDomains;
			expect(acquisitionContext.allowedEmailDomains).to.eql(expectedResult);
		});

		it('setting this.hasRestrictBlockedEmailDomains ', () => {
			expect(acquisitionContext.hasRestrictBlockedEmailDomains).to.be.true;
		});

		it('setting this.blockedEmailDomains', () => {
			const expectedResult = acquisitionContextData.blockedEmailDomains;
			expect(acquisitionContext.blockedEmailDomains).to.eql(expectedResult);
		});

		it('setting this.signupWelcomeText', () => {
			const expectedResult = acquisitionContextData.signupWelcomeText;
			expect(acquisitionContext.signupWelcomeText).to.eql(expectedResult);
		});

	});

	describe('isAllowedEmailDomain', () => {

		beforeEach(() => {
			acquisitionContextData.hasRestrictEmailDomains = true;
			acquisitionContextData.allowedEmailDomains = [
				'*.zExaMPle.uk',	// working wildcard subdomain prefix
				'pre.*.com',		// invalid domain wildcard
				'ExamPle.com',
				'Example_2.com'
			];
			acquisitionContext = new AcquisitionContext(acquisitionContextData);
		});

		it('returns true when there is not a resistricted email domains array', () => {
			acquisitionContextData.hasRestrictEmailDomains = false;
			const acquisitionContext = new AcquisitionContext(acquisitionContextData);
			const email = 'email@another-example.com';
			expect(acquisitionContext.isAllowedEmailDomain(email)).to.be.true;
		});

		it('returns TRUE', () => {
			const email = 'email@example.com';
			expect(acquisitionContext.isAllowedEmailDomain(email)).to.be.true;
		});

		it('returns TRUE if email matches a wildcard domain', () => {
			const email = 'email@teST.ZEXAMPLE.UK';
			expect(acquisitionContext.isAllowedEmailDomain(email)).to.be.true;
		});

		it('should not use wildcard characters mid hostname - only as a subdomain prefix', () => {
			const email = 'email@pre.test.com';
			expect(acquisitionContext.isAllowedEmailDomain(email)).to.be.false;
		});

		it('should escape dot char in host name', () => {
			const email = 'email@example-com';
			expect(acquisitionContext.isAllowedEmailDomain(email)).to.be.false;
		});

		it('returns FALSE', () => {
			const email = 'email@another-example.com';
			expect(acquisitionContext.isAllowedEmailDomain(email)).to.be.false;
		});

		it('returns FALSE if allowedEmailDomains is an empty array', () => {
			const email = 'email@another-example.com';
			acquisitionContext.allowedEmailDomains = [];
			expect(acquisitionContext.isAllowedEmailDomain(email)).to.be.false;
		});

		it('throws an error when allowedEmailDomains is undefined', () => {
			const email = 'email@example.com';
			acquisitionContext.allowedEmailDomains = undefined;
			expect(() => acquisitionContext.isAllowedEmailDomain(email)).to.throw('allowedEmailDomains is undefined');
		});

		it('throws an error when allowedEmailDomains and hasRestrictEmailDomains is undefined', () => {
			const email = 'email@example.com';
			acquisitionContextData.hasRestrictEmailDomains = undefined;
			acquisitionContext.allowedEmailDomains = undefined;
			expect(() => acquisitionContext.isAllowedEmailDomain(email)).to.throw('allowedEmailDomains is undefined');
		});

	});

	describe('isBlockedEmailDomain', () => {

		beforeEach(() => {
			acquisitionContextData.hasRestrictBlockedEmailDomains = true;
			acquisitionContextData.blockedEmailDomains = ['BLOCKED.com'];
			acquisitionContext = new AcquisitionContext(acquisitionContextData);
		});

		it('returns true when there is not a resistricted and blocked email domains array', () => {
			acquisitionContextData.hasRestrictBlockedEmailDomains = false;
			const acquisitionContext = new AcquisitionContext(acquisitionContextData);
			const email = 'email@blocked.com';
			expect(acquisitionContext.isBlockedEmailDomain(email)).to.be.false;
		});

		it('returns TRUE', () => {
			const email = 'email@blocked.com';
			expect(acquisitionContext.isBlockedEmailDomain(email)).to.be.true;
		});

		it('returns FALSE', () => {
			const email = 'email@example.com';
			expect(acquisitionContext.isBlockedEmailDomain(email)).to.be.false;
		});

		it('returns FALSE if blockedEmailDomains is an empty array', () => {
			const email = 'email@example.com';
			acquisitionContext.blockedEmailDomains = [];
			expect(acquisitionContext.isBlockedEmailDomain(email)).to.be.false;
		});

		it('throws an error if blockedEmailDomains is undefined', () => {
			const email = 'email@example.com';
			acquisitionContext.blockedEmailDomains = undefined;
			expect(() => acquisitionContext.isBlockedEmailDomain(email)).to.throw(
				'blockedEmailDomains is undefined'
			);
		});

		it('throws an error if blockedEmailDomains and hasRestrictBlockedEmailDomains is undefined', () => {
			const email = 'email@example.com';
			acquisitionContextData.hasRestrictBlockedEmailDomains = undefined;
			acquisitionContext.blockedEmailDomains = undefined;
			expect(() => acquisitionContext.isBlockedEmailDomain(email)).to.throw(
				'blockedEmailDomains is undefined'
			);
		});

	});

	describe('isMarketingCampaign', () => {
		let acquisitionContext: any;

		beforeEach(() => {
			acquisitionContextData.name = 'Display Name';
			acquisitionContext = new AcquisitionContext(acquisitionContextData);
		});

		it('returns TRUE if acquisition context data name is Marketing Campaigns Account', () => {
			acquisitionContextData.name = 'Marketing Campaigns Account';
			acquisitionContext = new AcquisitionContext(acquisitionContextData);
			expect(acquisitionContext.isMarketingCampaign()).to.be.true;
		});

		it('returns FALSE if name is NOT Marketing Campaigns Account', () => {
			expect(acquisitionContext.isMarketingCampaign()).to.be.false;
		});

	});

	describe('getDomain', () => {

		it('returns email domain', () => {
			const email = 'email@example.com';
			expect(acquisitionContext.getDomain(email)).to.equal('example.com');
		});

		it('returns empty string when email is invalid', () => {
			const email = 'email';
			expect(acquisitionContext.getDomain(email)).to.equal('');
		});

	});

});