// @ts-nocheck

import { expect } from 'chai';
import { UserSubscription } from '../../../src/models/user-subscription';
import { EMAIL_NEWSLETTER_DIGITAL_PRODUCT_CODES, PRINT_PRODUCT_CODES, STANDARD_AND_PREMIUM_DIGITAL_PRODUCT_CODES } from '../../../src/static-data/product-codes';

describe('User Subscription', () => {
	let mockData;

	beforeEach(() => {
		mockData = {
			status: 'Active',
			fulfilmentOption: 'HD',
			productCodes: ['n6d', 'p2'],
			productName: 'productName',
			productType: 'DIGITAL',
			reference: 'subscriptionNumber',
			renewalDate: '2020-08-16T00:00:00.000Z',
			trialEndDate: '2020-08-17T00:00:00.000Z',
			trialPrice: {
				currency: 'GBR',
				nativeSymbol: '£',
				symbol: '£',
				value: '500.00'
			},
			price: {
				currency: 'GBR',
				nativeSymbol: '£',
				symbol: '£',
				value: '500.00'
			},
			isOutOfTerm: false,
			isSingleTerm: false,
			source: 'ZuoraMock',
			offer: {
				offerId: "6c7b7f36-",
				discount: null
			},
			stepUp: {
				isInStepUp: false,
				priceBeforeStepUp: "39.00",
				priceAfterStepUp: null
			}
		};
	});

	describe('initialize', () => {
		let instance;

		beforeEach(() => {
			instance = new UserSubscription(mockData);
		});

		it('returns the subscription status', () => {
			expect(instance.status).to.equal(mockData.status);
		});

		it('returns the subscription fulfilmentOption', () => {
			expect(instance.fulfilmentOption).to.equal(mockData.fulfilmentOption);
		});

		it('returns upper case productCodes in an array', () => {
			expect(instance.productCodes).to.eql(['N6D', 'P2']);
		});

		it('returns the subscription productName', () => {
			expect(instance.productName).to.equal(mockData.productName);
		});

		it('returns the subscription productType', () => {
			expect(instance.productType).to.equal(mockData.productType);
		});

		it('returns subscription number for reference', () => {
			expect(instance.number).to.equal(mockData.reference);
		});

		it('returns the subscription startDate', () => {
			expect(instance.startDate).to.equal(mockData.startDate);
		});

		it('returns the subscription renewalDate', () => {
			expect(instance.renewalDate).to.equal(mockData.renewalDate);
		});

		it('returns the subscription trialEndDate', () => {
			expect(instance.trialEndDate).to.equal(mockData.trialEndDate);
		});

		it('returns the subscription trialPrice object', () => {
			expect(instance.trialPrice).to.equal(mockData.trialPrice);
		});

		it('returns the subscription price object', () => {
			expect(instance.price).to.equal(mockData.price);
		});

		it('returns the subscription isOutOfTerm status', () => {
			expect(instance.isOutOfTerm).to.equal(mockData.isOutOfTerm);
		});

		it('returns the subscription isSingleTerm status', () => {
			expect(instance.isSingleTerm).to.equal(mockData.isSingleTerm);
		});

		it('returns the subscription source', () => {
			expect(instance.source).to.equal(mockData.source);
		});

		it('returns the subscription associated offer object', () => {
			expect(instance.offer).to.deep.equal(mockData.offer);
		});

		it('returns the subscription stepUp object', () => {
			expect(instance.stepUp).to.deep.equal(mockData.stepUp);
		});

		describe('when no offer or stepUp data is passed', () => {
			let instance;

			beforeEach(() => {
				const newMockData = JSON.parse(JSON.stringify(mockData))
				delete newMockData.stepUp
				delete newMockData.offer

				instance = new UserSubscription(newMockData);
			});

			it('returns undefined for the subscription associated offer object', () => {
				expect(instance.offer).to.equal(undefined);
			});

			it('returns undefined for the subscription stepUp object', () => {
				expect(instance.stepUp).to.equal(undefined);
			});
		})
	});

	context('product types', () => {
		describe('isDigitalProduct', () => {
			it('returns TRUE when productCodes contains a P1 product code', () => {
				mockData.productCodes = ['P1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isDigitalProduct).to.be.true;
			});

			it('returns TRUE when productCodes contains a P2 product code', () => {
				mockData.productCodes = ['P2'];
				const instance = new UserSubscription(mockData);
				expect(instance.isDigitalProduct).to.be.true;
			});

			it('returns TRUE when productCodes contains a P22 product code', () => {
				mockData.productCodes = ['P22'];
				const instance = new UserSubscription(mockData);
				expect(instance.isDigitalProduct).to.be.true;
			});

			it('returns TRUE when productCodes contains an NS1 product code', () => {
				mockData.productCodes = ['NS1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isDigitalProduct).to.be.true;
			});

			it('returns TRUE when productCodes contains an NP1 product code', () => {
				mockData.productCodes = ['NP1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isDigitalProduct).to.be.true;
			});

			it('returns TRUE when productCodes contains an PNWU1 product code', () => {
				mockData.productCodes = ['PNWU1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isDigitalProduct).to.be.true;
			});

			it('returns FALSE when productCodes also contains a print code', () => {
				mockData.productCodes = ['N6D', 'P1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isDigitalProduct).to.be.false;
			});

			it('returns FALSE when productCodes does NOT contain a digital product code', () => {
				mockData.productCodes = ['NWE'];
				const instance = new UserSubscription(mockData);
				expect(instance.isDigitalProduct).to.be.false;
			});
		});

		describe('isStandardProduct', () => {
			it('returns TRUE when productCodes contains P1 code', () => {
				mockData.productCodes = ['P1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isStandardProduct).to.be.true;
			});

			it('returns TRUE when productCodes contains P1 and a print product code', () => {
				mockData.productCodes = ['N6D', 'P1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isStandardProduct).to.be.true;
			});

			it('returns FALSE when productCodes does NOT contain a P1 code', () => {
				mockData.productCodes = ['P2'];
				const instance = new UserSubscription(mockData);
				expect(instance.isStandardProduct).to.be.false;
			});
		});

		describe('isPremiumProduct', () => {
			it('returns TRUE when productCodes contains P2 code', () => {
				const instance = new UserSubscription(mockData);
				expect(instance.isPremiumProduct).to.be.true;
			});

			it('returns TRUE when productCodes contains P2 and a print product code', () => {
				mockData.productCodes = ['N6D', 'P2'];
				const instance = new UserSubscription(mockData);
				expect(instance.isPremiumProduct).to.be.true;
			});

			it('returns FALSE when productCodes does NOT contain a P2 code', () => {
				mockData.productCodes = ['P1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isPremiumProduct).to.be.false;
			});
		});

		describe('isPrintProduct', () => {
			it('returns TRUE when productCodes contains N6D print product code', () => {
				mockData.productCodes = ['N6D'];
				const instance = new UserSubscription(mockData);
				expect(instance.isPrintProduct).to.be.true;
			});

			it('returns TRUE when productCodes contains N5D print product code', () => {
				mockData.productCodes = ['N5D'];
				const instance = new UserSubscription(mockData);
				expect(instance.isPrintProduct).to.be.true;
			});

			it('returns TRUE when productCodes contains NWE print product code', () => {
				mockData.productCodes = ['NWE'];
				const instance = new UserSubscription(mockData);
				expect(instance.isPrintProduct).to.be.true;
			});

			it('returns FALSE when productCodes contains print and digital product code', () => {
				mockData.productCodes = ['N6D', 'P1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isPrintProduct).to.be.false;
			});

			it('returns FALSE when productCodes contains only a digital product code', () => {
				mockData.productCodes = ['P2'];
				const instance = new UserSubscription(mockData);
				expect(instance.isPrintProduct).to.be.false;
			});
		});

		describe('isEpaperProduct', () => {
			it('returns TRUE when productCodes contains EP product code', () => {
				mockData.productCodes = ['EP'];
				const instance = new UserSubscription(mockData);
				expect(instance.isEpaperProduct).to.be.true;
			});

			it('returns TRUE even when productCodes contains another product code', () => {
				mockData.productCodes = ['EP', 'P2'];
				const instance = new UserSubscription(mockData);
				expect(instance.isEpaperProduct).to.be.true;
			});

			it('returns FALSE when productCodes does not contain the EP product code', () => {
				mockData.productCodes = ['P2'];
				const instance = new UserSubscription(mockData);
				expect(instance.isEpaperProduct).to.be.false;
			});
		});

		describe('isWeekendOnlyProduct', () => {
			it('returns TRUE when it is only a weekend product', () => {
				mockData.productCodes = ['NWE', 'P2'];
				const instance = new UserSubscription(mockData);
				expect(instance.isWeekendOnlyProduct).to.be.true;
			});

			it('returns FALSE when it is a weekday and weekend product code', () => {
				mockData.productCodes = ['N6D'];
				const instance = new UserSubscription(mockData);
				expect(instance.isWeekendOnlyProduct).to.be.false;
			});

			it('returns FALSE when it is only a weekday product', () => {
				mockData.productCodes = ['N5D', 'P2'];
				const instance = new UserSubscription(mockData);
				expect(instance.isWeekendOnlyProduct).to.be.false;
			});

			it('returns FALSE when it is only a digital product', () => {
				mockData.productCodes = ['P1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isWeekendOnlyProduct).to.be.false;
			});
		});

		describe('isWeekdayOnlyProduct', () => {
			it('returns TRUE when it is only a weekday product', () => {
				mockData.productCodes = ['N5D', 'P2'];
				const instance = new UserSubscription(mockData);
				expect(instance.isWeekdayOnlyProduct).to.be.true;
			});

			it('returns FALSE when it is a weekday and weekend product code', () => {
				mockData.productCodes = ['N6D'];
				const instance = new UserSubscription(mockData);
				expect(instance.isWeekdayOnlyProduct).to.be.false;
			});

			it('returns FALSE when it is only a weekend product', () => {
				mockData.productCodes = ['NWE', 'P2'];
				const instance = new UserSubscription(mockData);
				expect(instance.isWeekdayOnlyProduct).to.be.false;
			});

			it('returns FALSE when it is only a digital product', () => {
				mockData.productCodes = ['P1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isWeekdayOnlyProduct).to.be.false;
			});
		});

		describe('isWeekdayWeekendProduct', () => {
			it('returns TRUE when it a weekday and weekend product', () => {
				const instance = new UserSubscription(mockData);
				expect(instance.isWeekdayWeekendProduct).to.be.true;
			});

			it('returns FALSE when it is only a weekend product', () => {
				mockData.productCodes = ['NWE'];
				const instance = new UserSubscription(mockData);
				expect(instance.isWeekdayWeekendProduct).to.be.false;
			});

			it('returns FALSE when it is only a weekday product', () => {
				mockData.productCodes = ['N5D', 'P1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isWeekdayWeekendProduct).to.be.false;
			});

			it('returns FALSE when it is only a digital product', () => {
				mockData.productCodes = ['P1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isWeekdayWeekendProduct).to.be.false;
			});
		});

		describe('isPrintTypeProduct', () => {
			it('returns TRUE when products codes only contains print product code', () => {
				mockData.productCodes = ['N5D'];
				const instance = new UserSubscription(mockData);
				expect(instance.isPrintTypeProduct).to.be.true;
			});

			it('returns TRUE when products codes contains a print and digital product code', () => {
				const instance = new UserSubscription(mockData);
				expect(instance.isPrintTypeProduct).to.be.true;
			});

			it('returns FALSE when products codes contains only a digital product code', () => {
				mockData.productCodes = ['P1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isPrintTypeProduct).to.be.false;
			});
		});

		describe('isDigitalTypeProduct', () => {
			it('returns TRUE when products codes only contains digital product code (P1)', () => {
				mockData.productCodes = ['P1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isDigitalTypeProduct).to.be.true;
			});

			it('returns TRUE when products codes only contains digital product code (P2)', () => {
				mockData.productCodes = ['P2'];
				const instance = new UserSubscription(mockData);
				expect(instance.isDigitalTypeProduct).to.be.true;
			});

			it('returns TRUE when products codes only contains digital product code (P22)', () => {
				mockData.productCodes = ['P22'];
				const instance = new UserSubscription(mockData);
				expect(instance.isDigitalTypeProduct).to.be.true;
			});

			it('returns TRUE when products codes contains a print and digital product code', () => {
				const instance = new UserSubscription(mockData);
				expect(instance.isDigitalTypeProduct).to.be.true;
			});

			it('returns TRUE when products codes only contains digital product code for Inside Politics niche email newsletter', () => {
				mockData.productCodes = ['NS1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isDigitalTypeProduct).to.be.true;
			});

			it('returns TRUE when products codes only contains digital product code for Unhedged niche email newsletter', () => {
				mockData.productCodes = ['NP1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isDigitalTypeProduct).to.be.true;
			});

			it('returns TRUE when products codes only contains digital product code for FT Newsletters trial', () => {
				mockData.productCodes = ['PNWU1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isDigitalTypeProduct).to.be.true;
			});

			it('returns FALSE when products codes contains only a print product code', () => {
				mockData.productCodes = ['N6D'];
				const instance = new UserSubscription(mockData);
				expect(instance.isDigitalTypeProduct).to.be.false;
			});
		});

		describe('isBundleProduct', () => {
			it('returns TRUE when productCodes contains print and Standard/Premium FT.com digital product code', () => {
				const instance = new UserSubscription(mockData);
				expect(instance.isBundleProduct).to.be.true;
			});

			it('returns TRUE when productCodes contains print and Standard/Premium FT.com digital product code (P1)', () => {
				mockData.productCodes = ['N6D', 'P1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isBundleProduct).to.be.true;
			});

			it('returns TRUE when productCodes contains print and Standard/Premium FT.com digital product code (P22)', () => {
				mockData.productCodes = ['N6D', 'P22'];
				const instance = new UserSubscription(mockData);
				expect(instance.isBundleProduct).to.be.true;
			});

			it('returns FALSE when productCodes contains print and a digital product code that cannot be included in a bundle (Inside Politics niche email newsletter - NS1)', () => {
				mockData.productCodes = ['N6D', 'NS1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isBundleProduct).to.be.false;
			});

			it('returns FALSE when productCodes contains print and a digital product code that cannot be included in a bundle (Unhedged niche email newsletter - NP1)', () => {
				mockData.productCodes = ['N6D', 'NP1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isBundleProduct).to.be.false;
			});

			it('returns FALSE when productCodes contains print and a digital product code that cannot be included in a bundle (FT Newsletters trial - PNWU1)', () => {
				mockData.productCodes = ['N6D', 'PNWU1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isBundleProduct).to.be.false;
			});

			it('returns FALSE when productCodes contains only a print product code', () => {
				mockData.productCodes = ['N6D'];
				const instance = new UserSubscription(mockData);
				expect(instance.isBundleProduct).to.be.false;
			});

			it('returns FALSE when productCodes contains only a digital product code', () => {
				mockData.productCodes = ['P2'];
				const instance = new UserSubscription(mockData);
				expect(instance.isBundleProduct).to.be.false;
			});
		});

		describe('isEpaperBundleProduct', () => {
			it('returns FALSE when productCodes contains print and Standard/Premium FT.com digital product code', () => {
				const instance = new UserSubscription(mockData);
				expect(instance.isEpaperBundleProduct).to.be.false;
			});

			it('returns FALSE when productCodes contains print and Standard/Premium FT.com digital product code (P1)', () => {
				mockData.productCodes = ['N6D', 'P1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isEpaperBundleProduct).to.be.false;
			});

			it('returns FALSE when productCodes contains print and Standard/Premium FT.com digital product code (P22)', () => {
				mockData.productCodes = ['N6D', 'P22'];
				const instance = new UserSubscription(mockData);
				expect(instance.isEpaperBundleProduct).to.be.false;
			});

			it('returns FALSE when productCodes contains print and a digital product code that cannot be included in a bundle (Inside Politics niche email newsletter - NS1)', () => {
				mockData.productCodes = ['N6D', 'NS1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isEpaperBundleProduct).to.be.false;
			});

			it('returns FALSE when productCodes contains print and a digital product code that cannot be included in a bundle (Unhedged niche email newsletter - NP1)', () => {
				mockData.productCodes = ['N6D', 'NP1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isEpaperBundleProduct).to.be.false;
			});

			it('returns FALSE when productCodes contains print and a digital product code that cannot be included in a bundle (FT Newsletters trial - PNWU1)', () => {
				mockData.productCodes = ['N6D', 'PNWU1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isEpaperBundleProduct).to.be.false;
			});

			it('returns FALSE when productCodes contains only a print product code', () => {
				mockData.productCodes = ['N6D'];
				const instance = new UserSubscription(mockData);
				expect(instance.isEpaperBundleProduct).to.be.false;
			});

			it('returns FALSE when productCodes contains only a digital product code', () => {
				mockData.productCodes = ['P2'];
				const instance = new UserSubscription(mockData);
				expect(instance.isEpaperBundleProduct).to.be.false;
			});

			it('returns FALSE when productCodes contains only an epaper code', () => {
				mockData.productCodes = ['EP'];
				const instance = new UserSubscription(mockData);
				expect(instance.isEpaperBundleProduct).to.be.false;
			});

			it('returns FALSE when productCodes contains an epaper and digital product code (P1)', () => {
				mockData.productCodes = ['EP', 'P1'];
				const instance = new UserSubscription(mockData);
				expect(instance.isEpaperBundleProduct).to.be.false;
			});

			it('returns TRUE when productCodes contains print (N6D) and epaper product code', () => {
				mockData.productCodes = ['N6D', 'EP'];
				const instance = new UserSubscription(mockData);
				expect(instance.isEpaperBundleProduct).to.be.true;
			});
			it('returns TRUE when productCodes contains print (N5D) and epaper product code', () => {
				mockData.productCodes = ['N5D', 'EP'];
				const instance = new UserSubscription(mockData);
				expect(instance.isEpaperBundleProduct).to.be.true;
			});
			it('returns TRUE when productCodes contains print (NWE) and epaper product code', () => {
				mockData.productCodes = ['NWE', 'EP'];
				const instance = new UserSubscription(mockData);
				expect(instance.isEpaperBundleProduct).to.be.true;
			});
		});

		describe('isNewsletterOnlyProduct', () => {
			EMAIL_NEWSLETTER_DIGITAL_PRODUCT_CODES.forEach(productCode => {
				it(`returns TRUE when products code is ${productCode}`, () => {
					mockData.productCodes = [productCode];
					const instance = new UserSubscription(mockData);
					expect(instance.isNewsletterOnlyProduct).to.be.true;
				});
			});

			STANDARD_AND_PREMIUM_DIGITAL_PRODUCT_CODES.forEach(productCode => {
				it(`returns FALSE when products code is ${productCode}`, () => {
					mockData.productCodes = [productCode];
					const instance = new UserSubscription(mockData);
					expect(instance.isNewsletterOnlyProduct).to.be.false;
				});
				
			});
		});
	});

	context('fulfilment options', () => {
		describe('isHomeDelivery', () => {
			it('returns TRUE when the subscription fulfilment option is HD', () => {
				const instance = new UserSubscription(mockData);
				expect(instance.isHomeDelivery).to.be.true;
			});

			it('returns FALSE when the subscription fulfilment option is NOT HD', () => {
				mockData.fulfilmentOption = 'PV';
				const instance = new UserSubscription(mockData);
				expect(instance.isHomeDelivery).to.be.false;
			});

			it('returns FALSE when the subscription is NOT a print product', () => {
				mockData.productCodes = ['P2'];
				mockData.fulfilmentOption = null;
				const instance = new UserSubscription(mockData);
				expect(instance.isHomeDelivery).to.be.false;
			});
		});

		describe('isPaperVoucher', () => {
			it('returns TRUE when the subscription fulfilment option is PV', () => {
				mockData.fulfilmentOption = 'PV';
				const instance = new UserSubscription(mockData);
				expect(instance.isPaperVoucher).to.be.true;
			});

			it('returns FALSE when the subscription fulfilment option is NOT PV', () => {
				const instance = new UserSubscription(mockData);
				expect(instance.isPaperVoucher).to.be.false;
			});

			it('returns FALSE when the subscription is NOT a print product', () => {
				mockData.productCodes = ['P2'];
				mockData.fulfilmentOption = null;
				const instance = new UserSubscription(mockData);
				expect(instance.isHomeDelivery).to.be.false;
			});
		});
	});

	describe('getPrintProductCode', () => {
		it('returns a the print product code when the product is a bundle', () => {
			const instance = new UserSubscription(mockData);
			expect(instance.getPrintProductCode).to.equal('N6D');
		});

		it('returns a the print product code when the product is print', () => {
			mockData.productCodes = ['N6D'];
			const instance = new UserSubscription(mockData);
			expect(instance.getPrintProductCode).to.equal('N6D');
		});

		it('returns null when the product is not print or bundle', () => {
			mockData.productCodes = ['P1'];
			const instance = new UserSubscription(mockData);
			expect(instance.getPrintProductCode).to.equal(undefined);
		});
	});

	describe('getDigitalProductCode', () => {
		it('returns a the digital product code when the product is a bundle', () => {
			const instance = new UserSubscription(mockData);
			expect(instance.getDigitalProductCode).to.equal('P2');
		});

		it('returns the digital product code when the product is digital (P1)', () => {
			mockData.productCodes = ['P1'];
			const instance = new UserSubscription(mockData);
			expect(instance.getDigitalProductCode).to.equal('P1');
		});

		it('returns the digital product code when the product is digital (P2)', () => {
			mockData.productCodes = ['P2'];
			const instance = new UserSubscription(mockData);
			expect(instance.getDigitalProductCode).to.equal('P2');
		});

		it('returns the digital product code when the product is digital (P22)', () => {
			mockData.productCodes = ['P22'];
			const instance = new UserSubscription(mockData);
			expect(instance.getDigitalProductCode).to.equal('P22');
		});

		it('returns a the digital product code when the product is Inside Politics niche email newsletter', () => {
			mockData.productCodes = ['NS1'];
			const instance = new UserSubscription(mockData);
			expect(instance.getDigitalProductCode).to.equal('NS1');
		});

		it('returns a the digital product code when the product is Unhedged niche email newsletter', () => {
			mockData.productCodes = ['NP1'];
			const instance = new UserSubscription(mockData);
			expect(instance.getDigitalProductCode).to.equal('NP1');
		});

		it('returns a the digital product code when the product is FT Newsletters trial', () => {
			mockData.productCodes = ['PNWU1'];
			const instance = new UserSubscription(mockData);
			expect(instance.getDigitalProductCode).to.equal('PNWU1');
		});

		it('returns null when the product is not digital or bundle', () => {
			mockData.productCodes = ['NWE'];
			const instance = new UserSubscription(mockData);
			expect(instance.getDigitalProductCode).to.equal(undefined);
		});
	});
});