'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 Business Analytics (C) Copyright IBM Corp. 2020
 * US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */

/**
 * @class VisDndLiveWidgetProvider
 * @hideconstructor
 *
 * @classdesc Handles drag and drop of metadata to create a visualization.
 */
define(['underscore', 'jquery', 'dashboard-analytics/widgets/livewidget/nls/StringResources'], function (_, $, StringResources) {

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

			_classCallCheck(this, VisDndLiveWidgetProvider);

			this.dashboardAPI = options.dashboardAPI;
			this.dashboardDnD = options.dashboardDnD;
			this.content = options.content;
			this.visualization = options.visualization;
			this.state = options.state;
			this.visRecommender = options.visRecommender;
			this.visDnDUtils = options.visDnDUtils;
			this.transaction = options.transaction;
		}

		VisDndLiveWidgetProvider.prototype.destroy = function destroy() {
			this.dashboardAPI = null;
			this.dashboardDnD = null;
			this.content = null;
			this.visualization = null;
			this.state = null;
			this.visRecommender = null;
			this.visDnDUtils = null;
			this.transaction = null;
		};

		VisDndLiveWidgetProvider.prototype.isInvalidVisDefinition = function isInvalidVisDefinition(target) {
			var $errorContainer = $(target.info.node).find('.vis-sdk-error-container-wrapper');
			if ($errorContainer.length > 0) {
				return true;
			}

			var definition = this.visualization.getDefinition();
			return definition && definition.getState().getError() !== undefined;
		};

		/**
   * Adds the model filters among the mappings to the local filters.
   * @param metadataColumns an array of metadataColumns to be added to the visualization
   * @returns remaining mappings that are not a model filter
   */


		VisDndLiveWidgetProvider.prototype.addModelFilters = function addModelFilters(metadataColumns, transactionToken) {
			var modelFilters = [];

			var nonFilterMetadataColumns = _.filter(metadataColumns, function (metadataColumn) {
				if (metadataColumn.isFilter()) {
					modelFilters.push(metadataColumn.getId());
					return false;
				}
				return true;
			});

			if (modelFilters.length > 0) {
				this._setModelFilter(modelFilters, transactionToken);
			}

			return nonFilterMetadataColumns;
		};

		VisDndLiveWidgetProvider.prototype._setModelFilter = function _setModelFilter(modelfilterId, transactionToken) {
			var localFilters = this.visualization.getLocalFilters();

			modelfilterId = $.isArray(modelfilterId) ? modelfilterId : [modelfilterId];

			_.each(modelfilterId, function (id) {
				var itemContext = {
					id: id,
					itemId: id,
					filterType: 'filter'
				};
				localFilters.addFilter(itemContext, {} /* filterContext */, transactionToken);
			});
		};

		VisDndLiveWidgetProvider.prototype._addFiltersForMembers = function _addFiltersForMembers(filterSpecs, visualization, transactionToken) {
			if (!filterSpecs.length) {
				return;
			}
			var localFilters = visualization.getLocalFilters();
			var dataItemList = visualization.getSlots().getDataItemList();
			filterSpecs.forEach(function (spec) {
				//if dataItem is added to slot or visualization, then add filters,
				// if dataItem is not added due to any reason, do not add filters
				var filterColumnId = spec.itemContext.itemId;
				var dataItem = dataItemList.find(function (dataItem) {
					return dataItem.getColumnId() === filterColumnId;
				});
				if (dataItem) {
					if (spec.hasFilters) {
						localFilters.editFilter(spec.itemContext, spec.filterContext, transactionToken);
					} else {
						localFilters.addFilter(spec.itemContext, spec.filterContext, transactionToken);
					}
				}
			});
		};

		VisDndLiveWidgetProvider.prototype.supports = function supports(source, target) {
			return target.type === 'widget.live' && source.type !== 'widget';
		};

		VisDndLiveWidgetProvider.prototype.accepts = function accepts(source, target) {
			if (target && target.type === 'widget.live') {
				if (this.isInvalidVisDefinition(target)) {
					//No definitions so do not all metadata drag and drop
					return false;
				}

				if (this.content) {
					if (this.state && this.state.getError()) {
						return false;
					}
				}

				if ($(target.info.node).hasClass('liveWidgetPreview')) {
					return false;
				}

				if (this.content) {
					return this.visDnDUtils.accepts(source, target);
				}
			}
			return false;
		};

		VisDndLiveWidgetProvider.prototype.onDrop = function onDrop(source, target) {
			var _this = this;

			if (target.type !== 'widget.live') {
				return;
			}

			var visDef = this.visualization.getDefinition();
			if (visDef.getState().getError()) {
				return;
			}
			if (!this.visExpandMode || this.visExpandMode && !this.visExpandMode.onDrop(source)) {
				if (this.visRecommender) {
					var metadataPayload = this.visDnDUtils.onDrop(source);
					var droppedColumns = metadataPayload.columns;
					if (!this.visDnDUtils.validateSupportsOLAP(droppedColumns.map(function (c) {
						return c.metadataColumn;
					}))) {
						this.dashboardAPI.getFeature('Notification').setMessage(StringResources.get('visualizationDoesNotSupportOLAP'));
						return;
					}
					var metadataColumns = _.pluck(droppedColumns, 'metadataColumn');

					var transactionToken = this.transaction.startTransaction();

					// We add model filters first
					metadataColumns = this.addModelFilters(metadataColumns, transactionToken);

					var filterSpecsForMembers = [];
					if (metadataColumns.length) {
						filterSpecsForMembers = this.visDnDUtils.addMembersAsLocalFilters({
							visualizationAPI: this.visualization,
							columns: metadataPayload.columns,
							doUpdateFilters: false
						}, transactionToken);
						metadataColumns = _.pluck(droppedColumns, 'metadataColumn');
					}

					var endTransaction = function endTransaction() {
						// Add the filters for items that are add as dataitems
						_this._addFiltersForMembers(filterSpecsForMembers, _this.visualization, transactionToken);
						_this.transaction.endTransaction(transactionToken);
					};
					if (metadataColumns.length > 0) {
						var sourceId = source.data.sourceId;
						var dataSource = this.visualization.getDataSource();
						// Create a transcation so that we can bundle the dataSource id change with the mapping

						if (!dataSource || dataSource.getId() != sourceId) {
							this.visualization.setDataSource(sourceId, transactionToken);
						}

						// The viz might not support the datasource so it might not be set
						var isDataSourceSet = !!this.visualization.getDataSource();
						if (isDataSourceSet) {
							// remove all filters
							var dataItems = metadataColumns.filter(function (mc) {
								return !mc.isFilter();
							}).map(function (column) {
								return {
									columnId: column.getId()
								};
							});
							this.visRecommender.addDataItems(dataItems, transactionToken).finally(function () {
								endTransaction();
							});
						} else {
							endTransaction();
						}
					} else {
						endTransaction();
					}
				}
			}
		};

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