'use strict';

/*
 *+------------------------------------------------------------------------+
 *| Licensed Materials - Property of IBM
 *| IBM Cognos Products: BI Dashboard
 *| (C) Copyright IBM Corp. 2017
 *|
 *| US Government Users Restricted Rights - Use, duplication or disclosure
 *| restricted by GSA ADP Schedule Contract with IBM Corp.
 *+------------------------------------------------------------------------+
 */
/*
	* This Class defines a Query Definitio Object that supports multiple layers
  */
define(['../../../lib/@waca/core-client/js/core-client/ui/core/Class', 'underscore'], function (Class, _) {
	'use strict';

	var SingleQueryDefinition = null;

	SingleQueryDefinition = Class.extend({
		_dataItems: [],
		_projections: [],
		_filters: [],
		_fields: [],
		_layerId: null,
		_hasCategoricalSlots: {},
		_queryHints: {},
		_augmentations: [],

		/**
   *Initialization for one layer query definition
   */
		init: function init(layerId, dataItems, projections, filters, hints, hasCategoricalSlots, augmentations) {
			this.setDataItems(dataItems);
			this.setProjections(projections);
			this.setFiltres(filters);
			this.setLayerId(layerId);
			this.setQueryHints(hints);
			this.setAugmentations(augmentations);
		},

		/**
  *@return {String} Unique layer ID
  */
		getLayerId: function getLayerId() {
			return this._layerId;
		},

		/**
  *@param {String} layerId
  *Set a layer unique ID
  */
		setLayerId: function setLayerId(layerId) {
			this._layerId = layerId;
		},

		/**
  *@return {String} Unique layer ID
  */
		getDataItems: function getDataItems() {
			return this._dataItems;
		},

		/**
  *@param {Array of JSONObject} dataItems	An array of data items included in the query definition
  *Set a data items
  */
		setDataItems: function setDataItems(dataItems) {
			this._dataItems = dataItems || [];
		},

		/**
  *@param {JSONObject} dataItem	Add a data item object to query definition
  */
		addDataItems: function addDataItems(dataItem) {
			this._dataItems = this._addArrayElement(this._dataItems, dataItem);
		},

		/**
  *@return {Array of JSONObject} An array of projections included in the query definition
  */
		getProjections: function getProjections() {
			return this._projections;
		},

		/**
  *@param {Array of JSONObject}
  *Set an array of projections
  */
		setProjections: function setProjections(projections) {
			this._projections = projections || [];
		},

		/**
  *@param {JSONObject} Add a projection object to query definition
  */
		addProjections: function addProjections(projection) {
			this._addArrayElement(this._projections, projection);
		},

		/**
  *@return {Array of JSONObject} An array of local filters object included in the query definition
  */
		getFilters: function getFilters() {
			return this._filters;
		},

		/**
  *@param {Array of JSONObject} filters
  *Set an arry of local filters
  */
		setFiltres: function setFiltres(filters) {
			this._filters = filters || [];
		},

		/**
  *@param {JSONObject} Add a filter object to query definition
  */
		addFilters: function addFilters(filter) {
			this._filters = this._addArrayElement(this._filters, filter);
		},

		setQueryHints: function setQueryHints(hints) {
			this._queryHints = hints;
		},

		getQueryHints: function getQueryHints() {
			return this._queryHints;
		},

		setAugmentations: function setAugmentations(augmentations) {
			this._augmentations = augmentations;
		},

		getAugmentations: function getAugmentations() {
			return this._augmentations;
		},

		getSynDataFilters: function getSynDataFilters() {
			return this.synDataFilters;
		},

		setSynDataFilters: function setSynDataFilters(synDataFilters) {
			this.synDataFilters = synDataFilters;
		},

		_addArrayElement: function _addArrayElement(array, item, singleID) {
			if (item) {
				if (!_.isArray(item)) {
					if (item.layerId) delete item.layerId;
					array.push(item);
				} else {
					_.each(item, function (entry) {
						if (item.layerId) delete entry.layerId;
					});

					if (singleID) {
						item = _.pluck(item, 'id');
					}
					array = array.concat(item);
				}
			}
			return array;
		}
	});

	/*Query definition object used by client to build final query spec
 * Internally, this object contains an array of query definition defined for
 *	one layer
 */
	var VisQueryDefinition = Class.extend({
		/**
   *Initialization for query definition
   *load all query context
   */
		init: function init(queryContext) {
			this._queryDefinitions = [];
			//Initialize layers
			_.each(queryContext.layers, function (layer) {
				this.addQueryDefinitionByLayer(layer.getId());
			}.bind(this));
			this._addLayeredEntities(queryContext);
			this._addSharedEntities(queryContext);
			_.each(this._queryDefinitions, function (def) {
				def.setProjections(_.pluck(def.getProjections(), 'id'));
			});
		},

		/**
  *@param {object} - queryContext that contains layered entities and common entities
  */
		_addLayeredEntities: function _addLayeredEntities(queryContext) {
			_.map(queryContext.layeredEntities, function (querySpecMember, querySpecMemberType) {
				_.each(querySpecMember, function (value) {
					this._addEntity(this.getQueryDefinitionByLayer(value.layerId), querySpecMemberType, value);
				}.bind(this));
			}.bind(this));
		},

		_addSharedEntities: function _addSharedEntities(queryContext) {
			_.map(queryContext.commonEntities, function (querySpecMember, querySpecMemberType) {
				_.each(this._queryDefinitions, function (queryDef) {
					_.each(querySpecMember, function (value) {
						this._addEntity(queryDef, querySpecMemberType, value);
					}.bind(this));
				}.bind(this));
			}.bind(this));
		},

		_addEntity: function _addEntity(queryDef, entryType, value) {
			if (!queryDef) {
				return;
			}
			//TODO:Each Entry could have its own hanlder
			switch (entryType) {
				case 'dataItems':
					queryDef.addDataItems(value);
					break;
				case 'projections':
					queryDef.addProjections(value);
					break;
				case 'filters':
					queryDef.addFilters(value);
					break;
				case 'queryHints':
					queryDef.setQueryHints(value);
					break;
				case 'augmentations':
					queryDef.setAugmentations(value);
					break;
				default:
				//console.warn('unrecognized definition element');
			}
		},

		//Create single layer definition object it is not defined
		addQueryDefinitionByLayer: function addQueryDefinitionByLayer(layerId) {
			var oLayerQueryDef = this.getQueryDefinitionByLayer(layerId);
			if (!oLayerQueryDef) {
				this._queryDefinitions.push(new SingleQueryDefinition(layerId));
			}
		},

		getQueryDefinitionByLayer: function getQueryDefinitionByLayer(layerId) {
			return _.find(this._queryDefinitions, function (entry) {
				return entry.getLayerId() === layerId;
			});
		},

		clearQueryDefinitions: function clearQueryDefinitions() {
			this._queryDefinitions = [];
		},

		/**
  *Return the Query definitions object that support multiple layers
  */
		getQueryDefinitions: function getQueryDefinitions() {
			return this._queryDefinitions;
		}

	});

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