'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 Cognos Products: BI Cloud (C) Copyright IBM Corp. 2019, 2020
 * US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */
define(['underscore', '../dataSources/metadata/MetadataColumn', 'bi/moser/moser.min'], function (_, MetadataColumn, MoserJS) {

	var SUPPORTED_SOURCE_CATEGORY_TYPES = [MoserJS.default.SourceCategoryType.HIERARCHY_LEVEL, MoserJS.default.SourceCategoryType.HIERARCHY_PARENT_CHILD, //member based hierachy, always return a hieararchy since there are no levels
	MoserJS.default.SourceCategoryType.LEVEL, MoserJS.default.SourceCategoryType.COLUMN //@todo return null what do we do so does it  break R3?
	];

	var ANCESTOR_TYPES = [MoserJS.default.MoserObjectTypes.QUERY_ITEM];

	/**
  * Limitations enforce by DSS:
  *
  * Cannot drop level and hierarchy to same slot
  * Cannot drop multiple hiearachies in same dimension: eg Years and Currently
  * Can drop different hieararchies from differnt dimensions : eg Years and Product
  *
  * Just document the limitations here since these should have already handle by drag and drop in R3
 */

	return function () {
		function MetadataDNDMapping(moduleAPI, dashboard) {
			var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

			_classCallCheck(this, MetadataDNDMapping);

			this.moduleAPI = moduleAPI;
			this.dashboard = dashboard;
			this.dataSource = this.dashboard.getFeature('DataSources').getDataSource(moduleAPI.getSourceId());
			this.moserObjects = options.moserObjects || [];
			this.dNDResults = [];
			this._processMetadataMapping();
		}

		MetadataDNDMapping.prototype.getMappedResults = function getMappedResults() {
			return this.dNDResults;
		};

		MetadataDNDMapping.prototype.getUtils = function getUtils() {
			return {
				getColumnsWithMembers: this.getColumnsWithMembers.bind(this)
			};
		};

		MetadataDNDMapping.prototype.getColumnsWithMembers = function getColumnsWithMembers() {
			var filterMemberColumns = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;

			var columnsWithMembers = {};
			_.each(this.dNDResults, function (result) {
				var metadataColumn = result.mappedMetadataColumn;
				var members = result.members;
				// Refer to members since it's mapped from a member.
				if (metadataColumn) {
					if (!filterMemberColumns || members.length) {
						columnsWithMembers[metadataColumn.getId()] = members;
					}
				}
			});
			return columnsWithMembers;
		};

		MetadataDNDMapping.prototype._processMetadataMapping = function _processMetadataMapping() {
			var _this = this;

			this.moserObjects.forEach(function (moserObject) {
				var payload = {};
				var sourceCategory = void 0;
				var mappedMoserObject = void 0;
				if (!_this._isMemberType(moserObject)) {
					mappedMoserObject = moserObject;
				} else {
					var searchMoserObject = _this._memberSearchSubject();
					mappedMoserObject = _this._getMappedMoserObject(moserObject, searchMoserObject);
					if (mappedMoserObject) {
						sourceCategory = _this._getSourceCategory(mappedMoserObject);
						if (SUPPORTED_SOURCE_CATEGORY_TYPES.indexOf(sourceCategory) !== -1) {
							payload.members = {
								id: moserObject.getIdForExpression(),
								memberCaption: moserObject.getMemberCaption() //example Camping Equipment
							};
							mappedMoserObject = _this._normalizeMappedMoserObject(mappedMoserObject, moserObject, sourceCategory);
						} else {
							//@todo not sure what this this so add to be save
							mappedMoserObject = moserObject;
						}
					} else {
						/*Get here when one of the following is true:
       *
       * 1. Select Product line from a relation source
       * 2. A measure like Revenue from relational source
       * 3. A measure like Revenue from OLAP source
      */

						mappedMoserObject = moserObject;
					}
				}

				// query item from navigation group is a referenced object
				var referencedObject = mappedMoserObject.getReferencedObject ? mappedMoserObject.getReferencedObject() : null;
				if (referencedObject) {
					payload.referencedObject = _this.dataSource.getMetadataColumn(referencedObject.getIdForExpression());
				}
				payload.mappedMetadataColumn = _this.dataSource.getMetadataColumn(mappedMoserObject.getIdForExpression());
				_this._addDNDResult(payload);
			});
		};

		MetadataDNDMapping.prototype._getSourceCategory = function _getSourceCategory(mappedMoserObject) {
			var sourceCategory = mappedMoserObject.getSourceCategory();
			if (!sourceCategory && mappedMoserObject.getObjectType() === MoserJS.default.MoserObjectTypes.QUERY_ITEM) {
				sourceCategory = MoserJS.default.SourceCategoryType.COLUMN;
			}
			return sourceCategory;
		};

		MetadataDNDMapping.prototype._getMappedMoserObject = function _getMappedMoserObject(moserObject, searchMoserObject) {
			if (!searchMoserObject) {
				//Note drag members from the rootMember, this function also return a level so it treats rootMember as like any other regular level
				return MoserJS.default.ModuleUtils.getTreeAncestor(moserObject, ANCESTOR_TYPES);
			} else if (searchMoserObject && this._isMemberType(searchMoserObject)) {
				return MoserJS.default.ModuleUtils.getTreeAncestor(searchMoserObject, ANCESTOR_TYPES);
			}
			return searchMoserObject;
		};

		MetadataDNDMapping.prototype._memberSearchSubject = function _memberSearchSubject() {
			return this.moduleAPI.getShapingHelper().getMemberSearchSubject();
		};

		MetadataDNDMapping.prototype._isMemberType = function _isMemberType(moserObject) {
			return moserObject.getObjectType() === 'MemberType';
		};

		MetadataDNDMapping.prototype._normalizeMappedMoserObject = function _normalizeMappedMoserObject(mappedMoserObject, moserObject, sourceCategory) {
			if (sourceCategory === MoserJS.default.SourceCategoryType.LEVEL) {
				var metadataColumn = this.moduleAPI.getMetadataColumn(moserObject.getLevelUniqueName());
				return metadataColumn.moserObject;
			}
			return mappedMoserObject;
		};

		MetadataDNDMapping.prototype._addDNDResult = function _addDNDResult() {
			var payload = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

			var dnDResult = this.dNDResults.find(function (result) {
				if (payload.mappedMetadataColumn && result.mappedMetadataColumn) {
					return result.mappedMetadataColumn.getId() === payload.mappedMetadataColumn.getId();
				} else {
					return false;
				}
			});

			if (dnDResult) {
				if (payload.members) {
					// Add local filter payload has filter built from member.
					dnDResult.members.push(payload.members);
				}
			} else {
				payload.members = payload.members ? [payload.members] : [];

				this.dNDResults.push(payload);
			}
		};

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