import { assert, assertEqual, assertFalse, assertNull, assertTrue, assertThrows } from '../tk-unit';
import { enable, disable, profile, time, start, stop, timer, isRunning, resetProfiles } from '@nativescript/core/profiling';

enable();
class TestClass {
	@profile('__func_decorator__')
	doNothing() {
		//noop
	}

	@profile('__func_decorator_error__')
	throwError() {
		throw new Error('This error is expected');
	}

	@profile
	unnamed1() {
		// noop
	}

	@profile()
	unnamed2() {
		// noop
	}

	private isInReentrant = false;

	@profile
	reentrant() {
		try {
			if (!this.isInReentrant) {
				this.isInReentrant = true;
				this.reentrant();
			}
		} finally {
			this.isInReentrant = false;
		}
	}
}

const testFunction1 = profile(function testFunction1() {
	// noop
});
const testFunction2 = profile('testFunction2', () => {
	// noop
});
disable();

function retry(count: number, action: () => void) {
	for (var i = 1; i <= count; i++) {
		try {
			action();

			return;
		} catch (e) {
			if (i === count) {
				throw e;
			}
		}
	}
}

export function test_time_returns_number() {
	assertEqual(typeof time(), 'number');
}

export function test_isRunning() {
	resetProfiles();
	const name = 'test_isRunning';
	assertFalse(isRunning(name), 'isRunning should be false before start');

	start(name);
	assertTrue(isRunning(name), 'isRunning should be true after start');

	stop(name);
	assertFalse(isRunning(name), 'isRunning should be false after stop');

	start(name);
	assertTrue(isRunning(name), 'isRunning should be true after second start');

	stop(name);
	assertFalse(isRunning(name), 'isRunning should be false after second stop');
}

export function test_isRunning_withReentrancy() {
	resetProfiles();
	const name = 'test_isRunning';
	assertFalse(isRunning(name), 'isRunning should be false before start');

	start(name);
	assertTrue(isRunning(name), 'isRunning should be true after start');

	start(name);
	assertTrue(isRunning(name), 'isRunning should be true after second start');

	stop(name);
	assertTrue(isRunning(name), 'isRunning should be true after first stop');

	stop(name);
	assertFalse(isRunning(name), 'isRunning should be false after second stop');
}

export function test_reset_profiles() {
	resetProfiles();
	const name = 'test_reset_profiles';

	start(name);
	stop(name);
	resetProfiles();

	const res = timer(name);

	assertNull(res);
}

export function test_start_stop() {
	resetProfiles();
	const name = 'test_start_stop';

	start(name);
	stop(name);
	const res = timer(name);

	assertEqual(res.count, 1);
}

export function test_start_stop_count() {
	resetProfiles();
	const name = 'test_start_stop_count';

	for (var i = 0; i < 10; i++) {
		start(name);
		stop(name);
	}

	const res = timer(name);
	assertEqual(res.count, 10);
}

export function test_profile_decorator_count() {
	resetProfiles();
	const test = new TestClass();
	for (var i = 0; i < 10; i++) {
		test.doNothing();
		test.unnamed1();
		test.unnamed2();
		testFunction1();
		testFunction2();
	}

	['__func_decorator__', 'TestClass.unnamed1', 'TestClass.unnamed2', 'testFunction1', 'testFunction2'].forEach((key) => {
		const res = timer(key);
		assertEqual(res.count, 10, 'Expected profile with name ${key} to have traced 10 calls.');
	});
}

export function test_profile_decorator_handles_exceptions() {
	resetProfiles();
	const test = new TestClass();

	assertThrows(() => test.throwError());
	assertFalse(isRunning('__func_decorator_error__'), 'Timer should be stopped on exception.');
	assertEqual(timer('__func_decorator_error__').count, 1, 'Timer should be called once');
}

export function test_start_stop_performance() {
	retry(5, () => {
		resetProfiles();

		const count = 10000;
		const name = 'test_start_stop_performance';

		for (var i = 0; i < count; i++) {
			start(name);
			stop(name);
		}

		const res = timer(name);
		assertEqual(res.count, count);
		assert(res.totalTime <= 500, `Total time for ${count} timer operations is too much: ${res.totalTime}`);
	});
}

export function test_profile_decorator_performance() {
	retry(5, () => {
		resetProfiles();

		var start = Date.now();
		const count = 10000;
		const test = new TestClass();
		for (var i = 0; i < count; i++) {
			test.doNothing();
		}

		const res = timer('__func_decorator__');
		assertEqual(res.count, count);

		assert(res.totalTime <= 500, `Total time for ${count} timer operations is too much: ${res.totalTime}`);
		var end = Date.now();
		assert(end - start <= 1000, `Total time for test execution is too much: ${end - start}ms`);
	});
}

export function test_reentrancy() {
	// reentrant
	retry(5, () => {
		resetProfiles();
		const test = new TestClass();
		test.reentrant();
	});
}