import { expect } from 'chai';
import * as sinon from 'sinon';

import { Invoice, InvoiceStatus } from '../../src/invoice';
import { TestConfiguration } from '../../src/configuration';

describe('Invoice service', () => {
	const sessionToken = 'FTSession_s';
	const invoiceId = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';

	let sandbox: any;
	let instance: any;
	let config: any;

	beforeEach(() => {
		sandbox = sinon.createSandbox();
		config = new TestConfiguration({
			invoiceApiKey: 'secret',
			originSystemId: 'n-membership-sdk test',
		});
		instance = new Invoice(config);
		sandbox.stub(instance, 'requestGet').resolves({});
	});

	afterEach(() => {
		sandbox.restore();
	});

	it('throws an error when host and key configuration properties do not exist', () => {
		try {
			new Invoice({} as any);
			expect.fail('It should throw');
		} catch (error) { }
	});

	describe('getInvoicesBySubscriptionNumber', () => {
		let getParams: any;
		const number = 'A-xxxxxxx';
		const mockResponse = [{ id: 'id' }];

		context('when successful', () => {
			beforeEach(async () => {
				instance.requestGet.resolves(mockResponse);
				await instance.getInvoicesBySubscriptionNumber(number, sessionToken);
				getParams = instance.requestGet.getCall(0).args[0];
			});

			it('should pass correct parameters to requestGet', () => {
				const url = `${instance.membershipApi}/invoice/invoices?subscriptionNumber=${number}`;
				expect(getParams).to.have.property('url');
				expect(getParams.url).to.equal(url);
			});

			it('should contain FTSession-s header in the additionalHeaders', () => {
				expect(getParams).to.have.property('additionalHeaders');
				expect(getParams.additionalHeaders).to.have.property('FTSession-s');
				expect(getParams.additionalHeaders['FTSession-s']).to.eql(`${sessionToken}`);
			});

			it('returns the result', async () => {
				const data = await instance.getInvoicesBySubscriptionNumber(number);
				expect(data).to.deep.equal(mockResponse);
			});

		});

		context('when a status is specified', () => {

			beforeEach(async () => {
				instance.requestGet.resolves(mockResponse);
				await instance.getInvoicesBySubscriptionNumber(number, sessionToken, InvoiceStatus.Posted);
				getParams = instance.requestGet.getCall(0).args[0];
			});

			it('should pass correct parameters to requestGet', () => {
				const url = `${instance.membershipApi}/invoice/invoices?subscriptionNumber=${number}&invoiceStatus=Posted`;
				expect(getParams).to.have.property('url');
				expect(getParams.url).to.equal(url);
			});

		});

		context('when an error is thrown', () => {
			const errorResponse = new Error('Test failure');

			beforeEach(() => {
				instance.requestGet.rejects(errorResponse);
			});

			it('it throws the same error', async () => {
				try {
					await instance.getInvoicesBySubscriptionNumber(number, sessionToken);
					expect.fail('Should have thrown the error!');
				} catch (error) {
					expect(error).to.deep.equal(errorResponse);
				}
			});
		});
	});
	describe('getInvoicesByBalance', () => {
		let getParams: any;
		const number = 'A-xxxxxxx';
		const mockResponse = [{ id: 'id' }];

		context('when successful', () => {
			beforeEach(async () => {
				instance.requestGet.resolves(mockResponse);
				await instance.getInvoicesByBalance(number, sessionToken, 'outstanding');
				getParams = instance.requestGet.getCall(0).args[0];
			});

			it('should pass correct parameters to requestGet', () => {
				const url = `${instance.membershipApi}/invoice/invoices?subscriptionNumber=${number}&balance=outstanding`;
				expect(getParams).to.have.property('url');
				expect(getParams.url).to.equal(url);
			});

			it('should contain FTSession-s header in the additionalHeaders', () => {
				expect(getParams).to.have.property('additionalHeaders');
				expect(getParams.additionalHeaders).to.have.property('FTSession-s');
				expect(getParams.additionalHeaders['FTSession-s']).to.eql(`${sessionToken}`);
			});

			it('returns the result', async () => {
				const data = await instance.getInvoicesByBalance(number, sessionToken);
				expect(data).to.deep.equal(mockResponse);
			});

		});

		context('when a status is specified', () => {

			beforeEach(async () => {
				instance.requestGet.resolves(mockResponse);
				await instance.getInvoicesByBalance(number, sessionToken, 'outstanding');
				getParams = instance.requestGet.getCall(0).args[0];
			});

			it('should pass correct parameters to requestGet method', () => {
				const url = `${instance.membershipApi}/invoice/invoices?subscriptionNumber=${number}&balance=outstanding`;
				expect(getParams).to.have.property('url');
				expect(getParams.url).to.equal(url);
			});

		});

		context('when an error is thrown', () => {
			const errorResponse = new Error('Test failure');

			beforeEach(() => {
				instance.requestGet.rejects(errorResponse);
			});

			it('it throws the same error', async () => {
				try {
					await instance.getInvoicesByBalance(number, sessionToken);
					expect.fail('Should have thrown the error!');
				} catch (error) {
					expect(error).to.deep.equal(errorResponse);
				}
			});
		});
	});

	describe('getInvoiceById', () => {
		let getParams: any;
		const mockResponse = { id: 'id' };

		context('when successful', () => {
			beforeEach(async () => {
				instance.requestGet.resolves(mockResponse);
				await instance.getInvoiceById(invoiceId, sessionToken);
				getParams = instance.requestGet.getCall(0).args[0];
			});

			it('should pass correct parameters to requestGet', () => {
				const url = `${instance.membershipApi}/invoice/invoices/${invoiceId}`;
				expect(getParams).to.have.property('url');
				expect(getParams.url).to.equal(url);
			});

			it('should contain FTSession-s header in the additionalHeaders', () => {
				expect(getParams).to.have.property('additionalHeaders');
				expect(getParams.additionalHeaders).to.have.property('FTSession-s');
				expect(getParams.additionalHeaders['FTSession-s']).to.eql(`${sessionToken}`);
				expect(getParams.additionalHeaders).to.have.property('Accept');
				expect(getParams.additionalHeaders['Accept']).to.eql('application/json');
			});

			it('returns the result', async () => {
				const data = await instance.getInvoiceById(invoiceId, sessionToken);
				expect(data).to.deep.equal(mockResponse);
			});

		});
		context('when an error is thrown', () => {
			const errorResponse = new Error('Test failure');

			beforeEach(() => {
				instance.requestGet.rejects(errorResponse);
			});

			it('it throws the same error', async () => {
				try {
					await instance.getInvoiceById(invoiceId, sessionToken);
					expect.fail('Should have thrown the error!');
				} catch (error) {
					expect(error).to.deep.equal(errorResponse);
				}
			});
		});
	});

	describe('download invoice', () => {
		let getParams: any;
		const mockResponse = 'some binary data';

		context('when no errors are returned', () => {
			beforeEach(async () => {
				instance.requestGet.resolves(mockResponse);
				await instance.download(invoiceId, sessionToken);
				getParams = instance.requestGet.getCall(0).args[0];
			});

			it('should pass correct parameters to requestGet', () => {
				const url = `${instance.membershipApi}/invoice/invoices/download/${invoiceId}`;

				expect(getParams).to.have.property('url');
				expect(getParams.url).to.equal(url);
			});

			it('should contain FTSession-s header in the additionalHeaders', () => {
				expect(getParams).to.have.property('additionalHeaders');
				expect(getParams.additionalHeaders).to.have.property('FTSession-s');
				expect(getParams.additionalHeaders['FTSession-s']).to.eql(`${sessionToken}`);
			});

			it('should contain Accept application/pdf in the additionalHeaders', () => {
				expect(getParams).to.have.property('additionalHeaders');
				expect(getParams.additionalHeaders).to.have.property('Accept');
				expect(getParams.additionalHeaders['Accept']).to.eql('application/pdf');
			});

			it('returns the result', async () => {
				const data = await instance.download(invoiceId, sessionToken);
				expect(data).to.deep.equal(mockResponse);
			});

		});
		context('when an error is thrown', () => {
			const errorResponse = new Error('Test failure');

			beforeEach(() => {
				instance.requestGet.rejects(errorResponse);
			});

			it('it throws the same error', async () => {
				try {
					await instance.download(invoiceId, sessionToken);
					expect.fail('Should have thrown the error!');
				} catch (error) {
					expect(error).to.deep.equal(errorResponse);
				}
			});
		});
	});
});