'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 VisDnDUtils
 * @hideconstructor
 *
 * @classdesc Utility feature for drag and drop of metadata onto a visualization content
 */
define(['underscore', '../../../lib/@waca/dashboard-common/dist/core/APIFactory', './api/VisDnDUtilsAPI', './OlapHelper.v2', './LocalFilterMemberDNDHelper', './VisMapColumnsToSlot', 'dashboard-analytics/dataSources/utils/ShapingUIUtils', './api/impl/VisDnDColumnToSlotProvider', './api/impl/VisDnDSlotToSlotProvider', './api/impl/VisDnDShapeToSlotProvider', './api/impl/VisDnDSlotLocalFilterProvider', './api/impl/VisDndLiveWidgetProvider', 'dashboard-analytics/dataSources/utils/ShapingConstants', 'dashboard-analytics/apiHelpers/SlotAPIHelper'], function (_, APIFactory, VisDnDUtilsAPI, OlapHelperV2, LocalFilterMemberDNDHelper, VisMapColumnsToSlot, ShapingUIUtils, VisDnDColumnToSlotProvider, VisDnDSlotToSlotProvider, VisDnDShapeToSlotProvider, VisDnDSlotLocalFilterProvider, VisDndLiveWidgetProvider, ShapingConstants, SlotAPIHelper) {

	var METADATA_TYPES = ['MODEL_ITEM', 'GRID_HEADER_ITEM', 'filter' // Used for FM package model filters ?
	];

	var VisDnDUtils = function () {
		function VisDnDUtils(_ref) {
			var features = _ref.features,
			    content = _ref.content;

			_classCallCheck(this, VisDnDUtils);

			this.content = content;
			this.dashboard = features['API'];
			this.dashboardDnD = features['Dashboard.DashboardDnd'];
			this.transaction = features['Dashboard.Transaction'];
			this.datasources = features['Dashboard.DataSources'];
			this.datasourcesMoser = features['Dashboard.DataSources.moser'];
			this.state = features['state'];
			this.visualization = features['Visualization'];
			this.visRecommender = features['Visualization.SmartsRecommender'];
			this.visDnD = features['VisDnD'];

			this.olapHelper = new OlapHelperV2(this.dashboard, this.visualization);
			this.visMapColumnsToSlot = new VisMapColumnsToSlot({
				content: this.content,
				visualization: this.visualization,
				transaction: this.transaction
			});

			this._initializeProviders();
		}

		VisDnDUtils.prototype.getAPI = function getAPI() {
			if (!this.api) {
				this.api = APIFactory.createAPI(this, [VisDnDUtilsAPI]);
			}
			return this.api;
		};

		VisDnDUtils.prototype._initializeProviders = function _initializeProviders() {
			var param = {
				visDnDUtils: this,
				dashboardAPI: this.dashboard,
				dashboardDnD: this.dashboardDnD,
				datasources: this.datasources,
				datasourcesMoser: this.datasourcesMoser,
				transaction: this.transaction,
				content: this.content,
				state: this.state,
				visualization: this.visualization,
				visRecommender: this.visRecommender
			};

			// Register the all livewidget providers
			var shapeToSlotProvider = new VisDnDShapeToSlotProvider(param);
			this.visDnD.registerProviders('widget.live', [new VisDndLiveWidgetProvider(param), shapeToSlotProvider], ['slot.item']);

			// Register the all slot.item providers
			var slotItemProviders = [VisDnDColumnToSlotProvider, VisDnDSlotToSlotProvider].map(function (ProviderClass) {
				return new ProviderClass(param);
			});
			this.visDnD.registerProviders('slot.item', [].concat(slotItemProviders, [shapeToSlotProvider]));

			// Register the slot.filter provider
			this.visDnD.registerProviders('slot.filter', [new VisDnDSlotLocalFilterProvider(param)]);
		};

		VisDnDUtils.prototype.destroy = function destroy() {
			this.dashboard = null;
			this.content = null;
			this.transaction = null;
			this.visualization = null;

			this.olapHelper = null;
			this.visMapColumnsToSlot = null;
		};

		VisDnDUtils.prototype._isSameDataSource = function _isSameDataSource(dragData) {
			var sourceId = dragData.sourceId;
			var dataSource = this.visualization.getDataSource();
			var currentModuleId = dataSource ? dataSource.getId() : null;
			return currentModuleId && sourceId !== currentModuleId ? false : true;
		};

		/**
   * return all the projected dataItems except MultiMeasure item.
   */


		VisDnDUtils.prototype._getProjectedDataItemList = function _getProjectedDataItemList() {
			if (!this.visualization) {
				throw new Error('Invalid visualization');
			}

			var dataItemList = this.visualization.getSlots().getDataItemList();
			dataItemList = dataItemList.filter(function (dataItem) {
				return dataItem.getColumnId() !== SlotAPIHelper.MULTI_MEASURES_SERIES;
			});
			return dataItemList.map(function (dataItem) {
				return dataItem.getMetadataColumn();
			});
		};

		VisDnDUtils.prototype._acceptsOlapColumnsV2 = function _acceptsOlapColumnsV2(payload, _ref2) {
			var dropTarget = _ref2.dropTarget,
			    dropAction = _ref2.dropAction;

			var metadataColumns = _.map(payload.data.columns, function (column) {
				return column.metadataColumn;
			});
			if (dropTarget === ShapingConstants.DROP_TARGET_OPTIONS.FILTER || !metadataColumns.some(function (col) {
				return col.isOlapColumn();
			})) {
				return true;
			}

			var targetSlotId = void 0;
			var position = void 0,
			    bReplace = void 0;
			if (dropAction) {
				//When dnd hover on crosstab, GridDnDManager composes dropAction and call VisDnD.accepts()
				position = dropAction.actionSpec.position;
				bReplace = dropAction.actionSpec.replace;
				var targetSlotAPI = dropAction.actionSpec.slot;
				targetSlotId = targetSlotAPI.getDefinition().getId();
			} else {
				return true;
			}

			return this.acceptsOlapV2({
				targetSlotId: targetSlotId,
				sourceSlotId: undefined,
				indexInSourceSlot: undefined,
				sourceColumns: metadataColumns,
				indexInTargetSlot: position,
				isReplace: bReplace
			});
		};

		VisDnDUtils.prototype.accepts = function accepts() {
			var payload = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
			var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

			//No visualizationAPI return false
			//No metadata provided return false
			if (!this.visualization || !payload.data || !this._isSameDataSource(payload.data)) {
				return false;
			}

			// No restrictions need to be applied when drop target is filter.
			var checkHierarchy = !options || options.dropTarget !== ShapingConstants.DROP_TARGET_OPTIONS.FILTER;
			if (checkHierarchy) {
				/**
     * Map of hierarchies used to check if the dragObject follows the drop rules.
     */
				var oHierarchyMap = {};
				var metadataColumns = _.map(payload.data.columns, function (columns) {
					return columns.metadataColumn;
				});
				var metadataColumnsWithMembers = payload.data.utils && payload.data.utils.getColumnsWithMembers();

				// Check the metadata item(s) in dragObject
				if (!metadataColumns) {
					return false;
				}

				if (ShapingUIUtils.isInvalidDragObject(metadataColumns, oHierarchyMap, metadataColumnsWithMembers)) {
					return false;
				}

				// Check dragObject with widget metadata
				// Members from the same hierarchy can only be dropped to same slot.
				var projectedMetadataColumns = this._getProjectedDataItemList();
				if (options.dropTarget === ShapingConstants.DROP_TARGET_OPTIONS.SLOT) {
					var slotMetadataColumnIds = [];
					if (options.targetNode) {
						var slotId = options.targetNode.getAttribute('data-slot-id');
						var slotDataItemList = slotId && this.visualization.getSlots().getSlot(slotId).getDataItemList();
						slotMetadataColumnIds = _.map(slotDataItemList, function (dataItem) {
							return dataItem.getColumnId() !== SlotAPIHelper.MULTI_MEASURES_SERIES;
						}).filter(Boolean);
					}

					// Get restricted columns that are not in the target slot
					var columnsNotInTargetSlot = slotMetadataColumnIds.length ? _.filter(projectedMetadataColumns, function (column) {
						return slotMetadataColumnIds.indexOf(column.getId()) === -1;
					}) : projectedMetadataColumns;
					// Restrict any metadata object from the same hierarchy to be dropped to a different slot
					var dragColumnProjected = _.some(columnsNotInTargetSlot, function (column) {
						return _.some(metadataColumns, function (dragColumn) {
							return column.getId() === dragColumn.getId() && (column.isHierarchy() || column.isNamedSet());
						});
					});
					if (dragColumnProjected) {
						return false;
					}
				}

				if (ShapingUIUtils.isInvalidDragObject(projectedMetadataColumns, oHierarchyMap, null, /** metadataColumnsExist */true)) {
					return false;
				}
			}
			var expandCollapseFeatureFlag = !this.dashboard.getGlassCoreSvc('.FeatureChecker').checkValue('dashboard', 'expandCollapse', 'disabled');
			if (expandCollapseFeatureFlag && this.visualization.getType() === 'Crosstab') {
				if (!this._acceptsOlapColumnsV2(payload, options)) {
					return false;
				}
			}
			return payload.data && payload.data.utils && payload.data.utils.isValid(options) && METADATA_TYPES.indexOf(payload.type) !== -1 ? true : false;
		};

		VisDnDUtils.prototype.onDrop = function onDrop(payload) {
			return METADATA_TYPES.indexOf(payload.type) !== -1 ? payload.data : null;
		};

		VisDnDUtils.prototype.mapColumns = function mapColumns(slotId, droppedColumns, options, transactionToken) {
			return this.visMapColumnsToSlot.mapColumns(slotId, droppedColumns, options, transactionToken);
		};

		VisDnDUtils.prototype.acceptsOlapV2 = function acceptsOlapV2(params) {
			return this.olapHelper.acceptsOlapV2(params);
		};

		VisDnDUtils.prototype.addMembersAsLocalFilters = function addMembersAsLocalFilters() {
			var _this = this;

			var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
			var transactionToken = arguments[1];

			var dataItemList = options.slotAPI ? options.slotAPI.getDataItemList() : this.visualization.getSlots().getDataItemList();
			var columns = options.columns ? options.columns.slice() : [];
			var removedExistingDataItem = options.columns || [];
			var _removeResultFn = function (index) {
				if (index > -1 && index < columns.length) {
					removedExistingDataItem.splice(index, 1);
				}
			}.bind(this);

			var localFiltersSpec = [];
			columns.forEach(function (column) {
				var newLocalFilters = column.original.members;

				if (newLocalFilters && newLocalFilters.length) {
					var hasMappedDatItem = LocalFilterMemberDNDHelper.hasDataItem(dataItemList, column.metadataColumn.getId());
					var itemContext = LocalFilterMemberDNDHelper.getItemContext(dataItemList, column.original.metadataColumn);
					LocalFilterMemberDNDHelper.addOrUpdateFilter({
						bReplace: options.bReplace,
						itemContext: itemContext,
						localFilters: _this.visualization.getLocalFilters(),
						newLocalFilters: newLocalFilters,
						localFiltersSpec: localFiltersSpec,
						doUpdateFilters: options.doUpdateFilters
					}, transactionToken);

					var appendMembersToExistingDataItem = hasMappedDatItem && !options.bReplace;

					if (appendMembersToExistingDataItem) {
						removedExistingDataItem.forEach(function (col, index) {
							if (column.metadataColumn.getId() === col.metadataColumn.getId()) {
								_removeResultFn(index);
								return;
							}
						});
					}
				}
			});
			return localFiltersSpec;
		};

		VisDnDUtils.prototype.exceedsItemsLimit = function exceedsItemsLimit(countOfItemsToDrop, indexInSlot, addAfter, slot) {
			var limit = slot.getDefinition().getMaxItems();
			if (typeof limit !== 'number' || limit < 0) {
				// no limit verification if maxItems is null or undefined or something else than a positive number (0 is considered as positive in this function)
				return false;
			}
			var mappedItems = slot.getDataItemList().length;
			//When dropping on top of an existing slot dataItem, we replace it with the items we're dropping.
			//EXCEPTION....for index===-1, we always add to the existing set of items.
			//indexInSlot===-1 means add at the end.
			//indexInSlot===-1 and addAfter = true means add at the beginning.
			var mappedItemsAfterDrop = countOfItemsToDrop + mappedItems - (addAfter || indexInSlot === -1 ? 0 : 1);
			return mappedItemsAfterDrop > limit;
		};

		VisDnDUtils.prototype.validateSupportsOLAP = function validateSupportsOLAP(metadataColumns) {
			var supported = true;
			var visDefinition = this.visualization.getDefinition();
			if (visDefinition.getProperty('supportsOLAP') === false) {
				metadataColumns && metadataColumns.forEach(function (metadataColumn) {
					if (metadataColumn.isOlapColumn() || metadataColumn.isNamedSet()) {
						supported = false;
					}
				});
			}
			return supported;
		};

		return VisDnDUtils;
	}();

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