'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: BI Cloud (C) Copyright IBM Corp. 2020
 * US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */
define(['gemini/lib/@waca/dashboard-common/dist/core/APIFactory', './SmartTitleAPI', 'underscore'], function (APIFactory, SmartTitleAPI, _) {
	var SmartTitleFeatureProvider = function () {
		function SmartTitleFeatureProvider(options) {
			var _this = this;

			_classCallCheck(this, SmartTitleFeatureProvider);

			this._dashboard = options.dashboardAPI;
			this._content = options.content;
			this._dashboardInternal = options.features['Dashboard.internal'];
			this._widgetApiHandlers = {};

			//tracking event to detect if this widget was added after dashboard open
			//event listener will be removed on render state change
			this._addedContent = [];
			var canvas = this._dashboard.getCanvas();
			if (canvas) {
				this._addContentEvent = canvas.on('add:content:child', function (event) {
					_this._addedContent.push(event.info.newContentId);
				});
			}

			this._state = {
				setupDone: false,
				setupCheckDone: false,
				initialWidgetRenderDone: false,
				shouldUseGeneratedTitle: undefined,
				smartTitleEnabled: undefined,
				toEnableGeneratedTitle: undefined,
				toSetNoTitle: undefined,
				toSetSmartTitle: undefined
			};
		}

		SmartTitleFeatureProvider.prototype._isSmartTitleFeatureEnabled = function _isSmartTitleFeatureEnabled() {
			return !this._dashboard.getGlassCoreSvc('.FeatureChecker').checkValue('dashboard', 'SmartTitle', 'disabled');
		};

		SmartTitleFeatureProvider.prototype._isSmartTitleEnabled = function _isSmartTitleEnabled() {
			return this._isSmartTitleFeatureEnabled() && this._state.smartTitleEnabled;
		};

		SmartTitleFeatureProvider.prototype.getAPI = function getAPI() {
			return APIFactory.createAPI(this, [SmartTitleAPI]); //each content object has its own 'feature' impl
		};

		SmartTitleFeatureProvider.prototype.initialize = function initialize() {
			this.prepare();
		};

		SmartTitleFeatureProvider.prototype.prepare = function prepare() {
			if (!this._isSmartTitleFeatureEnabled()) {
				return;
			}
			this.upgradeIfNeeded();
			this._setupTitle();
			this._addChangeHandlerForTitleModeProperty();
		};

		SmartTitleFeatureProvider.prototype._getModelAttr = function _getModelAttr(name) {
			var boardModel = this._dashboardInternal.getBoardModel();
			var id = this._content.getId();
			var widgetModel = boardModel && boardModel.getWidgetModel(id);
			if (widgetModel) {
				return widgetModel.get(name);
			}
			return undefined;
		};

		SmartTitleFeatureProvider.prototype._setModelAttr = function _setModelAttr(attribs) {
			var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { silent: true };

			var boardModel = this._dashboardInternal.getBoardModel();
			var id = this._content.getId();
			var widgetModel = boardModel && boardModel.getWidgetModel(id);
			widgetModel && widgetModel.set(attribs, options);
		};

		SmartTitleFeatureProvider.prototype._setProp = function _setProp(name, value) {
			var _this2 = this;

			if (this._state.initialWidgetRenderDone) {
				this._content.setPropertyValue(name, value);
			} else {
				var stateAPI = this._content.getFeature('state');
				stateAPI.whenStatusChanges('rendered').then(function () {
					//Content api does not allow SKIP undo/red0 event yet. Need to set in the model and skip the event for the first time
					//this._content.setPropertyValue(name, value);

					var boardModel = _this2._dashboardInternal.getBoardModel();
					var id = _this2._content.getId();
					var widgetModel = boardModel && boardModel.getWidgetModel(id);
					if (widgetModel) {
						var attribs = {};
						attribs[name] = value;
						widgetModel.set(attribs, { payloadData: { skipUndoRedo: true } });
					}
				});
			}
		};

		SmartTitleFeatureProvider.prototype.upgradeIfNeeded = function upgradeIfNeeded() {
			//TODO: feature manages its own upgrade, but could we allow others to customize upgrade process ?
			var container = this._content.getContainer();
			var containerType = container && container.getType();
			var forceSmartTitle = containerType && containerType === 'exploreCard';

			if (forceSmartTitle) {
				var attribs = {
					showTitle: undefined,
					titleMode: 'smartTitle'
				};
				this._setModelAttr(attribs);
				this._setProp('titleMode', 'smartTitle');
				this._setProp('showTitle', undefined);
				return;
			}

			var showTitle = this._getModelAttr('showTitle');
			var name = this._getModelAttr('name');

			var titleMode = this._getModelAttr('titleMode');

			if (showTitle !== undefined) {
				var _attribs = {
					showTitle: undefined
				};
				if (name && (!titleMode || titleMode !== 'noTitle')) {
					if (showTitle === true) {
						_attribs.titleMode = 'customTitle';
						this._setProp('titleMode', 'customTitle');
					} else {
						_attribs.titleMode = 'noTitle';
						this._setProp('titleMode', 'noTitle');
					}
				}
				this._setModelAttr(_attribs);
				this._setProp('showTitle', undefined);
			}
		};

		SmartTitleFeatureProvider.prototype._setupTitle = function _setupTitle() {
			var _this3 = this;

			//if no title set & showTitle prop is true and generatedTitle is undefined, enable smart title
			//if showTitle is true & generatedTitle true, enable smart title (does not matter if title is set or not)
			var stateAPI = this._content.getFeature('state');
			stateAPI.whenStatusChanges('rendered').then(function () {
				_this3._state.initialWidgetRenderDone = true;
			});

			this._stateInitPromise = stateAPI.whenStatusChanges('rendering');
			this._stateInitPromise.then(function () {
				_this3._ensureStateCheckOnInit();
				_this3._state.setupCheckDone = true;

				if (!_this3._state.setupDone) {
					_this3._state.setupDone = true;
					if (_this3._state.toEnableGeneratedTitle && _this3._state.toSetSmartTitle) {
						_this3.enableAndSetSmartTitle();
					} else if (_this3._state.toEnableGeneratedTitle) {
						_this3._enableSmartTitle();
					} else if (_this3._state.toSetNoTitle) {
						_this3._setProp('titleMode', 'noTitle');
					}
				}
			});
		};

		SmartTitleFeatureProvider.prototype._removeAddContentEventListener = function _removeAddContentEventListener() {
			if (this._addContentEvent && this._addContentEvent.remove) {
				this._addContentEvent.remove();
				this._addContentEvent = null;
			}
		};

		SmartTitleFeatureProvider.prototype._ensureStateCheckOnInit = function _ensureStateCheckOnInit() {

			this._removeAddContentEventListener();

			var id = this._content.getId();

			var isWidgetLoadedAfterDashboardOpen = this._addedContent.indexOf(id) !== -1;

			var name = this._getModelAttr('name');

			var titleMode = this._content.getPropertyValue('titleMode');

			var shouldUseGeneratedTitle = false;
			if (name) {
				if (titleMode === 'smartTitle' || !titleMode && isWidgetLoadedAfterDashboardOpen) {
					this._state.toEnableGeneratedTitle = true;
					shouldUseGeneratedTitle = true;
				} else if (titleMode !== 'customTitle') {
					this._setProp('titleMode', 'noTitle');
				}
			} else {

				if (titleMode === undefined) {
					if (name !== undefined && name !== null && name === '' && !isWidgetLoadedAfterDashboardOpen) {
						this._state.toSetNoTitle = true;
					} else {
						//newly added widget
						this._state.toEnableGeneratedTitle = true;
						this._state.toSetSmartTitle = true;
						shouldUseGeneratedTitle = true;
					}
				} else if (titleMode === 'smartTitle') {
					this._state.toEnableGeneratedTitle = true;
					this._state.toSetSmartTitle = true;
					shouldUseGeneratedTitle = true;
				}
			}

			this._state.shouldUseGeneratedTitle = shouldUseGeneratedTitle;
			return this._state;
		};

		SmartTitleFeatureProvider.prototype.shouldUseGeneratedTitle = function shouldUseGeneratedTitle() {
			var smartTitleEnabledConfig = this._dashboard.getAppConfig('smartTitle');
			if (smartTitleEnabledConfig) {
				var state = this._ensureStateCheckOnInit();
				return state.shouldUseGeneratedTitle;
			}
			return false;
		};

		SmartTitleFeatureProvider.prototype._addChangeHandlerForTitleModeProperty = function _addChangeHandlerForTitleModeProperty() {
			var _this4 = this;

			this._content.on('change:property:titleMode', function (event) {
				if (event.info.value === 'smartTitle') {
					_this4.enableAndSetSmartTitle();
				} else {
					_this4.disableSmartTitle(event.info.value);
				}
			});
		};

		SmartTitleFeatureProvider.prototype.enableAndSetSmartTitle = function enableAndSetSmartTitle() {
			if (this._isSmartTitleEnabled()) {
				return;
			}
			var widgetAPI = this._content.getFeature('WidgetAPI.deprecated');
			this._enableSmartTitle();
			this._triggerTitleUpdate(widgetAPI, true);
		};

		SmartTitleFeatureProvider.prototype._enableSmartTitle = function _enableSmartTitle() {
			if (this._isSmartTitleEnabled()) {
				return;
			}
			this._state.smartTitleEnabled = true;

			var widgetAPI = this._content.getFeature('WidgetAPI.deprecated');
			var visAPI = widgetAPI.getVisApi();

			this._deregisterListener();
			this._widgetApiHandlers = {
				_onChangeDefinition: visAPI && visAPI.on('change:definition', this._triggerTitleUpdate.bind(this, widgetAPI))
			};
			this._setProp('titleMode', 'smartTitle');
		};

		SmartTitleFeatureProvider.prototype.disableSmartTitle = function disableSmartTitle() {
			var newTitleMode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'customTitle';

			if (this._isSmartTitleEnabled() === false) {
				return;
			}
			this._state.smartTitleEnabled = false;
			this._deregisterListener();
			this._setProp('titleMode', newTitleMode);
		};

		SmartTitleFeatureProvider.prototype.getTitleState = function getTitleState() {
			var name = this._getModelAttr('name');
			return {
				generatedTitle: this._isSmartTitleEnabled(),
				title: name
			};
		};

		SmartTitleFeatureProvider.prototype.shouldSetTitle = function shouldSetTitle(newTitle) {
			var name = this._getModelAttr('name');
			if (name != newTitle) {
				return true;
			}

			if (this._isTitlePartiallyFormatted(name)) {
				return true;
			}

			return false;
		};

		SmartTitleFeatureProvider.prototype._isTitlePartiallyFormatted = function _isTitlePartiallyFormatted(name) {
			//If the rawTitle can't be found in the titleHtml, then its been formatted.
			return !this._findRawTitleInHtml(name);
		};

		SmartTitleFeatureProvider.prototype.getTitleHtmlWithPreviousFormat = function getTitleHtmlWithPreviousFormat(title) {
			//If the previous unformatted title is found in the html, replace it with the new title to preserve the surrounding format
			var htmlTitleInfo = this._findRawTitleInHtml(this._getModelAttr('name'));
			if (htmlTitleInfo) {
				htmlTitleInfo.spanContainingTheTitle.innerHTML = _.escape(title);
				var newTitleHtml = htmlTitleInfo.titleRoot.innerHTML;
				return newTitleHtml;
			}
			//Null means the title itself had mixed format and can't be replaced.
			return null;
		};

		SmartTitleFeatureProvider.prototype._findRawTitleInHtml = function _findRawTitleInHtml(rawTitle) {
			var titleHtml = this._getModelAttr('titleHtml');
			if (rawTitle && titleHtml) {
				//When escaped html is set in the title control, some characters are changed (eg encoded single quotes are decoded)
				//Use innerHTML for both titleHtml and the escaped rawTitle to make sure things match.
				var rawTitleDiv = document.createElement('div');
				rawTitleDiv.innerHTML = _.escape(rawTitle);

				//The only titleHtml structure we count on is that there's a span somewhere with a title that matches rawTitle.
				var root = document.createElement('div'); //Create a node and set its html content to be titleHtml.
				root.innerHTML = titleHtml;
				var spans = root.getElementsByTagName('span');
				var spanContainingTheTitle = null;
				for (var i = 0; i < spans.length; ++i) {
					if (spans[i].innerHTML === rawTitleDiv.innerHTML) {
						spanContainingTheTitle = spans[i];
					}
				}
				return spanContainingTheTitle && { spanContainingTheTitle: spanContainingTheTitle, titleRoot: root };
			}
			return null;
		};

		SmartTitleFeatureProvider.prototype.destroy = function destroy() {
			this._deregisterListener();
			return Promise.resolve(true);
		};

		SmartTitleFeatureProvider.prototype._deregisterListener = function _deregisterListener() {
			if (this._widgetApiHandlers._onChangeDefinition) {
				this._widgetApiHandlers._onChangeDefinition.remove();
				this._widgetApiHandlers._onChangeDefinition = null;
			}

			this._removeAddContentEventListener();
		};

		SmartTitleFeatureProvider.prototype._triggerTitleUpdate = function _triggerTitleUpdate(widgetAPI) {
			if (widgetAPI) {
				widgetAPI.updateTitle();
			}
		};

		return SmartTitleFeatureProvider;
	}();

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