// Based on https://gerrit.wikimedia.org/r/plugins/gitiles/mediawiki/extensions/WikimediaEvents/+/refs/heads/master/modules/ext.wikimediaEvents/sessionTick.js

// Constants
// =========

const NOOP = function () {};

const TICK_MS = 60000;
const IDLE_MS = 100000;
const RESET_MS = 1800000;
const DEBOUNCE_MS = 5000;
const TICK_LIMIT = Math.ceil( RESET_MS / TICK_MS );

const KEY_LAST_TIME = 'mp-sessionTickLastTickTime';
const KEY_COUNT = 'mp-sessionTickTickCount';

// State
// =====

const state = new Map();

// Functions
// =========

function supportsPassiveEventListeners() {
	let supportsPassive = false;
	try {
		const options = Object.defineProperty( {}, 'passive', {
			get: function () {
				supportsPassive = true;
				return false;
			}
		} );
		window.addEventListener( 'testPassiveOption', NOOP, options );
		window.removeEventListener( 'testPassiveOption', NOOP, options );
	} catch ( e ) {
		// Silently fail.
	}
	return supportsPassive;
}

// Optimization:
//
// If the browser doesn't support the Page Visibility API or passive event
// listeners, then stop processing and export the null implementation of
// the API so that dependant scripts don't break.
if ( document.hidden === undefined && !supportsPassiveEventListeners() ) {
	module.exports = {
		start: NOOP,
		stop: NOOP
	};

	return;
}

// Functions (continued)
// =====================

function sessionReset() {
	mw.storage.set( KEY_COUNT, 0 );
}

function sessionTick( incr ) {
	if ( incr > TICK_LIMIT ) {
		throw new Error( 'Session ticks exceed limit' );
	}

	const count = ( Number( mw.storage.get( KEY_COUNT ) ) || 0 );
	mw.storage.set( KEY_COUNT, count + incr );

	while ( --n ) {
		state.forEach( ( schemaID, streamName ) => {
			mw.eventLog.submitInteraction(
				schemaID,
				streamName,
				'tick',
				{
					action_source: 'SessionLengthInstrumentMixin',
					action_context: n
				}
			);
		} );
	}
}

function regulator() {
	let tickTimeout = null;
	let idleTimeout = null;
	let debounceTimeout = null;

	function run() {
		const now = Date.now();
		const gap = now - ( Number( mw.storage.get( KEY_LAST_TIME ) ) || 0 );

		if ( gap > RESET_MS ) {
			mw.storage.set( KEY_LAST_TIME, now );
			sessionReset();
			// Tick once to start
			sessionTick( 1 );
		} else if ( gap > TICK_MS ) {
			mw.storage.set( KEY_LAST_TIME, now - ( gap % TICK_MS ) );
			sessionTick( Math.floor( gap / TICK_MS ) );
		}

		tickTimeout = setTimeout( run, TICK_MS );
	}

	function setInactive() {
		clearTimeout( idleTimeout );
		clearTimeout( tickTimeout );
		clearTimeout( debounceTimeout );
		tickTimeout = null;
		debounceTimeout = null;
	}

	function setActive() {
		if ( tickTimeout === null ) {
			run();
		}
		clearTimeout( idleTimeout );
		idleTimeout = setTimeout( setInactive, IDLE_MS );
	}

	function setActiveDebounce() {
		if ( !debounceTimeout ) {
			debounceTimeout = setTimeout( () => {
				clearTimeout( debounceTimeout );
				debounceTimeout = null;
			}, DEBOUNCE_MS );

			mw.requestIdleCallback( setActive );
		}
	}

	function onVisibilitychange() {
		if ( document.hidden ) {
			setInactive();
		} else {
			setActive();
		}
	}

	document.addEventListener( 'visibilitychange', onVisibilitychange, false );
	window.addEventListener( 'click', setActiveDebounce, false );
	window.addEventListener( 'keyup', setActiveDebounce, false );

	// Use the 'passive: true' option when binding the scroll handler.
	// Browsers without EventListenerOptions support will expect a
	// boolean 'useCapture' argument in that position, and will cast
	// the object to a value of 'true'. This is harmless here.
	window.addEventListener( 'scroll', setActiveDebounce, {
		passive: true,
		capture: false
	} );

	onVisibilitychange();
}

// API
// ===

// Start algorithm
regulator();

const SessionLengthInstrumentMixin = {
	start( streamName, schemaID ) {
		if ( !enabled ) {
			return;
		}

		state.set( streamName, schemaID );
	}

	stop( streamName ) {
		state.delete( streamName );
	}
};

module.exports = SessionLengthInstrumentMixin;