'use strict';

/*
 *+------------------------------------------------------------------------+
 *| Licensed Materials - Property of IBM
 *| IBM Cognos Products: BI Dashboard
 *| (C) Copyright IBM Corp. 2016, 2019
 *|
 *| US Government Users Restricted Rights - Use, duplication or disclosure
 *| restricted by GSA ADP Schedule Contract with IBM Corp.
 *+------------------------------------------------------------------------+
 */

define(['../../../lib/@waca/core-client/js/core-client/ui/core/Class', '../../../lib/@waca/upgrades/UpgradeBase', '../../../lib/@waca/dashboard-common/dist/query/FacetDataObject', 'jquery', 'underscore'], function (Class, UpgradeBase, FacetObject, $, _) {

	var UPLOADED_FILE_TYPE = 'uploadedFile';
	var DATASET2_TYPE = 'dataSet2';

	var Upgrade = Class.extend([UpgradeBase], {
		init: function init() {
			this.VERSION = 8;
		},

		/**
   * Perform upgrade
   *
   * @param {object} spec - spec to perform upgrade on
   *
   * @return {Promise} Promise always resolved when upgrade performed; error is logged only
   */
		up: function up(spec) {
			if (!spec) {
				return Promise.resolve(spec);
			}

			this._upgradeEventGroups(spec);
			this._upgradeTimeline(spec);
			return this._upgradeIdentifiers(spec).catch(function (error) {
				if (this.data.logger) {
					this.data.logger.error(error);
				}
				return spec;
			}.bind(this));
		},

		// Update columnId: change from content-locale to model-locale
		_upgradeIdentifiers: function _upgradeIdentifiers(boardSpec) {
			var _this = this;

			var initialDatasetInfos = [];
			// Collect all columnIds from widgets - Also update filter values in widgets
			_.each(boardSpec.widgets, function (widgetSpec) {
				var datasetInfo = _this._collectColumnIdsInWidget(widgetSpec);
				if (datasetInfo) {
					var exist = _.findWhere(initialDatasetInfos, {
						datasetId: datasetInfo.datasetId
					});
					if (!exist) {
						initialDatasetInfos.push(datasetInfo);
					} else {
						// concatenate column lists with existing dataset
						exist.columnIds = exist.columnIds.concat(datasetInfo.columnIds);
					}
				}
			});

			// Collect all columnIds from datasetShaping (calculations, data tray filters) - Also update filter values in dataset shaping
			if (boardSpec.datasetShaping && boardSpec.datasetShaping.length > 0) {
				this._collectColumnIdsFromDatasetShaping(boardSpec.datasetShaping, initialDatasetInfos);
			}

			// We have updated all filter values for R6 to have use/display format, now we can eliminate datasets
			// of type uploaded file or dataSet2 as these datasets do not support multi-lingual
			var datasetInfos = _.filter(initialDatasetInfos, function (datasetInfo) {
				if (datasetInfo.datasetType !== UPLOADED_FILE_TYPE && datasetInfo.datasetType !== DATASET2_TYPE) {
					return datasetInfo;
				}
			});

			// If the same dataset is used in different widgets, merge their list of columnIds to call Moser once per dataset
			this._mergeDatasetColumnIds(datasetInfos);

			// Call Moser REST-API to get identifiers in model locale
			var identifierPromises = [];
			_.each(datasetInfos, function (datasetInfo) {
				if (!datasetInfo.merged) {
					identifierPromises.push(_this._getIdentifiersInModelLocale(datasetInfo));
				}
			});

			return Promise.all(identifierPromises).then(function () {
				for (var i = 0; i < datasetInfos.length; ++i) {
					if (datasetInfos[i].newColumnIds && datasetInfos[i].newColumnIds.length > 0) {
						_this._replaceIdentifiersInAllWidgets(datasetInfos[i], boardSpec);
						_this._replaceIdentifiersInDatasetShaping(datasetInfos[i], boardSpec);
					}
				}
				return boardSpec;
			});
		},

		_collectColumnIdsFromDatasetShaping: function _collectColumnIdsFromDatasetShaping(datasetShaping, datasetInfos) {
			for (var i = 0; i < datasetShaping.length; ++i) {
				var aDatasetShaping = datasetShaping[i];
				var datasetInfo = _.findWhere(datasetInfos, {
					datasetId: aDatasetShaping.id
				});
				if (!datasetInfo) {
					// create new datasetInfo
					datasetInfo = {
						datasetId: aDatasetShaping.id,
						columnIds: [],
						datasetType: 'module' //Unable find to a matched dataset from any widget.
					};
					datasetInfos.push(datasetInfo);
				}
				if (aDatasetShaping.calculations && aDatasetShaping.calculations.length > 0) {
					this._collectCalculationColumnIds(aDatasetShaping.calculations, datasetInfo.columnIds);
				}
				if (aDatasetShaping.filters && aDatasetShaping.filters.length > 0) {
					this._collectFilterColumnIdsAndUpgradeFilterValues(aDatasetShaping.filters, datasetInfo.columnIds);
				}
				if (datasetInfo.columnIds.length > 0) {
					datasetInfo.columnIds = _.uniq(datasetInfo.columnIds);
				}
			}
		},

		_collectCalculationColumnIds: function _collectCalculationColumnIds(calculations, columnIds) {
			_.each(calculations, function (calculation) {
				if (calculation.expr && calculation.expr.params && calculation.expr.params.length > 0) {
					_.each(calculation.expr.params, function (param) {
						if (param.col) {
							columnIds.push(param.col);
						}
					});
				}
			});
		},

		/*
   *@param {Array} filters
   *@param {Array} columnIds, array that holds collected column IDs, Optional
   */
		_collectFilterColumnIdsAndUpgradeFilterValues: function _collectFilterColumnIdsAndUpgradeFilterValues(filters, columnIds) {
			var _this2 = this;

			_.each(filters, function (filter) {
				if (filter.columnId) {
					if (columnIds) {
						columnIds.push(filter.columnId);
					}
					_this2._upgradeFilterValues(filter);
				}
			});
		},

		_mergeDatasetColumnIds: function _mergeDatasetColumnIds(datasetInfos) {

			if (datasetInfos.length === 0) {
				return;
			}
			for (var i = 0; i < datasetInfos.length; ++i) {
				// Remove duplicates
				datasetInfos[i].columnIds = _.uniq(datasetInfos[i].columnIds);
			}
		},

		_findSameDataset: function _findSameDataset(datasetId, startIndex, datasetInfos) {
			for (var j = startIndex + 1; j < datasetInfos.length; ++j) {
				if (!datasetInfos[j].merged && datasetInfos[j].datasetId === datasetId) {
					return j;
				}
			}
			return -1;
		},

		_collectColumnIdsInWidget: function _collectColumnIdsInWidget(widgetModel) {
			if (!widgetModel || !widgetModel.dataSet) {
				return null; //Upgrade is not needed
			}

			// Collect all columnIds used in this widget
			var columnIdsOfWidget = this._collectColumnIds(widgetModel);
			if (columnIdsOfWidget.length === 0) {
				return null;
			}
			return {
				datasetId: widgetModel.dataSet.id,
				columnIds: columnIdsOfWidget,
				datasetType: widgetModel.dataSet.type
			};
		},

		_collectColumnIds: function _collectColumnIds(widgetModel) {
			var columnIds = [];
			_.each(widgetModel.mapping, function (mapping) {
				if (mapping.columnId) {
					columnIds.push(mapping.columnId);
				}
			}.bind(this));
			//Update model filters attributes
			_.each(widgetModel.filters, function (filter) {
				if (filter.columnId) {
					columnIds.push(filter.columnId);
					this._upgradeFilterValues(filter);
				} else {
					// compound filters with nested values structure (see example in unit test)
					this._collectColumnIdsInCompoundFilter(filter, columnIds);
				}
			}.bind(this));
			//Update model local filters attributes
			this._collectFilterColumnIdsAndUpgradeFilterValues(widgetModel.localFilters, columnIds);
			return _.uniq(columnIds);
		},

		/*Upgrade pre-R6 filter values to R6 FacetDataObject*/
		_upgradeFilterValues: function _upgradeFilterValues(filter) {
			if (filter && _.isArray(filter.values) && filter.values.length > 0) {
				var result = [];
				_.each(filter.values, function (value) {
					//include NULL values
					result.push(!_.isObject(value) ? new FacetObject(value).toJSONObject() : value);
				});
				filter.values = result;
			}
		},

		_collectColumnIdsInCompoundFilter: function _collectColumnIdsInCompoundFilter(filter, columnIds) {
			if (filter.columnId) {
				columnIds.push(filter.columnId);
			}
			if (filter.values) {
				this._collectColumnIdsInValues(filter.values, columnIds);
			}
		},

		_collectColumnIdsInValues: function _collectColumnIdsInValues(values, columnIds) {
			_.each(values, function (value) {
				if (value.columnId) {
					columnIds.push(value.columnId);
				}
				this._upgradeFilterValues(value);
				if (value.values) {
					this._collectColumnIdsInValues(value.values, columnIds);
				}
			}.bind(this));
		},

		_getIdentifiersInModelLocale: function _getIdentifiersInModelLocale(datasetInfo) {
			var _this3 = this;

			var datasetId = datasetInfo.datasetId;

			return this.data.ajaxSvc.ajax({
				url: 'v1/metadata/modules/' + datasetId + '/identifiers',
				type: 'GET',
				data: {
					idArray: JSON.stringify(datasetInfo.columnIds.sort())
				},
				headers: {
					Accept: 'application/json'
				}
			}).then(function (response) {
				// Moser response is an array of objects:
				// {
				//		'source': <identifier in dashboard>
				//		'target': <identifier in model locale>
				// }
				datasetInfo.newColumnIds = response.data;
				return response;
			}).catch(function (error) {
				_this3.data.logger.error('Error calling Modeling service API to update identifiers');
				var err = '';
				if (error.jqXHR.responseText) {
					err = error.jqXHR.responseText;
					_this3.data.logger.error(err);
				}
				throw err; // re-throw
			});
		},

		_replaceIdentifiersInAllWidgets: function _replaceIdentifiersInAllWidgets(datasetInfo, boardSpec) {
			var _this4 = this;

			_.each(boardSpec.widgets, function (widgetSpec) {
				if (widgetSpec.dataSet && widgetSpec.dataSet.id === datasetInfo.datasetId) {
					_this4._replaceIdentifiersInOneWidget(widgetSpec, datasetInfo.newColumnIds);
				}
			});
		},

		_replaceIdentifiersInDatasetShaping: function _replaceIdentifiersInDatasetShaping(datasetInfo, boardSpec) {
			if (boardSpec.datasetShaping) {
				var aDatasetShaping = _.findWhere(boardSpec.datasetShaping, {
					id: datasetInfo.datasetId
				});
				if (aDatasetShaping) {
					if (aDatasetShaping.calculations && aDatasetShaping.calculations.length > 0) {
						this._replaceIdentifiersInCalculations(aDatasetShaping.calculations, datasetInfo.newColumnIds);
					}
					if (aDatasetShaping.filters && aDatasetShaping.filters.length > 0) {
						this._replaceIdentifiersInFilters(aDatasetShaping.filters, datasetInfo.newColumnIds);
					}
				}
			}
		},

		_replaceIdentifiersInCalculations: function _replaceIdentifiersInCalculations(calculations, columnIdsMapping) {
			_.each(calculations, function (calculation) {
				if (calculation.expr && calculation.expr.params && calculation.expr.params.length > 0) {
					_.each(calculation.expr.params, function (param) {
						if (param.col) {
							var newColumn = _.findWhere(columnIdsMapping, {
								source: param.col
							});
							if (newColumn) {
								param.col = newColumn.target;
							}
						}
					});
				}
			});
		},

		_replaceIdentifiersInFilters: function _replaceIdentifiersInFilters(filters, columnIdsMapping) {
			_.each(filters, function (filter) {
				if (filter.columnId) {
					this._replaceIdentifierOfColumn(filter, columnIdsMapping);
				}
			}.bind(this));
		},

		_replaceIdentifiersInCompoundFilters: function _replaceIdentifiersInCompoundFilters(filter, columnIdsMapping) {
			if (filter.columnId) {
				this._replaceIdentifierOfColumn(filter.columnId, columnIdsMapping);
			}
			if (filter.values) {
				this._replaceIdentifiersInValues(filter.values, columnIdsMapping);
			}
		},

		_replaceIdentifiersInValues: function _replaceIdentifiersInValues(values, columnIdsMapping) {
			_.each(values, function (value) {
				if (value.columnId) {
					this._replaceIdentifierOfColumn(value, columnIdsMapping);
				}
				if (value.values) {
					this._replaceIdentifiersInValues(value.values, columnIdsMapping);
				}
			}.bind(this));
		},

		_replaceIdentifiersInOneWidget: function _replaceIdentifiersInOneWidget(widgetModel, columnIdsMapping) {
			_.each(widgetModel.mapping, function (mapping) {
				if (mapping.columnId) {
					this._replaceIdentifierOfColumn(mapping, columnIdsMapping);
				}
			}.bind(this));
			//Update model filters attributes
			_.each(widgetModel.filters, function (filter) {
				if (filter.columnId) {
					this._replaceIdentifierOfColumn(filter, columnIdsMapping);
				} else {
					this._replaceIdentifiersInCompoundFilters(filter, columnIdsMapping);
				}
			}.bind(this));
			//Update model local filters attributes
			_.each(widgetModel.localFilters, function (filter) {
				if (filter.columnId) {
					this._replaceIdentifierOfColumn(filter, columnIdsMapping);
				}
			}.bind(this));
		},

		_replaceIdentifierOfColumn: function _replaceIdentifierOfColumn(column, columnIdsMapping) {
			var newColumn = _.findWhere(columnIdsMapping, {
				source: column.columnId
			});
			if (newColumn) {
				column.columnId = newColumn.target;
			}
		},

		_upgradeEventGroups: function _upgradeEventGroups(boardSpec) {
			if (boardSpec && boardSpec.layout && !boardSpec.evenGroups) {
				var eventGroups = [];
				var root = boardSpec.layout;
				var isSinglePage = true;

				// Consider it as single page if the root's children is empty or contains a group or widget
				if (root.items && root.items.length > 0) {
					isSinglePage = _.find(root.items, function (layout) {
						return layout.type === 'widget' || layout.type === 'group';
					}) ? true : false;
				}

				if (isSinglePage) {
					eventGroups.push(this._buildEventGroup(root));
				} else {
					_.each(root.items, function (tab) {
						eventGroups.push(this._buildEventGroup(tab));
					}.bind(this));
				}
				boardSpec.eventGroups = eventGroups;
			}
		},

		_buildEventGroup: function _buildEventGroup(layout, eventGroup) {
			// define an empty event group
			eventGroup = eventGroup || {
				id: layout.id + ':1',
				widgetIds: []
			};

			if (layout.type === 'widget') {
				eventGroup.widgetIds.push(layout.id);
			} else {
				_.each(layout.items, function (layout) {
					this._buildEventGroup(layout, eventGroup);
				}.bind(this));
			}
			return eventGroup;
		},

		_upgradeTimeline: function _upgradeTimeline(boardSpec) {
			if (boardSpec && boardSpec.timeline) {
				var episodes = [];
				_.each(boardSpec.timeline.items, function (timelineModel) {
					// preserve old behavior... it's not clear how this could happen
					if (timelineModel.id) {
						episodes.push(this._upgradeTimelineSpec(timelineModel));
					}
				}.bind(this));
				delete boardSpec.timeline.items;
				boardSpec.timeline.episodes = episodes;
			}
		},

		_upgradeTimelineSpec: function _upgradeTimelineSpec(timelineSpec) {
			var acts = [];
			if (timelineSpec.episode) {
				acts.push({
					timer: timelineSpec.episode.timer1 || timelineSpec.episode.timer1 === 0 ? timelineSpec.episode.timer1 : 0,
					action: timelineSpec.episode.action1 || 'show'
				});
				acts.push({
					timer: timelineSpec.episode.timer2 || timelineSpec.episode.timer2 === 0 ? timelineSpec.episode.timer2 : 5000,
					action: timelineSpec.episode.action2 || 'hide'
				});
			}
			return {
				id: timelineSpec.id,
				type: timelineSpec.type,
				acts: acts
			};
		},

		down: function down(spec) {
			// no downgrade at this time; return as is
			return Promise.resolve(spec);
		}
	});

	return new Upgrade();
});
//# sourceMappingURL=8.js.map