'use strict';

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

/*
 *+------------------------------------------------------------------------+
 *| 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(['../../lib/@waca/core-client/js/core-client/ui/core/Class', './SmartsVisRecommenderService', './SmartsToVizMapping', './VisToSmartsMapping', './IRUtils', './SmartsSupportedChartTypes', 'underscore', './SmartsCompareCardRecommenderHelper', '../../apiHelpers/SlotAPIHelper'], function (Class, SmartsVisRecommenderService, SmartsToVizMapping, VisToSmartsMapping, IRUtils, SmartsSupportedChartTypes, _, SmartsCompareCardRecommenderHelper, SlotAPIHelper) {
	'use strict';

	var UnsupportedSmartsVis = ['com.ibm.vis.rave2network'];

	var BaseSmartsVisRecommenderWrapper = Class.extend({

		// constructor
		init: function init(_ref) {
			var moserDataSources = _ref.moserDataSources,
			    ajaxSvc = _ref.ajaxSvc,
			    logger = _ref.logger,
			    glassOptions = _ref.glassOptions,
			    dashboardApi = _ref.dashboardApi,
			    dataSources = _ref.dataSources;

			BaseSmartsVisRecommenderWrapper.inherited('init', this, arguments);

			this.moserDataSources = moserDataSources;

			this._recommenderService = new SmartsVisRecommenderService({
				ajaxSvc: ajaxSvc,
				logger: logger
			});
			this.dataSources = dataSources;
			this._glassOptions = glassOptions;
			this._smartsToVisInfoMap = SmartsToVizMapping;
			this._visToSmartsInfoMap = VisToSmartsMapping;
			this._supportedVisIds = Object.keys(this._smartsToVisInfoMap);
			this._recommenderApi = dashboardApi.getFeature('Recommender.internal');
		},

		destroy: function destroy() {
			BaseSmartsVisRecommenderWrapper.inherited('destroy', this, arguments);

			if (this._recommenderService) {
				this._recommenderService.destroy();
				this._recommenderService = null;
			}

			this.dataSources = null;
			this._glassOptions = null;
			this._smartsToVisInfoMap = null;
			this._visToSmartsInfoMap = null;
			this._supportedVisIds = null;
			this._recommenderApi = null;
		},

		/**
  * Returns alternate visualizations recommendation for the given columnIds
  * @params - columnIds
  * @params - requestOptions
  *				{
  *					assetId, (mandatory) storeId of embeddedModule, uploadedFile or module)
  *					sourceType, (mandatory) 'uploadedFile', 'dataSet2' or 'module'
  *					oneChartPerType, (optional) true or false, default is true - returns one recommendation per chart type.
  *					numResult, (optional) number of recommendations, default is 10
  *				}
  * @returns - [recommendations] where recommendation is
  *	{
  *		visId: <visId>
  *		slots : {slotId_1 : [columnIds],
  *			    slotId_2: [columnIds],
  *				:
  *				}
  *		label: <label>
  *		description: <description>
  *		title: <title>
  *	}
  */
		recommendAlternateVisualizations: function recommendAlternateVisualizations() {
			var columnIds = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
			var requestOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

			return this._getRequestParametersForRecommendVisualizations(columnIds, requestOptions, true /*partialTempModule*/).then(this._recommenderService.recommendAlternateVisualizationsOrBindings.bind(this._recommenderService)).then(this._transformRecommendationResponse.bind(this, requestOptions.module.getSourceId())).then(this._stripDuplicates.bind(this));
		},

		/**
  * Returns a list of recommended related visualizations based on given columnIds.
  * @params - columnIds
  * @params - requestOptions
  *				{
  *					assetId, (mandatory) storeId of embeddedModule, uploadedFile or module)
  *					sourceType, (mandatory) 'uploadedFile', 'dataSet2' or 'module'
  *					oneChartPerType, (optional) true or false, default is true - returns one recommendation per chart type.
  *					numResult, (optional) number of recommendations, default is 10
  *				}
  * @returns - [recommendations] where recommendation is
  *	{
  *		visId: <visId>
  *		slots : {slotId_1 : [columnIds],
  *			    slotId_2: [columnIds],
  *				:
  *				}
  *		label: <label>
  *		description: <description>
  *		title: <title>
  *	}
  */
		recommendRelatedVisualizations: function recommendRelatedVisualizations() {
			var columnIds = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
			var requestOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

			return this._getRequestParametersForRecommendVisualizations(columnIds, requestOptions).then(this._recommenderService.recommendRelatedVisualizations.bind(this._recommenderService)).then(this._transformRecommendationResponse.bind(this, requestOptions.module.getSourceId()));
		},

		recommendCompareVisualizations: function recommendCompareVisualizations() {
			var _this = this;

			var columnIds = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
			var requestOptions = arguments[1];

			var helper = new SmartsCompareCardRecommenderHelper(columnIds, requestOptions);
			return helper.getRequestParameters().then(function (params) {
				return _this._recommenderService.recommendCompareVisualizations(params).then(helper.transformCompareRecommendationResponse.bind(helper, requestOptions.module, requestOptions.widgetSpec));
			});
		},

		_getIncludedCharts: function _getIncludedCharts() {
			return SmartsSupportedChartTypes.get(this._glassOptions, this._recommenderApi.getChartTypeList());
		},


		_getRequestParametersForRecommendVisualizations: function _getRequestParametersForRecommendVisualizations(columnIds, requestOptions, bPartialTempModule) {
			var _this2 = this;

			var visualization = requestOptions.visualization,
			    moserDataSources = requestOptions.moserDataSources;

			if (visualization && moserDataSources && moserDataSources.isConsumerGroupColumn) {
				var sourceId = visualization.getDataSource().getId();
				columnIds.forEach(function (columnId, i) {
					if (moserDataSources.isConsumerGroupColumn(sourceId, columnId)) {
						var customGroup = moserDataSources.getCustomGroupData(sourceId, columnId);
						if (customGroup && customGroup.basedOnMoserObjectId) {
							columnIds[i] = customGroup.basedOnMoserObjectId;
						}
					}
				});
			}

			var columns = this._getColumnsInfo(columnIds);

			var requestParameters = {
				columns: columns
			};
			if (requestOptions.includeBestVisForTargetFields) {
				requestParameters.includeBestVisForTargetFields = true;
			}

			return this._getIncludedCharts().then(function (supporteChartTypes) {
				if (supporteChartTypes) {
					requestParameters.includedCharts = supporteChartTypes;
				}

				return _this2._addCommonRequestParameters(requestParameters, requestOptions, bPartialTempModule);
			});
		},

		/**
  * Given a visualization type, recommends the binding for the given columns
  * @param visId - visId
  * @param columnsToBind - array of columnIds, these are columns that need to be bound
  * @param boundColumns - array of bound column info --> [{slotId : <slotId>
  *											             columnIds: <[columnIds]> }
  */
		recommendBindings: function recommendBindings(_ref2) {
			var _this3 = this;

			var visId = _ref2.visId,
			    columnsToBind = _ref2.columnsToBind,
			    requestOptions = _ref2.requestOptions,
			    boundColumnsInfo = _ref2.boundColumnsInfo,
			    originalVisId = _ref2.originalVisId;


			var columns = [];

			if (columnsToBind) {
				columns = columns.concat(this._getColumnsInfo(columnsToBind));
			}

			if (boundColumnsInfo) {
				/**
     * presence of originalVisId indicates that this is a change viz request, therefore,
     * include the binding info for the original viz
     */
				var mapInfo = this._visToSmartsInfoMap[originalVisId] || this._visToSmartsInfoMap[visId];

				if (!mapInfo) {
					return Promise.reject(new Error('Invalid originalVisId or visId'));
				}
				columns = columns.concat(this._getColumnsInfoForBoundColumns(boundColumnsInfo, mapInfo));
			}

			var requestParameters = {
				columns: columns,
				chartType: this._visToSmartsInfoMap[visId].chartType,
				allowBindingsWithWarnings: true
			};

			if (originalVisId && this._visToSmartsInfoMap[originalVisId]) {
				requestParameters.originalChartType = this._visToSmartsInfoMap[originalVisId].chartType;
			}

			return this._addCommonRequestParameters(requestParameters, requestOptions, true /*bPartialTempModule*/).then(function () {
				return _this3._recommenderService.recommendAlternateVisualizationsOrBindings(requestParameters).then(_this3._transformBindingRecommendationResponse.bind(_this3, visId, requestOptions.module));
			});
		},

		/**
   * Get recommendation info from the chartInfo endpoint of smarts server
   * @param {object}	options
   * @param {array} 	options.columns - list of columns and which slots they're mapped to
   * @param {string}	options.visId - id of vis type
   * @param {object}	options.requestOptions - other request-specific options
   * @return {object} payload from smarts server (including `label` attribute)
   */
		getRecommendInfo: function getRecommendInfo(_ref3) {
			var _this4 = this;

			var columns = _ref3.columns,
			    visId = _ref3.visId,
			    requestOptions = _ref3.requestOptions;

			var mapInfo = this._visToSmartsInfoMap[visId];

			if (!mapInfo) {
				return Promise.reject(new Error(this.getUnsupportedVizErrCode()));
			}

			columns = this._sanitizeColumnInfo(columns);

			var requestParameters = {
				columns: this._getColumnsInfoForBoundColumns(columns, mapInfo),
				chartType: this._visToSmartsInfoMap[visId].chartType
			};

			return this._addCommonRequestParameters(requestParameters, requestOptions, true /*bPartialTempModule*/).then(function () {
				return _this4._recommenderService.getChartInfo(requestParameters);
			});
		},

		getUnsupportedVizErrCode: function getUnsupportedVizErrCode() {
			return 'ERR_CODE_UNSUPPORTED_VIS';
		},

		_isSupportedViz: function _isSupportedViz(recommendation) {
			return this._supportedVisIds.indexOf(recommendation.chartType) !== -1;
		},

		_addCommonRequestParameters: function _addCommonRequestParameters(requestParameters, _ref4, bPartialTempModule) {
			var assetId = _ref4.assetId,
			    numResults = _ref4.numResults,
			    sourceType = _ref4.sourceType,
			    oneChartPerType = _ref4.oneChartPerType,
			    module = _ref4.module,
			    filters = _ref4.filters;

			var columnIds = requestParameters.columns.map(function (column) {
				return column.id;
			}).reduce(function (acc, columnIds) {
				return acc.concat(columnIds);
			}, []);

			var tempModuleJSON = bPartialTempModule ? module.copyPartialMoserModuleJSON(columnIds) : module.getTemporarySessionModuleJSON();

			var commonRequestParameters = {
				sourceModuleId: assetId,
				oneChartPerType: oneChartPerType || true,
				numResults: numResults || 10, //upper limit of recommendatations returned. 10 is arbitrary.
				sourceType: sourceType,
				shapedModule: !!module.getShapingId() //module has shaping
			};

			if (tempModuleJSON) {
				commonRequestParameters.tempModule = JSON.stringify(tempModuleJSON);
			}

			if (filters) {
				commonRequestParameters.filters = filters;
			}
			return module.saveTemporaryModule().then(function (shapingModuleId) {
				if (assetId !== shapingModuleId) {
					commonRequestParameters.tempModuleId = shapingModuleId;
				}
				return _.extend(requestParameters, commonRequestParameters);
			});
		},

		_transformRecommendationResponse: function _transformRecommendationResponse(dataSourceId, recommendations) {
			return recommendations.filter(this._isSupportedViz.bind(this)).filter(this._isSupportedBinding.bind(this, dataSourceId)).filter(this._hasSupportedFilter.bind(this)).map(this._transformRecommendation.bind(this));
		},

		//remove the duplicate recommendations but keep the first occurrence and preserve the order
		_stripDuplicates: function _stripDuplicates(recommendations) {
			var result = [];
			var map = new Map();
			for (var _iterator = recommendations, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
				var _ref5;

				if (_isArray) {
					if (_i >= _iterator.length) break;
					_ref5 = _iterator[_i++];
				} else {
					_i = _iterator.next();
					if (_i.done) break;
					_ref5 = _i.value;
				}

				var recommendation = _ref5;

				if (!map.has(recommendation.visId)) {
					map.set(recommendation.visId, true);
					result.push(recommendation);
				}
			}
			return result;
		},

		/**
  * This method should be overriden as needed to provide the proper transformation
  * @ params {recommendation}
  * @ returns
  *	{
  *		visId: <visId>
  *		slots : {slotId_1 : [columnIds],
  *			    slotId_2: [columnIds],
  *				:
  *				}
  *		label: <label>
  *		description: <description>
  *		title: <title>
  *	}
  */
		_transformRecommendation: function _transformRecommendation(recommendation) {
			var chartType = recommendation.chartType,
			    label = recommendation.label,
			    description = recommendation.description,
			    title = recommendation.title,
			    columns = recommendation.columns,
			    filters = recommendation.filters,
			    autoGroupingMap = recommendation.autoGroupingMap;

			var smartsToVisMap = this._smartsToVisInfoMap[chartType];

			return {
				label: label,
				description: description,
				title: title,
				visId: smartsToVisMap.visId,
				topBottom: this._transformTopBottomFromSmartsFilters(filters),
				filters: this._transformFiltersFromSmartsFilters(filters),
				autoGroup: this._transformAutoGroupFromSmartsAutoGroupingMap(autoGroupingMap),
				slots: this._transformFromSmartsColumnInfo(columns, smartsToVisMap)
			};
		},

		_getColumnsInfo: function _getColumnsInfo(columnIds) {
			return columnIds.map(function (columnId) {
				return { id: [columnId] };
			});
		},

		_sanitizeColumnInfo: function _sanitizeColumnInfo(boundColumnsInfo) {
			return boundColumnsInfo.map(function (info) {
				return {
					slotId: info.slotId,
					columnIds: _.without(info.columnIds, SlotAPIHelper.MULTI_MEASURES_SERIES)
				};
			}).filter(function (info) {
				return info.columnIds.length > 0;
			});
		},

		/** Massage the given boundColumnsInfo into one that Smarts understand
  *	Transform
  *	[{
  *		slotId: <slotId>,
  *		columnIds: [<column ids>]
  *   }, {..}]
  * 	to
  *	[{
  *		slot: <slot name>
  *		id: [<column ids>]
  *	}, {..}]
  *
  */
		_getColumnsInfoForBoundColumns: function _getColumnsInfoForBoundColumns(boundColumnsInfo, mapInfo) {
			return boundColumnsInfo.map(function (columnInfo) {
				return {
					slot: mapInfo[columnInfo.slotId],
					id: columnInfo.columnIds
				};
			});
		},

		_transformAutoGroupFromSmartsAutoGroupingMap: function _transformAutoGroupFromSmartsAutoGroupingMap() {
			var autoGroupingMap = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

			return Object.keys(autoGroupingMap).map(function (itemId) {
				var value = autoGroupingMap[itemId];
				return _extends({
					itemId: itemId
				}, value);
			});
		},

		_transformTopBottomFromSmartsFilters: function _transformTopBottomFromSmartsFilters() {
			var filters = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];

			return filters.filter(function (filter) {
				return filter.type === 'TOP_BOTTOM';
			}).map(function (filter) {
				return {
					itemId: filter.columnId,
					spec: {
						type: IRUtils.IRToTopBottomType(filter.topBottomType, filter.method),
						value: filter.domainSize,
						context: filter.byColumn,
						aggregate: 'sum' // TODO
					}
				};
			});
		},

		_transformFiltersFromSmartsFilters: function _transformFiltersFromSmartsFilters() {
			var filters = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];

			return filters.filter(function (filter) {
				return filter.type !== 'TOP_BOTTOM';
			}).map(function (filter) {
				return IRUtils.IRFilters2LocalFilter(filter);
			});
		},

		_transformFromSmartsColumnInfo: function _transformFromSmartsColumnInfo(columns, smartsToVisMap) {
			var slotToColumnIdsMap = {};

			columns.forEach(function (column) {
				var slotId = smartsToVisMap[column.slot];
				var columnIds = slotToColumnIdsMap[slotId] || [];

				slotToColumnIdsMap[slotId] = columnIds.concat(column.id);
			});
			return slotToColumnIdsMap;
		},

		/*
  * When a visualization is not supported by Smarts vis recommender,  it is map to one that is supported
  * that has the same number and type of slots.  This is only for recommend binding request.
   */
		_getSmartsToVisMappingForUnsupportedVisualization: function _getSmartsToVisMappingForUnsupportedVisualization(visId) {
			var smartsToVisMap = {};
			var oldMapInfo = this._visToSmartsInfoMap[visId];
			var chartProps = Object.keys(oldMapInfo);
			chartProps.forEach(function (prop) {
				if (prop === 'chartType') {
					smartsToVisMap.visId = visId;
				} else {
					smartsToVisMap[oldMapInfo[prop]] = prop;
				}
			});
			return smartsToVisMap;
		},

		_transformBindingRecommendationResponse: function _transformBindingRecommendationResponse(visId, module, bindingRecommendations) {
			var _this5 = this;

			var smartsToVisMap = void 0;
			if (UnsupportedSmartsVis.indexOf(visId) > -1) {
				smartsToVisMap = this._getSmartsToVisMappingForUnsupportedVisualization(visId);
			}
			return bindingRecommendations.map(function (bindingRec) {
				var chartType = bindingRec.chartType,
				    columns = bindingRec.columns,
				    unbound = bindingRec.unbound;

				smartsToVisMap = !smartsToVisMap ? _this5._smartsToVisInfoMap[chartType] : smartsToVisMap;

				return {
					visId: visId || smartsToVisMap.visId,
					slots: _this5._transformFromSmartsColumnInfo(columns, smartsToVisMap),
					unbound: unbound
				};
			});
		},

		/**
   * 	Returns true if the slot binding recommendation is supported for the
   * 	specified chart type
   */
		_isSupportedBinding: function _isSupportedBinding(dataSourceId, _ref6) {
			var chartType = _ref6.chartType,
			    columns = _ref6.columns;

			switch (chartType.toUpperCase()) {

				case 'SPIRAL':
					return this._isSupportedSpiral(dataSourceId, columns);

				default:
					return true;
			}
		},

		_hasSupportedFilter: function _hasSupportedFilter(recommendation) {
			if (recommendation) {
				var filters = recommendation.filters;
				if (filters && filters.length > 0) {
					var isProjected = function isProjected(columnId) {
						var columns = recommendation.columns || [];
						var isOnASlot = columns.some(function (column) {
							if (column.id.indexOf(columnId) !== -1) {
								return true;
							}
							return false;
						});
						return isOnASlot;
					};
					var isIncompatible = filters.some(function (filter) {
						if (filter.type === 'TOP_BOTTOM') {
							if (!isProjected(filter.columnId)) {
								return true;
							} else {
								return false;
							}
						}
						return false;
					});
					return !isIncompatible;
				}
			}
			return true;
		},

		/**
   * Returns false if Driver analysis viz has attribute type bound to TARGET slot
   * @param module
   * @param columns
   * @returns {boolean}
   * @private
   */
		_isSupportedSpiral: function _isSupportedSpiral(dataSourceId, columns) {
			var dataSource = this.dataSources.getDataSource(dataSourceId);
			var containsOlapItem = columns.some(function (column) {
				var mdColumn = dataSource.getMetadataColumn(column.id);
				return mdColumn && mdColumn.isOlapColumn();
			});

			var module = this.moserDataSources.getModule(dataSourceId);
			// Spiral/Comet/Sunburst/Decision Tree charts are not supported for OLAP data
			return !(containsOlapItem || module.isOlapPackage());
		}

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