/* eslint-disable promise/catch-or-return,promise/no-callback-in-promise */
import {setConfig, getConfig, resetConfig, getUserInfo} from '../src/utils/utils';
import {Resolvable, WaitForSync} from '../src/utils/resolvable';
import {describe, it} from 'mocha';
import {expect} from 'chai';
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
import * as fetchMock from 'fetch-mock';
import {UserInfo} from '../src/utils/userinfo';

describe('frontend:utils - setConfig/getConfig', () => {
	const CONFIG = {EXTERNAL_BASE_URL: 'http://demo.url'};
	afterEach(() => resetConfig());

	it('should return config (afterwards)', async () => {
		setConfig(CONFIG);
		const config = await getConfig();
		expect(config).to.deep.equal(CONFIG);
	});
	it('should return config (beforehand)', (done) => {
		getConfig().then((config) => {
			expect(config).to.deep.equal(CONFIG);
			done();
		});
		setConfig(CONFIG);
	});
});

describe('frontend:utils - getUserInfo', () => {
	const CONFIG = {EXTERNAL_BASE_URL: 'http://demo.url'};
	const USER_INFO: Partial<UserInfo> = {
		name: 'John Doe',
	};

	beforeEach(() => setConfig(CONFIG));
	afterEach(() => resetConfig());

	it('should equal fetched', async () => {
		setConfig(CONFIG);
		fetchMock.mock('http://demo.url/api/user', {
			status: 200,
			body: JSON.stringify(USER_INFO),
		});
		const userInfo = await getUserInfo();
		expect(userInfo).to.deep.equal(USER_INFO);
	});
});

describe('frontend:utils - resolvable', () => {
	const DATA = 5;
	const ERROR = new Error('Custom error!');

	it('waitForSync should return data (afterwards)', async () => {
		const resolvable = new WaitForSync<number>();
		resolvable.setData(DATA);
		const data = await resolvable.resolve();
		expect(data).to.deep.equal(DATA);
	});
	it('waitForSync should return data (beforehand)', (done) => {
		const resolvable = new WaitForSync<number>();
		resolvable.resolve().then((data) => {
			expect(data).to.deep.equal(DATA);
			done();
		});
		resolvable.setData(DATA);
	});

	it('waitForSync should error (afterwards)', async () => {
		const resolvable = new WaitForSync<number>();
		resolvable.setError(ERROR);
		try {
			await resolvable.resolve();
		} catch (err) {
			expect(err).to.deep.equal(ERROR);
		}
	});
	it('waitForSync should error (beforehand)', (done) => {
		const resolvable = new WaitForSync<number>();
		resolvable.resolve().catch((err) => {
			expect(err).to.deep.equal(ERROR);
			done();
		});
		resolvable.setError(ERROR);
	});

	it('waitForSync should resolve data twice', async () => {
		const resolvable = new WaitForSync<number>();
		resolvable.setData(DATA);
		const data1 = await resolvable.resolve();
		const data2 = await resolvable.resolve();
		expect(data1).to.deep.equal(DATA);
		expect(data2).to.deep.equal(DATA);
	});
	it('waitForSync should error twice', async () => {
		const resolvable = new WaitForSync<number>();
		resolvable.setError(ERROR);
		try {
			await resolvable.resolve();
		} catch (err) {
			expect(err).to.deep.equal(ERROR);
		}
		try {
			await resolvable.resolve();
		} catch (err) {
			expect(err).to.deep.equal(ERROR);
		}
	});
	it('waitForSync should wait for resolution twice', (done) => {
		const resolvable = new WaitForSync<number>();
		Promise.all([
			resolvable.resolve().then((data) => {
				expect(data).to.deep.equal(DATA);
			}), resolvable.resolve().then((data) => {
				expect(data).to.deep.equal(DATA);
			}),
		]).then(() => done());
		resolvable.setData(DATA);
	});

	it('resolvable should resolve', async () => {
		const resolvable = new Resolvable(async () => DATA);
		const data = await resolvable.resolve();
		expect(data).to.deep.equal(DATA);
	});
});