'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'], function (_) {
	var QuerySelectionBuilder = function () {
		function QuerySelectionBuilder() {
			_classCallCheck(this, QuerySelectionBuilder);
		}

		QuerySelectionBuilder.prototype.build = function build(dataItem) {
			var filtersList = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
			var searchFilters = arguments[2];

			var finalSelections = [];
			if (!dataItem.getBinning()) {
				//By default, return selections in the order agreed to by PM.
				finalSelections.push.apply(finalSelections, this._buildSelectionsFromDrillStateForHierarchyOrSet(dataItem, filtersList, searchFilters));
				finalSelections.push.apply(finalSelections, this._buildSelectionsFromFiltersForOLAPDataItems(dataItem, filtersList));
				finalSelections.push.apply(finalSelections, this._buildSelectionsForTopBottom(dataItem));
				finalSelections.push.apply(finalSelections, this._buildSelectionsForSort(dataItem));
			} else {
				finalSelections.push.apply(finalSelections, this._buildSelectionsFromFiltersForOLAPDataItems(dataItem, filtersList));
				finalSelections.push.apply(finalSelections, this._buildSelectionsForSort(dataItem));
			}

			return finalSelections;
		};

		//For hierarchies or OLAP set, build one of root members, children of single root or children of current drill member.	


		QuerySelectionBuilder.prototype._buildSelectionsFromDrillStateForHierarchyOrSet = function _buildSelectionsFromDrillStateForHierarchyOrSet(dataItem, filterList) {
			var searchFilters = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];

			var selections = [];
			// Do not convert to hierarchy to level set if has search filters
			if (searchFilters.find(function (searchFilter) {
				return searchFilter.columnId === dataItem.getColumnId();
			})) {
				return selections;
			}

			var matchingLocalFilterEntry = _.find(filterList, function (filter) {
				return filter.columnId === dataItem.getColumnId();
			});
			var overrideHierarchyDefaultSelection = matchingLocalFilterEntry && matchingLocalFilterEntry.overrideHierarchyDefaultSelection;

			var metaDataColumn = dataItem.getMetadataColumn();
			if (metaDataColumn.isHierarchy() || metaDataColumn.isNamedSet()) {
				if (this._isExistingDrillSelection(dataItem)) {
					var drillDownValue = dataItem.getDrillDownValue();
					var drillUpValue = dataItem.getDrillUpValue();
					if (drillDownValue) {
						selections.push({
							'operation': 'add',
							'children': drillDownValue
						});
					} else if (drillUpValue) {
						selections.push({
							'operation': 'add',
							'drillUp': drillUpValue
						});
					}
				} else if (metaDataColumn.isHierarchy() && !overrideHierarchyDefaultSelection) {
					// default behavior.	
					if (metaDataColumn.isSingleRootHierarchy()) {
						selections.push({
							'operation': 'add',
							'children': metaDataColumn.getRootMember()
						});
					} else {
						selections.push({
							'operation': 'add',
							'rootMembers': true
						});
					}
				}
			}
			return selections;
		};

		QuerySelectionBuilder.prototype._buildSelectionsForTopBottom = function _buildSelectionsForTopBottom(dataItem) {
			var topBottom = dataItem.getTopBottom();
			if (!topBottom) {
				return [];
			}

			var topBottomQuerySpec = {
				'operation': 'keep',
				'topBottom': {
					'type': topBottom.type,
					'value': topBottom.value
				}
			};
			if (topBottom.context) {
				topBottomQuerySpec.context = [topBottom.context];
			}
			if (topBottom.rank) {
				topBottomQuerySpec.topBottom.rank = topBottom.rank;
			}
			return [topBottomQuerySpec];
		};

		QuerySelectionBuilder.prototype._isExistingDrillSelection = function _isExistingDrillSelection(dataItem) {
			var drillSelection = dataItem.getDrillDownValue() || dataItem.getDrillUpValue();
			return !!drillSelection;
		};

		QuerySelectionBuilder.prototype._convertFilterEntryToSelection = function _convertFilterEntryToSelection(filterEntry) {
			var discreteOperation = this._convertFilterOperatorToSetOperation(filterEntry.operator);
			var result = null;
			if (discreteOperation) {
				var valuesArray = filterEntry.values;
				result = {
					operation: discreteOperation
				};

				if (filterEntry.operator === 'containsignorecase') {
					result.filter = {
						operator: filterEntry.operator,
						values: valuesArray.map(function (value) {
							return value.u;
						})
					};
				} else {
					result.set = valuesArray.map(function (value) {
						return value.u;
					});
				}
			}
			return result;
		};

		QuerySelectionBuilder.prototype._convertFilterOperatorToSetOperation = function _convertFilterOperatorToSetOperation(operator) {
			switch (operator) {
				case 'in':
				case 'containsignorecase':
					return 'keep';
				case 'notin':
					return 'remove';
				default:
					return;
			}
		};

		QuerySelectionBuilder.prototype._buildSelectionsFromFiltersForOLAPDataItems = function _buildSelectionsFromFiltersForOLAPDataItems(dataItem, filterList, outputEdgeFilterExceptions) {
			var _this = this;

			var metadataColumn = dataItem.getMetadataColumn();
			if (!metadataColumn.isOlapColumn() || metadataColumn.isProperty()) {
				return [];
			}
			var dataItemLocalFilters = filterList.filter(function (filter) {
				return filter.columnId === dataItem.getColumnId();
			});

			var selections = [];
			dataItemLocalFilters.forEach(function (filterEntry) {
				if (filterEntry && filterEntry.values.length > 0 && !filterEntry.conditions) {
					var selectionItem = _this._convertFilterEntryToSelection(filterEntry);
					if (selectionItem) {
						selections.push(selectionItem);
					}
				}
			});
			if (selections.length > 0) {
				//Track which filters were converted to dataItemSelections (so we don't filter on them as well!)
				if (outputEdgeFilterExceptions) {
					outputEdgeFilterExceptions.push(dataItem.getColumnId());
				}
			}
			return selections;
		};

		/**
   * @todo: should figure out how to do the sort selection here.
   * this is a temporary code
   */


		QuerySelectionBuilder.prototype._buildSelectionsForSort = function _buildSelectionsForSort(dataItem) {
			var sortInfo = dataItem.getSort();
			return sortInfo ? [{
				'operation': 'order',
				'sort': _.extend({}, _.pick(sortInfo, 'type', 'by', 'priority'))
			}] : [];
		};

		return QuerySelectionBuilder;
	}();

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