'use strict';

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

	var renderErrors = {
		'ENGINE_LAYOUT_DOES_NOT_FIT': 'dwErrorVisualizationTooSmall'
	};

	var RESERVED_CONTEXT_KEYS = ['id', 'extraInfo'];

	var RenderTask = BaseTask.extend({

		/**
   * Final render task. Call the view to render the visualization.
   * @param renderContext - information collected by a particular call to render or reRender (such as the view, control, data etc).
   * @returns a promise
   */
		process: function process(renderContext) {
			this._logRenderContext('_render:ContextStepsComplete', renderContext);

			var isAnnotationRequest = renderContext.extraInfo && renderContext.extraInfo.annotationRequest;
			if (this._isStepComplete(renderContext, 'render') || isAnnotationRequest) {
				this._completeStep(renderContext, 'render', this.getRenderState());
				return Promise.resolve(renderContext);
			}

			return this.render(renderContext);
		},

		render: function render(renderContext) {
			var bResizing = renderContext.resizing;
			delete renderContext.resizing;
			var result = void 0;

			var renderState = this.getRenderState();
			var isRealTimeRefresh = renderContext.extraInfo && renderContext.extraInfo.sender === 'realtimeRefresh';
			if (!renderState.readyToRender()) {
				// This may happen when resize occurs prematurely along with the main render
				// Since we are not ready to render, we have no choice but to terminate render
				// However we should NOT make a false claim that render has completed
				// the state of the render will eventually get updated by the subsequent render request
				result = Promise.resolve(renderContext);
			} else if (renderContext.sameQueryData === true && isRealTimeRefresh) {
				renderContext.renderComplete = true;
				this.visAPI.renderComplete();
				result = Promise.resolve(renderContext);
			} else {
				this.clearError();
				result = this.ownerWidget.getVisBounds().then(function (bounds) {
					var _this = this;

					this._logRenderContext('_render:visBoundReady', renderContext);

					if (renderState.readyToRender()) {
						renderState.lastSizeRendered = bounds;
						_.each(_.keys(renderContext), function (key) {
							if (!_this._isReservedContextKey(key) && renderState.getCurrentContext(key)) {
								renderContext[key] = renderState.getCurrentContext(key)[key];
							}
						});

						renderContext.widgetSize = bounds;

						var visView = this.getRenderState().getCurrentContextData('visView');
						visView.show();

						try {
							visView.resizing = bResizing;
							return visView.render(renderContext).then(function (result) {
								if (result && result.reRenderNeeded) {
									_this.ownerWidget.setReRenderOnShow({
										resizing: true
									});
									renderContext.renderComplete = false;
									return renderContext;
								}
								_this._completeStep(renderContext, 'render', renderState);
								renderState.firstRenderComplete = true;
								renderContext.renderComplete = true;
								//The render is completed so ensure the renderingNewData flag is reset prior to the next render.
								visView.setRenderingNewData(false);

								//refresh property panel when re-render happens, no need to refreh the panel if the rerender is triggered by resizing or auto-refresh
								var isAutoRefresh = renderContext && renderContext.extraInfo && renderContext.extraInfo.sender === 'realtimeRefresh';
								var refreshPropertiesPane = renderContext && renderContext.refresh && renderContext.refresh.propertiesPane;
								refreshPropertiesPane = refreshPropertiesPane || refreshPropertiesPane === undefined && renderContext.refreshAll;
								if (refreshPropertiesPane && _this.ownerWidget.focusOn && !bResizing && !isAutoRefresh) {
									_this.ownerWidget.refreshPropertiesPane();
								}
								return renderContext;
							}).catch(function (e) {
								this._showRenderError(renderContext, e);
								renderContext.renderComplete = true;
								//The render is completed so ensure the renderingNewData flag is reset prior to the next render.
								visView.setRenderingNewData(false);
								return renderContext;
							}.bind(this));
						} catch (e) {
							//The render is completed (with an error) so ensure the renderingNewData flag is reset prior to the next render.
							visView.setRenderingNewData(false);
							this._showRenderError(renderContext, e);
						}

						renderState.firstRenderComplete = true;
					}

					renderContext.renderComplete = true;
					return renderContext;
				}.bind(this));
			}
			return result;
		},

		/**
   * Don't process these keys as steps in the render sequence
   */
		_isReservedContextKey: function _isReservedContextKey(key) {
			return RESERVED_CONTEXT_KEYS.indexOf(key) > -1;
		},

		_showRenderError: function _showRenderError(renderContext, e) {

			if (this.owner.isActive()) {
				if (this.owner.isLastRun(renderContext)) {
					renderContext.visView.hide();
					var errorCode = e.getErrorCode && e.getErrorCode();
					var errorCodeName = errorCode && errorCode.name();
					var errorMessage = errorCodeName && renderErrors[errorCodeName] || 'dwErrorRenderingVisualization';

					this.owner.showError(errorMessage);
				}
				this.logger.error('An error occured during the data widget rendering sequence', e, this.visAPI);
			} else {
				this.logger.debug('An error occured during the data widget rendering sequence', e, this.visAPI);
			}
		}
	});

	return RenderTask;
});
//# sourceMappingURL=RenderTask.js.map