"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. 2019, 2020
 * US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */

/**
 * @class SlotMappingModel
 * @hideconstructor
 * @classdesc Provides access to the slot mapping model
 */
define([], function () {
	return function () {
		function SlotMappingModel(slotMappingModelJson) {
			_classCallCheck(this, SlotMappingModel);

			this._slotMappingModel = slotMappingModelJson;
			if (!this._slotMappingModel.slots) {
				this._slotMappingModel.slots = [];
			}
			if (!this._slotMappingModel.multiMeasureGroups) {
				this._slotMappingModel.multiMeasureGroups = {};
			}
		}

		SlotMappingModel.prototype.getSlotList = function getSlotList() {
			return this._slotMappingModel.slots;
		};

		// Remove a slot from the model


		SlotMappingModel.prototype.removeSlot = function removeSlot(slotId) {
			this._slotMappingModel.slots = this._slotMappingModel.slots.filter(function (slot) {
				return slot.name !== slotId;
			});
		};

		// Get a slot with a given id. If one does not exist, it will be created


		SlotMappingModel.prototype.getSlot = function getSlot(slotId) {
			var slot = void 0;
			for (var i = 0; i < this._slotMappingModel.slots.length; i++) {
				if (this._slotMappingModel.slots[i].name === slotId) {
					slot = this._slotMappingModel.slots[i];
					break;
				}
			}
			if (!slot) {
				slot = {
					name: slotId
				};
				this._slotMappingModel.slots.push(slot);
			}
			if (!slot.dataItems) {
				slot.dataItems = [];
			}
			return slot;
		};

		SlotMappingModel.prototype._getMultiMeasureGroup = function _getMultiMeasureGroup(dataset) {
			return this._slotMappingModel.multiMeasureGroups[dataset];
		};

		SlotMappingModel.prototype._initMultiMeasureGroup = function _initMultiMeasureGroup(dataset) {
			if (!this._slotMappingModel.multiMeasureGroups[dataset]) {
				this._slotMappingModel.multiMeasureGroups[dataset] = {};
			}
		};

		SlotMappingModel.prototype.getMultiMeasureSlotId = function getMultiMeasureSlotId(dataset) {
			var group = this._getMultiMeasureGroup(dataset);
			return group && group.slotId;
		};

		SlotMappingModel.prototype.setMultiMeasureSlotId = function setMultiMeasureSlotId(dataset, slotId) {
			this._initMultiMeasureGroup(dataset);
			var group = this._getMultiMeasureGroup(dataset);
			group.slotId = slotId;
		};

		SlotMappingModel.prototype.getMultiMeasurePosition = function getMultiMeasurePosition(dataset) {
			var group = this._getMultiMeasureGroup(dataset);
			return group ? group.position : -1;
		};

		SlotMappingModel.prototype.setMultiMeasurePosition = function setMultiMeasurePosition(dataset, position) {
			this._initMultiMeasureGroup(dataset);
			var group = this._getMultiMeasureGroup(dataset);
			group.position = position;
		};

		SlotMappingModel.prototype.getMappedDataItemIdList = function getMappedDataItemIdList(slotId) {
			var dataItemIds = [];
			this._slotMappingModel.slots.forEach(function (slot) {
				if (slot.dataItems && (!slotId || slotId === slot.name)) {
					dataItemIds = dataItemIds.concat(slot.dataItems);
				}
			});
			return dataItemIds;
		};

		// Get the slot that is mapped to a given dataitem


		SlotMappingModel.prototype.getMappedSlot = function getMappedSlot(dataItemId) {
			var slot = void 0;
			for (var i = 0; i < this._slotMappingModel.slots.length; i++) {
				var dataItems = this._slotMappingModel.slots[i].dataItems;
				if (dataItems) {
					for (var j = 0; j < dataItems.length; j++) {
						if (dataItems[j] === dataItemId) {
							slot = this._slotMappingModel.slots[i];
							break;
						}
					}
				}
				if (slot) {
					break;
				}
			}
			return slot;
		};

		// Add a dataItem mapping to a given slot


		SlotMappingModel.prototype.mapDataItemsToSlot = function mapDataItemsToSlot(dataItemIdList, slotId) {
			var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;

			this.unmapDataItemsFromSlots(dataItemIdList);
			var slot = this.getSlot(slotId);
			if (index < 0) {
				var _slot$dataItems;

				(_slot$dataItems = slot.dataItems).push.apply(_slot$dataItems, dataItemIdList);
			} else {
				var _slot$dataItems2;

				(_slot$dataItems2 = slot.dataItems).splice.apply(_slot$dataItems2, [index, 0].concat(dataItemIdList));
			}
		};

		// Add a dataItem mapping to a given slot


		SlotMappingModel.prototype.unmapDataItemsFromSlots = function unmapDataItemsFromSlots(dataItemIdList) {
			var _this = this;

			dataItemIdList.forEach(function (dataItemId) {
				var currentMappedSlot = _this.getMappedSlot(dataItemId);
				if (currentMappedSlot) {
					currentMappedSlot.dataItems = currentMappedSlot.dataItems.filter(function (id) {
						return dataItemId !== id;
					});
					if (currentMappedSlot.dataItems.length === 0) {
						_this.removeSlot(currentMappedSlot.name);
					}
				}
			});
		};

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