'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/*
 *+------------------------------------------------------------------------+
 *| Licensed Materials - Property of IBM
 *| IBM Cognos Products: Dashboard
 *| (C) Copyright IBM Corp. 2018
 *|
 *| US Government Users Restricted Rights - Use, duplication or disclosure
 *| restricted by GSA ADP Schedule Contract with IBM Corp.
 *+------------------------------------------------------------------------+
 */
define(['underscore'], function (_) {
	'use strict';

	return function () {
		function VisRenderTrace(renderState) {
			_classCallCheck(this, VisRenderTrace);

			// disable tracer by default
			this._enabledTrace = false;
			this._trace = {};
			this._renderState = renderState;
		}

		/**
   * Enable or disable the tracer
   * note: tracer is disabled by default
   * @param {boolean} [enable = true]	boolean flag to enable tracing when it's true otherwise disable tracing
   */


		VisRenderTrace.prototype.enable = function enable() {
			var _enable = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

			return this._enabledTrace = _enable;
		};

		/**
   * Clear all trace
   */


		VisRenderTrace.prototype.clear = function clear() {
			return this._trace = {};
		};

		/**
   * Get all recorded render sequence trace
   * @return {Object} render sequence trace
   */


		VisRenderTrace.prototype.getTrace = function getTrace() {
			return this._trace;
		};

		/**
   * Starts a trace for a single render senquence run
   * @param {Object[]} tasks	array of all tasks to run in the current render sequence
   * @param {Object} renderContext	render context object
   * @param {Object} renderOptions	render options given by the caller on the render request
   */


		VisRenderTrace.prototype.startRender = function startRender(tasks, renderContext, options) {
			var _this = this;

			if (this._enabledTrace) {
				var renderId = renderContext.id;
				// prepare the render sequence trace object
				if (this._trace[renderId] === undefined) {
					this._trace[renderId] = {
						options: options,
						steps: []
					};
				}
				// prepare the render sequence task trace object for each tasks
				_.each(tasks, function (task) {
					_this._trace[renderId].steps.push({
						step: task.id
					});
				});
			}
		};

		/**
   * Starts a trace for a single render sequemce task
   * @param {Object} task	render sequence task
   * @param {Object} renderContext	render context object
   */


		VisRenderTrace.prototype.startTask = function startTask(task, renderContext) {
			if (this._enabledTrace) {
				var trace = this._getRenderTaskTrace(renderContext.id, task.id);
				if (trace) {
					// record the task start time
					trace.start = new Date().toISOString();
				}
			}
		};

		/**
   * trace a task dependency
   */


		VisRenderTrace.prototype.taskDependency = function taskDependency(task, renderContext, dependency) {
			if (this._enabledTrace) {
				var trace = this._getRenderTaskTrace(renderContext.id, task.id);
				if (trace) {
					if (trace.dependencies === undefined) {
						trace.dependencies = [];
					}
					trace.dependencies.push(dependency);
				}
			}
		};

		/**
   * Ends a trace for a sing render sequence task
   * @param {Object} task	render sequence task
   * @param {Object} renderContext	render context object
   * @param {string} status	status string of the task
   * @param {Error=} err optional error object
   */


		VisRenderTrace.prototype.endTask = function endTask(task, renderContext, status, err) {
			if (this._enabledTrace) {
				var trace = this._getRenderTaskTrace(renderContext.id, task.id);
				if (trace) {
					// record the task end time, status and currentContext
					trace.end = new Date().toISOString();
					trace.status = status;
					trace.currentContext = _.clone(this._renderState._currentContext);

					// record the error object (if applicable)
					if (err) {
						trace.error = err;
					}

					// record the render laps time after each task
					var renderTrace = this._getRenderTrace(renderContext.id);
					if (renderTrace) {
						renderTrace.elapsed = new Date(trace.end).getTime() - new Date(renderTrace.steps[0].start).getTime();
					}
				}
			}
		};

		/**
   * Get a root trace object for particular render sequence
   * @param {string} renderId	render identifier
   * @return {object} render sequence trace object
   */


		VisRenderTrace.prototype._getRenderTrace = function _getRenderTrace(renderId) {
			return this._trace[renderId];
		};

		/**
   * Get a trace object for a particular render sequence and task
   * @param {string} renderId	render identifier
   * @param {string} taskId render sequence task identifier
   * @return {object} render sequence task trace object
   */


		VisRenderTrace.prototype._getRenderTaskTrace = function _getRenderTaskTrace(renderId, taskId) {
			var renderTrace = this._getRenderTrace(renderId);
			if (renderTrace) {
				return _.find(renderTrace.steps, function (entry) {
					return entry.step === taskId;
				});
			}
		};

		return VisRenderTrace;
	}();
});
//# sourceMappingURL=VisRenderTrace.js.map