'use strict';

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

/**
 * Licensed Materials - Property of IBM
 * IBM Cognos Products: Dashboard
 * (C) Copyright IBM Corp. 2017, 2020
 * US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */
define(['underscore', './BaseProvider', '../../vipr/VIPR', '../../vipr/VIPRUtils', '../../vipr/VIPRConfig', '../../vipr/VIPRLibraries', '../../vipr/properties/PropertiesCreatorFromVisDefinition', '../../vipr/properties/ColorPropertiesCreator', '../../../lib/@waca/dashboard-common/dist/utils/ObjectHelper', '../../../widgets/livewidget/nls/StringResources', '../../../widgets/livewidget/util/VisUtil'], function (_, BaseProvider, VIPR, VIPRUtils, VIPRConfig, VIPRLibraries, PropertiesCreatorFromVisDefinition, ColorPropertiesCreator, ObjectHelper, StringResources, VisUtil) {
	'use strict';

	var VIPR_RENDERER = 'dashboard-analytics/visualizations/renderer/vipr3/VIPRView';
	var VIPR3Provider = BaseProvider.extend({
		init: function init() {
			VIPR3Provider.inherited('init', this, arguments);
			this.viprdefinitionsPromises = null;
			this.createDefinitionsMap = {};
			this.loadedVipr3Bundles = {};

			this.initPromise = VIPR.initialize({ 'dashboardApi': this.dashboardApi });
		},

		contains: function contains(id) {
			return this.initPromise.then(function () {
				var libs = VIPR.getLibraries();
				return Promise.resolve(!!libs[id]);
			});
		},

		clear: function clear() {
			var _this = this;

			var libType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : VIPRLibraries.LIB_TYPE_ALL;


			if (libType === VIPRLibraries.LIB_TYPE_ALL) {
				this.viprdefinitionsPromises = null;
				this.createDefinitionsMap = {};
				this.loadedVipr3Bundles = {};
			} else if (this.viprdefinitionsPromises) {
				var libIds = [];
				if (libType === VIPRLibraries.LIB_TYPE_SYSTEM) {
					libIds = VIPR.getSystemLibIds();
				} else if (libType === VIPRLibraries.LIB_TYPE_CUSTOM) {
					libIds = VIPR.getCustomLibIds();
				}

				libIds.forEach(function (id) {
					delete _this.viprdefinitionsPromises[id];
					delete _this.createDefinitionsMap[id];
					delete _this.loadedVipr3Bundles[id];
					VIPRConfig.removeCustomVisConfiguration(id);
				});
			}
		},

		_visualizationPreviewWasLoaded: function _visualizationPreviewWasLoaded() {
			return !!this.loadedVipr3Bundles['visualizationPreview'];
		},


		refreshProvider: function refreshProvider(dashboardApi) {
			var _this2 = this;

			var visPreviewWasLoaded = this._visualizationPreviewWasLoaded();
			this.clear(VIPRLibraries.LIB_TYPE_CUSTOM);
			this.initPromise = VIPR.initialize({ 'dashboardApi': dashboardApi, refresh: true });
			return this.initPromise.then(this._getVIPRDefinitions.bind(this, VIPRLibraries.LIB_TYPE_CUSTOM, visPreviewWasLoaded)).then(function () {
				var promises = Object.values(_this2.viprdefinitionsPromises);
				return Promise.all(promises).then(function (viprDefinitions) {
					return _.chain(viprDefinitions).map(function (viprDef) {
						return viprDef ? _this2.createDefinition(viprDef, true) : null;
					}).filter(function (def) {
						return !!def;
					}).value();
				});
			});
		},

		getDefinition: function getDefinition(id) {
			var _this3 = this;

			return this.initPromise.then(function () {
				return _this3._getVIPRDefinition(id).then(function (viprDef) {
					if (viprDef) {
						if (!_this3.createDefinitionsMap[id]) {
							_this3.createDefinitionsMap[id] = _this3.createDefinition(viprDef, true);
						}
						return _this3.createDefinitionsMap[id];
					} else {
						return Promise.reject(VisUtil.createVisDefinitionLoadingError(id));
					}
				});
			});
		},

		getDefinitions: function getDefinitions() {
			var _this4 = this;

			return this.initPromise.then(function () {
				return _this4._getVIPRDefinitions().then(function (viprDefinitions) {
					return _this4._createDefinitions(viprDefinitions, true);
				});
			});
		},

		_createDefinitions: function _createDefinitions(viprDefinitions, freezeDefinition) {
			var _this5 = this;

			if (!this.createDefinitionsMap) {
				this.createDefinitionsMap = {};
			}
			return _.chain(viprDefinitions).map(function (def) {
				if (!_this5.createDefinitionsMap[def.id]) {
					_this5.createDefinitionsMap[def.id] = _this5.createDefinition(def, freezeDefinition);
					return _this5.createDefinitionsMap[def.id];
				}
			}).filter(function (def) {
				return !!def;
			}).value();
		},

		/**
   * re-load the vipr bundle and recreate the definition
   * @param {string} id the visId
   */
		refresh: function refresh(id) {
			var _this6 = this;

			VIPR.unloadBundle(id);
			return this._loadVIPRDefinition(id).then(function (viprDef) {
				if (!_this6.createDefinitionsMap) {
					_this6.createDefinitionsMap = {};
				}
				_this6.createDefinitionsMap[id] = viprDef ? _this6.createDefinition(viprDef, true) : { id: id, renderer: VIPR_RENDERER, empty: true };
				return _this6.createDefinitionsMap[id];
			});
		},


		_loadVIPRDefinition: function _loadVIPRDefinition(id) {
			var _this7 = this;

			return VIPR.loadBundle(id).then(function (bundle) {
				_this7.loadedVipr3Bundles[id] = bundle;
				return bundle;
			}).catch(function (err) {
				console.error(err);
				return undefined;
			});
		},

		_getVIPRDefinition: function _getVIPRDefinition(id) {
			// initialize the map
			if (!this.viprdefinitionsPromises) {
				this.viprdefinitionsPromises = {};
			}

			if (!this.viprdefinitionsPromises[id]) {
				this.viprdefinitionsPromises[id] = this._loadVIPRDefinition(id);
			}
			return this.viprdefinitionsPromises[id];
		},

		_getVIPRDefinitions: function _getVIPRDefinitions() {
			var _this8 = this;

			var libType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : VIPRLibraries.LIB_TYPE_ALL;
			var loadVisPreview = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;


			var bundleIds = void 0;
			if (loadVisPreview) {
				bundleIds = VIPR.getBundleIds(libType);
			} else {
				// Only load definitions for the visualizationPreview bundle when explicitly requested
				bundleIds = _.without(VIPR.getBundleIds(libType), 'visualizationPreview');
			}

			var promises = _.map(bundleIds, function (id) {
				return _this8._getVIPRDefinition(id);
			});
			// wait for all to finish and filter out the failed bundles
			return Promise.all(promises.map(function (p) {
				return p.catch(function (e) {
					return e;
				});
			})).then(function (definitions) {
				return _.filter(definitions, function (def) {
					return !!def;
				});
			}).catch(function (err) {
				console.error(err);
			});
		},

		_getViprDefinitionProperties: function _getViprDefinitionProperties(viprDefinition) {
			return viprDefinition.vizDef.properties;
		},


		_getCaption: function _getCaption(viprDefinition, viprConfigDefinition, isCustomVis, isSchematic) {
			var schematicPreviewCaption = 'schematicTestCaption';
			var visualizationPreview = 'customVisTestVisualization';
			var caption = void 0;
			if (viprDefinition.userData.name === visualizationPreview) {
				caption = viprConfigDefinition.name;
			} else if (isCustomVis) {
				caption = viprDefinition.userData.name;
				// since schematic metadata like name and icon can be updated after creating bundle, and we can not
				// unregister/register the schematic bundle due to shared bundle-context with other visualization like Map
				// we will separate these metadata info and use vis library information that is set in vipr ConfigDefinition
			} else if (isSchematic && viprDefinition.userData.name !== schematicPreviewCaption) {
				caption = viprConfigDefinition.name;
			} else {
				caption = StringResources.get(viprDefinition.userData.name);
			}
			return caption;
		},

		/**
  * Return a Visualization definition object that can be consumed by VIPR Data and LiveWidget
  **/
		createDefinition: function createDefinition(viprDefinition, freezeDefinition) {
			var viprConfigDefinition = VIPRConfig.getConfig(viprDefinition.id);
			var type = viprConfigDefinition && viprConfigDefinition.type;
			var isSchematic = viprConfigDefinition && viprConfigDefinition.isSchematic;
			var isCustomVis = viprConfigDefinition && viprConfigDefinition.isCustomVis;
			var usages = viprConfigDefinition && viprConfigDefinition.usages;
			var placeholderIcon = this._getPlaceholder(viprDefinition, isCustomVis, isSchematic);
			var caption = this._getCaption(viprDefinition, viprConfigDefinition, isCustomVis, isSchematic);

			var viprProperties = [];
			var viprGroupProperties = {};

			// since schematic metadata like name,icon and assetId can be updated after creating bundle, and we can not
			// unregister/register the schematic bundle due to shared bundle-context with other visualization like Map
			// we will separate these metadata info and use vis library information that is set in vipr ConfigDefinition
			var icon = isSchematic ? viprConfigDefinition.icon : viprDefinition.userData.icon;
			var assetId = isSchematic ? viprConfigDefinition.assetId : viprDefinition.userData.assetId;

			// set VIPRConig for extensible vis based on VIDA properties
			if (VIPRUtils.includeAllProperties(viprDefinition)) {
				this._setViprConfigDefinition(viprConfigDefinition, viprDefinition, viprProperties, viprGroupProperties);
			}

			var vizDefProperties = PropertiesCreatorFromVisDefinition.getInstance().getVizDefPropertiesFromDefinition(viprDefinition);

			var properties = PropertiesCreatorFromVisDefinition.getInstance().getPropertiesFromDefintion(viprDefinition.id);

			var definition = {
				type: type,
				isSchematic: isSchematic,
				isCustomVis: isCustomVis,
				id: viprDefinition.id,
				supportsSortAction: VIPRUtils.supportsSortAction(viprDefinition.id),
				supportsContextualTopBottomAction: VIPRUtils.supportsContextualTopBottomAction(viprDefinition.id),
				supportsNonContextualTopBottomAction: VIPRUtils.supportsNonContextualTopBottomAction(viprDefinition.id),
				supportsFormatAction: VIPRUtils.supportsFormatAction(viprDefinition.id),
				supportsMaintainAxisScale: VIPRUtils.supportsMaintainAxisScale(viprDefinition.id),
				supportsCustomGroupAction: VIPRUtils.supportsCustomGroupAction(viprDefinition.id),
				supportsCustomDataSelection: VIPRUtils.supportsCustomDataSelection(viprDefinition.id),
				supportsAnnotations: VIPRUtils.supportsAnnotations(viprDefinition.id),
				datasets: this._getDatasets(viprDefinition.vizDef.dataSets),
				geo: VIPRUtils.isGeospatial(viprDefinition.id),
				name: viprDefinition.manifest.name,
				caption: caption,
				label: caption,
				icon: icon,
				assetId: assetId,
				tabs: VIPRUtils.getVisualizationTabs(viprDefinition.id),
				placeholderIcon: placeholderIcon,
				isRecommendable: VIPRUtils.isRecommendable(viprDefinition.id),
				noDataQuery: VIPRUtils.noDataQuery(viprDefinition.id),
				isMultilayersWidget: VIPRUtils.doesConfigPropertyMatchExpected(viprDefinition.id, 'isMultilayersWidget', true),
				useFPDAsInsightsInput: VIPRUtils.useFPDAsInsightsInput(viprDefinition.id),
				disablePan: VIPRUtils.isDisablePan(viprDefinition.id),
				renderWithoutCompletingMapping: VIPRUtils.isRenderWithoutCompletingMapping(viprDefinition.id),
				aggregateAndSortOnClient: VIPRUtils.aggregateAndSortOnClient(viprDefinition.id),
				preferredSize: {
					height: 420,
					width: 500
				},
				dataSlots: VIPRUtils.createDataSlots(viprDefinition),
				metaDataEntries: VIPRUtils.createMetaDataEntries(viprDefinition.vizDef),
				properties: properties,
				vizDefProperties: vizDefProperties,
				propertyPrefixes: VIPRUtils.getPropertyPrefixes(viprDefinition),
				listenForPropChanges: VIPRUtils.getListenForPropChanges(viprDefinition),
				groupedProperty: VIPRUtils.getGroupedProperty(viprDefinition),
				renderer: VIPR_RENDERER,
				scope: 'default',
				themeMapping: ColorPropertiesCreator.getInstance().getThemeIdMappings(properties),
				queryHints: VIPRUtils.getQueryHints(viprDefinition.id),
				binningConfig: VIPRUtils.getBinning(viprDefinition.id),
				canApplyBinning: VIPRUtils.canApplyAutoBin(viprDefinition.id),
				isViewBinned: false,
				supportsOLAP: !VIPRUtils.doesConfigPropertyMatchExpected(viprDefinition.id, 'doesNotSupportOLAP', true),
				usages: usages
			};

			if (isSchematic) {
				definition.getSchematicContent = viprConfigDefinition.schematicVis.getSchematicContent.bind(viprConfigDefinition.schematicVis);
			}

			var nLimit = VIPRUtils.getDataRowLimit(viprDefinition.id);
			if (nLimit) {
				definition.dataRowLimit = nLimit;
			}
			var nLimitIE = VIPRUtils.getDataRowLimitIE(viprDefinition.id);
			if (nLimitIE) {
				definition.dataRowLimitIE = nLimitIE;
			}
			return freezeDefinition ? ObjectHelper.deepFreezeObject(definition) : definition;
		},

		_setViprConfigDefinition: function _setViprConfigDefinition(viprConfigDefinition, viprDefinition, viprProperties, viprGroupProperties) {
			VIPRUtils.getViprProperiesAndGroups(viprDefinition, viprProperties, viprGroupProperties);
			var options = {
				viprProperties: viprProperties,
				viprGroupProperties: _extends({}, viprGroupProperties),
				dataSets: viprDefinition.vizDef.dataSets
			};
			VIPRConfig.setAllViprConfigProperties(viprConfigDefinition, options);
			viprDefinition.userData.config = {
				'properties': {
					'exclude': [],
					'include': viprConfigDefinition.bundleInclude
				}
			};
			VIPR.updateCustomLibrary(viprDefinition.id);
		},
		_getPlaceholder: function _getPlaceholder(viprDefinition, isCustomVis, isSchematic) {
			var isNonPreviewSchematic = isSchematic && viprDefinition.id !== 'com.ibm.vis.schematicsPreview';
			var isNonPreviewCustom = isCustomVis && viprDefinition.id !== 'visualizationPreview';
			var iconBase = this.icon_root;
			var icon = viprDefinition.userData.placeholderIcon;
			if (viprDefinition.userData.icon) {
				// When there is an icon in custom or schematic definition, returns this icon
				if (isNonPreviewCustom || isNonPreviewSchematic) {
					iconBase = viprDefinition.userData.placeholderIcon;
					icon = viprDefinition.userData.icon;
				}
			} else {
				// When there is no icon in custom or schematic definition, return default placeholderIcon respectively
				if (isCustomVis) {
					icon = 'placeholders/custom-visual.svg';
				} else if (isSchematic) {
					icon = 'placeholders/custom-schematic.svg';
				}
			}
			return iconBase + icon;
		},


		_getDatasets: function _getDatasets(datasets) {
			var bIsSingleDataset = datasets.length === 1;
			return _.map(datasets, function (dataset) {
				return {
					/* Default Dataset name for sinlge dataset Viz is set to be 'data' if there is no name in the definition */
					'name': bIsSingleDataset && !dataset.name ? 'data' : dataset.name,
					'optional': dataset.optional,
					'suppressMissing': dataset.suppressMissing,
					'needsSorted': dataset.needsSorted,
					'requiresValues': dataset.requiresValues,
					'caption': dataset.caption
				};
			});
		}
	});

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