// @ts-nocheck

import { expect } from 'chai';

import { User } from '../../../src/models/user';
import { UserSubscription } from '../../../src/models/user-subscription';
import { Licence } from '../../../src/models/licence';

describe('User', () => {
	let user;
	let userDetailsResponse;
	let getB2bUserResponse;

	beforeEach(() => {

		userDetailsResponse = {
			id: 'fakeId',
			profiles: {
				basic: {
					email: 'email@example.com',
					secondaryEmail: 'email@email.com',
					firstName: 'John',
					lastName: 'Doe',
					nonLogin: false,
					createDate: '2022-04-28T14:37:21.766Z',
					country: 'GBR'
				},
				restricted: {
					primaryTelephone: '12345678',
					homeAddress: {
						country: 'GBR',
						postcode: 'SE1 9HL'
					}
				},
				demographics: {
					industry: { code: 'PHC' },
					position: { code: 'AS' },
					responsibility: { code: 'BUY' }
				}
			},
			access: {
				isB2b: false,
				isB2c: false,
				isStaff: false,
				isSso: false,
				licences: [{
					id: 'id',
					details: {
						isB2c: true,
						isB2b: false,
						links: [{ rel: 'trial' }],
						seatLimit: 100,
						status: 'active',
						issueReason: 'Contract Signed',
						products: [{ name: 'FT.com Premium' }],
					},
					administrators: [{ userId: 'userId', licenceId: 'licenceId' }],
					seats: { allocated: 0 },
					seat: { joinedDate: 'date string' },
					acqContexts: [],
				}],
			},
			subscriber: {
				billingAccount: {
					currencyCode: 'GBP',
					isDeferredBilling: false,
					isExternal: false,
					paymentMethod: {
						type: 'CREDITCARD',
						lastTransactionStatus: 'Approved'
					}
				},
				status: {
					currentSubscriber: false,
					currentTriallist: false,
					subscriptions: [{
						status: 'Inactive',
						active: false,
						productCodes: ['p1']
					}, {
						renewalDate: '2012-02-16',
						status: 'Active',
						active: true,
						productCodes: ['p1']
					}, {
						status: 'Inactive',
						active: false,
						productCodes: ['p1']
					}]
				}
			},
			session: {
				sessionId: 'fakeSessionId'
			}
		};

		getB2bUserResponse = (jobTitle: string, graduationDate?: string) => ({
			...userDetailsResponse,
			profiles: {
				...userDetailsResponse?.profiles,
				b2b: {
					jobTitle,
					graduationDate
				}
			},
			access: {
				...userDetailsResponse?.access,
				isB2b: true
			}
		});

		user = new User(userDetailsResponse, false);
	});

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

		it('graphQl user details response', () => {
			expect(user.details).to.eql(userDetailsResponse);
		});

		it('user lastTransactionStatus', () => {
			expect(user.lastTransactionStatus).to.eql('Approved');
		});

		it('user profile details', () => {
			expect(user.profile).to.eql(userDetailsResponse.profiles);
		});

		it('user access details', () => {
			expect(user.access).to.eql(userDetailsResponse.access);
		});

		it('user access details licence includes joinedDate', () => {
			expect(user.access.licences[0].seat.joinedDate).to.eql('date string');
		});

		it('user subscription details', () => {
			expect(user.subscription).to.eql(userDetailsResponse.subscriber);
		});

		it('user isDeferredBilling field present', () => {
			expect(user.isDeferredBilling).to.eql(userDetailsResponse.subscriber.billingAccount.isDeferredBilling);
		});

		it('isRestricted user as TRUE', () => {
			const user = new User(userDetailsResponse, true);
			expect(user.isProfileRestricted).to.be.true;
		});

		it('isRestricted user as FALSE', () => {
			expect(user.isProfileRestricted).to.be.false;
		});

		it('user\'s id', () => {
			expect(user.id).to.eql('fakeId');
		});

		it('user\'s email', () => {
			expect(user.email).to.eql('email@example.com');
		});

		it('user\'s first name', () => {
			expect(user.firstName).to.eql('John');
		});

		it('user\'s last name', () => {
			expect(user.lastName).to.eql('Doe');
		});

		it('user\'s no logged', () => {
			expect(user.nonLogin).to.eql(false);
		});

		it('user\'s creation date', () => {
			expect(user.creationDate).to.eql('2022-04-28T14:37:21.766Z');
		});

		it('user\'s demographics', () => {
			expect(user.demographics).to.eql(userDetailsResponse.profiles.demographics);
		});

		it('user\'s industry demographics', () => {
			expect(user.industry).to.eql('PHC');
		});

		it('user\'s position demographics', () => {
			expect(user.position).to.eql('AS');
		});

		it('user\'s responsibility demographics', () => {
			expect(user.responsibility).to.eql('BUY');
		});

		it('FALSE when user does not have an active B2C subscription', () => {
			expect(user.isB2C).to.be.false;
		});

		it('TRUE when user has an active B2C subscription', () => {
			userDetailsResponse.access = { isB2c: true };
			const user = new User(userDetailsResponse, false);
			expect(user.isB2C).to.be.true;
		});

		it('FALSE when user does not have an active B2B licence', () => {
			expect(user.isB2B).to.be.false;
		});

		it('TRUE when user has an active B2B licence', () => {
			userDetailsResponse.access = { isB2b: true };
			const user = new User(userDetailsResponse, false);
			expect(user.isB2B).to.be.true;
		});

		it('FALSE when user has not signed up with SSO', () => {
			expect(user.isSSO).to.be.false;
		});

		it('TRUE when user has signes up with SSO', () => {
			userDetailsResponse.access = { isSso: true };
			const user = new User(userDetailsResponse, false);
			expect(user.isSSO).to.be.true;
		});

		it('FALSE when user is a member of FT staff', () => {
			expect(user.isStaff).to.be.false;
		});

		it('array of licence instances', () => {
			expect(user.licences).to.be.an.instanceof(Array);
			expect(user.licences[0]).to.be.an.instanceof(Licence);
		});

		it('user\'s payment method type', () => {
			expect(user.paymentMethod).to.eql('CREDITCARD');
		});

		it('user\'s billing currency code', () => {
			expect(user.billingCurrencyCode).to.eql('GBP');
		});

		it('user\'s billing country as an empty string', () => {
			expect(user.billingCountryCode).to.eql('');
		});

		it('user\'s billing state as an empty string', () => {
			expect(user.billingState).to.eql('');
		});

		it('user\'s billing postcode as an empty string', () => {
			expect(user.billingPostcode).to.eql('');
		});

		it('isRegisteredUserOnly as TRUE', () => {
			expect(user.isRegistered).to.be.true;
		});

		it('isRegisteredUser as FALSE', () => {
			userDetailsResponse.subscriber.status.currentSubscriber = true;
			const user = new User(userDetailsResponse, false);
			expect(user.isRegistered).to.be.false;
		});

		it('isTrialist as TRUE', () => {
			userDetailsResponse.subscriber.status.currentTriallist = true;
			const user = new User(userDetailsResponse, false);
			expect(user.isTrialist).to.be.true;
		});

		it('isTrialist as FALSE', () => {
			userDetailsResponse.subscriber.status.currentTriallist = false;
			const user = new User(userDetailsResponse, false);
			expect(user.isTrialist).to.be.false;
		});

		it('isPremium as TRUE', () => {
			userDetailsResponse.access.productCodes = ['P2'];
			const user = new User(userDetailsResponse, false);
			expect(user.isPremium).to.be.true;
		});

		it('isPremium as FALSE', () => {
			userDetailsResponse.access.productCodes = ['P1'];
			const user = new User(userDetailsResponse, false);
			expect(user.isPremium).to.be.false;
		});

		it('isEpaper as TRUE', () => {
			userDetailsResponse.access.productCodes = ['EP'];
			const user = new User(userDetailsResponse, false);
			expect(user.isEpaper).to.be.true;
		});

		it('isEpaper as FALSE', () => {
			userDetailsResponse.access.productCodes = ['P1'];
			const user = new User(userDetailsResponse, false);
			expect(user.isEpaper).to.be.false;
		});

		it('user\'s session id', () => {
			expect(user.sessionId).to.eql('fakeSessionId');
		});

		it('returns a user\'s subscription details', () => {
			expect(user.subscription).to.eql(userDetailsResponse.subscriber);
		});

		it('returns B2B user\'s  Job title', () => {
			const mockUserDetailsResponse = getB2bUserResponse('Faculty/Other');
			const user = new User(mockUserDetailsResponse, false);

			expect(user.jobTitle).to.eql(mockUserDetailsResponse.profiles.b2b.jobTitle);
			expect(user.graduationDate).to.be.undefined;
		});

		it('returns B2B user\'s graduation date', () => {
			const mockUserDetailsResponse = getB2bUserResponse('Student', '012020');
			const user = new User(mockUserDetailsResponse, false);

			expect(user.jobTitle).to.eql(mockUserDetailsResponse.profiles.b2b.jobTitle);
			expect(user.graduationDate).to.eql(mockUserDetailsResponse.profiles.b2b.graduationDate);
		});

	});

	context('primaryTelephone', () => {

		it('gets user\'s telephone number', () => {
			expect(user.primaryTelephone).to.eql('12345678');
		});

		it('sets user\'s telephone number', () => {
			user.primaryTelephone = '111111111';
			expect(user.primaryTelephone).to.eql('111111111');
		});

	});

	context('renewalDate', () => {

		it('gets the renewal date for the user\'s currently active subscription', () => {
			expect(user.renewalDate).to.eql('2012-02-16');
		});

		it('returns null if user has no currently active subscription', () => {
			let userDetailsResponseCopy = Object.assign({}, userDetailsResponse);
			delete userDetailsResponseCopy.subscriber.status.subscriptions;
			const user = new User(userDetailsResponseCopy, false);
			expect(user.renewalDate).to.be.null;
		});

	});

	context('homeAddress', () => {

		it('get user\'s home address details', () => {
			expect(user.homeAddress).to.eql(userDetailsResponse.profiles.restricted.homeAddress);
		});

	});

	context('country', () => {

		it('get user\'s home address country code', () => {
			expect(user.country).to.eql('GBR');
		});

		it('set user\'s home address country code', () => {
			user.country = 'USA';
			expect(user.country).to.eql('USA');
		});

	});

	context('postcode', () => {

		it('get user\'s home address post code', () => {
			expect(user.postcode).to.eql('SE1 9HL');
		});

		it('set with user\'s home address post code', () => {
			user.postcode = '90210';
			expect(user.postcode).to.eql('90210');
		});

	});

	context('throws an error', () => {

		it('when user\'s profile is restricted due to an old session', () => {
			const user = new User(userDetailsResponse, true);
			expect(() => user.primaryTelephone).to.throw();
			expect(() => user.country).to.throw();
			expect(() => user.postcode).to.throw();
		});

		it('when userDetailsResponse is invalid', () => {
			let response;

			try {
				user = new User({}, true);
				expect.fail('Should have thrown the error!');
			} catch (error) {
				response = error;
			}

			expect(response.message).to.equal('Invalid user details by session response');
		});

	});

	context('formatForSubscription', () => {

		it('Returns the user data in the correct format for subs api.', () => {
			expect(user.formatForSubscription()).to.deep.equal({
				id: 'fakeId',
				email: 'email@example.com',
				firstName: 'John',
				lastName: 'Doe',
				primaryTelephone: '12345678',
				secondaryEmail: 'email@email.com',
				homeAddress: {
					country: 'GBR',
					postcode: 'SE1 9HL'
				},
				demographics: {
					industry: { code: 'PHC' },
					position: { code: 'AS' },
					responsibility: { code: 'BUY' }
				}
			});
		});
	});

	context('belongsToLicence', () => {

		it('returns TRUE if licence ID can be found in the user\'s licence array', () => {
			const licenceId = 'id';
			expect(user.belongsToLicence(licenceId)).to.be.true;
		});

		it('returns FALSE if licence ID could not be found in the user\'s licence array', () => {
			const licenceId = 'anotherId';
			expect(user.belongsToLicence(licenceId)).to.be.false;
		});
	});

	context('activeSubscription', () => {
		it('returns a UserSubscription instance for a active subscription', () => {
			expect(user.activeSubscription).to.be.an.instanceof(UserSubscription);
		});

		it('returns an active subscription', () => {
			expect(user.activeSubscription.status).to.equal('Active');
		});

		it('returns null when subscriptions is empty array', () => {
			userDetailsResponse.subscriber.status.subscriptions = [];
			const user = new User(userDetailsResponse, false);
			expect(user.activeSubscription).to.equal(null);
		});

		it('returns null when subscriptions is null', () => {
			userDetailsResponse.subscriber.status.subscriptions = null;
			const user = new User(userDetailsResponse, false);
			expect(user.activeSubscription).to.equal(null);
		});

		it('returns null when subscriber is null', () => {
			userDetailsResponse.subscriber = null;
			const user = new User(userDetailsResponse, false);
			expect(user.activeSubscription).to.equal(null);
		});

		it('returns null when subscriber is an empty object', () => {
			userDetailsResponse.subscriber = {};
			const user = new User(userDetailsResponse, false);
			expect(user.activeSubscription).to.equal(null);
		});
	});

	context('activeSubscriptionName', () => {
		it('returns an attempt at the active subscription name', () => {
			expect(user.activeSubscriptionName).to.equal('Standard Digital');
		});
	});

	context('allSubscription', () => {
		it('returns a UserSubscription instance for an active subscription', () => {
			const allSubscriptions = user.allSubscriptions;
			expect(allSubscriptions).to.be.an.instanceof(Array);
			expect(allSubscriptions.length).to.equal(3);
			expect(allSubscriptions[0]).to.be.an.instanceof(UserSubscription);
			expect(allSubscriptions[1]).to.be.an.instanceof(UserSubscription);
			expect(allSubscriptions[2]).to.be.an.instanceof(UserSubscription);
		});

		it('returns null when subscriptions is empty array', () => {
			userDetailsResponse.subscriber.status.subscriptions = [];
			const user = new User(userDetailsResponse, false);
			expect(user.allSubscriptions).to.eql([]);
		});

		it('returns null when subscriptions is null', () => {
			userDetailsResponse.subscriber.status.subscriptions = null;
			const user = new User(userDetailsResponse, false);
			expect(user.allSubscriptions).to.eql([]);
		});

		it('returns null when subscriber is null', () => {
			userDetailsResponse.subscriber = null;
			const user = new User(userDetailsResponse, false);
			expect(user.allSubscriptions).to.eql([]);
		});

		it('returns null when subscriber is an empty object', () => {
			userDetailsResponse.subscriber = {};
			const user = new User(userDetailsResponse, false);
			expect(user.allSubscriptions).to.eql([]);
		});
	});

});