'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. 2018, 2019
 * US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */
define(['../lib/@waca/dashboard-common/dist/core/APIFactory', '../api/deprecated/CanvasAPI', '../lib/@waca/core-client/js/core-client/utils/Deferred', '../dashboard/api/FilterAPI', 'underscore'], function (APIFactory, DeprecatedCanvasAPI, Deferred, DeprecatedFilterApi, _) {
	var CanvasAPIImpl = function () {
		function CanvasAPIImpl(dashboardAPI, boardModel, canvasController, layoutController, widgetLoader) {
			_classCallCheck(this, CanvasAPIImpl);

			this.widgetLoader = widgetLoader;
			this.boardModel = boardModel;
			this.canvasController = canvasController;
			this.layoutController = layoutController;
			this.dashboardAPI = dashboardAPI;

			// TODO: remove this -- it is just here because some code might be using it
			this.controller = this.canvasController;

			this.filterApi = new DeprecatedFilterApi(this.canvasController, this.dashboardAPI);
		}

		CanvasAPIImpl.prototype.getAPI = function getAPI() {
			if (!this.api) {
				this.api = APIFactory.createAPI(this, [DeprecatedCanvasAPI], {
					deprecatedPropList: ['controller']
				});
			}
			return this.api;
		};

		CanvasAPIImpl.prototype.getWidgetsWhenRendered = function getWidgetsWhenRendered() {
			return this.dashboardAPI.waitTillWidgetsRendered.apply(this.dashboardAPI, arguments);
		};

		CanvasAPIImpl.prototype.deselectAllWidgets = function deselectAllWidgets() {
			return this.dashboardAPI.deselectAllWidgets.apply(this.dashboardAPI, arguments);
		};

		CanvasAPIImpl.prototype.destroy = function destroy() {

			this.widgetLoader = null;
			this.boardModel = null;
			this.canvasController = null;
			this.layoutController = null;
			this.dashboardAPI = null;

			// TODO: remove this -- it is just here because some code might be using it
			this.controller = null;

			this.filterApi = null;
		};

		CanvasAPIImpl.prototype.getFilters = function getFilters() {
			return this.filterApi;
		};

		CanvasAPIImpl.prototype.getSelectedWidgets = function getSelectedWidgets() {
			var _this = this;

			var widgetModels = this.layoutController.getSelectedWidgets();
			var widgets = [];
			widgetModels.forEach(function (model) {
				var widget = _this.getWidget(model.id);
				if (widget) {
					widgets.push(widget);
				}
			});
			return widgets;
		};

		CanvasAPIImpl.prototype.getWidgetWhenReady = function getWidgetWhenReady(id) {

			if (this.widgetLoader) {
				return this.widgetLoader.getWidgetAsync(id).then(function (widget) {
					if (widget) {
						return widget.getAPI();
					}
				});
			} else {
				return Promise.reject(new Error('No longer alive!'));
			}
		};

		CanvasAPIImpl.prototype.getWidget = function getWidget(id) {
			if (this.widgetLoader) {
				var widget = this.widgetLoader.getWidget(id);
				if (widget) {
					return widget.getAPI();
				}
			}
		};

		CanvasAPIImpl.prototype.getWidgets = function getWidgets() {
			var id = void 0;
			var widgets = [];
			var widget = void 0;
			for (id in this.boardModel.widgetInstances) {
				widget = this.getWidget(id);
				if (widget) {
					widgets.push(widget);
				}
			}
			return widgets;
		};

		CanvasAPIImpl.prototype.addFragment = function addFragment(options, sender, payloadData) {
			if (payloadData === undefined) payloadData = null;

			//sets preferred add options in CanvasController Class
			this.layoutController.setPreferredAddOptions(options);

			var payload = this.boardModel.addFragment(options, sender ? sender : 'api', payloadData);
			var parameter = payload && payload.value && payload.value.parameter;
			return parameter && parameter.model && parameter.model.layout && parameter.model.layout.id; //return model id of added widget
		};

		CanvasAPIImpl.prototype.addWidget = function addWidget(addOptions, sender, options) {
			this.layoutController.setPreferredAddOptions(addOptions);
			var payload = this.boardModel.addWidget(addOptions, sender ? sender : 'api', options);
			var parameter = payload && payload.value && payload.value.parameter;
			return parameter && parameter.model && parameter.model.id; //return model id of added widget
		};

		CanvasAPIImpl.prototype.replaceWidget = function replaceWidget(widgetId, addOptions, sender) {
			var layoutModel = this.boardModel.layout.findModel(widgetId);
			if (layoutModel) {
				addOptions.layoutProperties = layoutModel.toJSON();
				var id = addOptions.layoutProperties.id;
				addOptions.layoutProperties.id = undefined;
				var parentModel = this.boardModel.layout.findParentModel(widgetId);
				if (parentModel) {
					addOptions.parentId = parentModel.id;
					addOptions.insertBefore = id;
				}
			} else {
				this.layoutController.setPreferredAddOptions(addOptions);
			}
			var undoRedoTransactionId = _.uniqueId('undoRedoReplace');
			var data = {
				undoRedoTransactionId: undoRedoTransactionId,
				transactionToken: addOptions && addOptions.transactionToken,
				replace: true
			};
			var newWidgetParameters = this.boardModel.addWidget(addOptions, sender ? sender : 'api', data);
			this.boardModel.removeWidget(widgetId, sender ? sender : 'api', data);

			if (newWidgetParameters && newWidgetParameters.value && newWidgetParameters.value.parameter && newWidgetParameters.value.parameter.model) {
				return newWidgetParameters.value.parameter.model.id;
			}
		};

		CanvasAPIImpl.prototype.hasMaximizedWidget = function hasMaximizedWidget() {
			return this.canvasController.layoutController.hasMaximizedWidget();
		};

		CanvasAPIImpl.prototype.removeWidget = function removeWidget(widgetId, sender) {
			this.boardModel.removeWidget(widgetId, sender ? sender : 'api');
		};

		CanvasAPIImpl.prototype.selectWidget = function selectWidget(widgetId, options) {
			var deferred = new Deferred();
			this.layoutController.whenWidgetRenderComplete(widgetId).done(function (layout) {
				var selectionHandler = this.layoutController.interactionController.selectionHandler;
				if (options && !options.multiSelect) {
					selectionHandler.deselectAll();
				}
				// pass the flag isTouch to properly render the resize edges for touch device.
				selectionHandler.selectNode(layout.domNode, options);
				deferred.resolve();
			}.bind(this));
			return deferred.promise;
		};

		CanvasAPIImpl.prototype.selectWidgets = function selectWidgets(widgetIds, options) {
			options = options || {};
			options = _.extend(options, {
				'multiSelect': true
			});
			var promises = [];
			for (var widgetId in widgetIds) {
				promises.push(this.selectWidget(widgetIds[widgetId], options));
			}
			return Promise.all(promises);
		};

		CanvasAPIImpl.prototype.getLayout = function getLayout(id) {
			var layoutView = this.canvasController.layoutController.getView(id);
			if (layoutView && layoutView.view) {
				return layoutView.view.getAPI();
			}
		};

		CanvasAPIImpl.prototype.getFeature = function getFeature(id) {
			return this.canvasController.getFeature(id);
		};

		CanvasAPIImpl.prototype.registerFeature = function registerFeature(id, feature) {
			return this.canvasController.registerFeature(id, feature);
		};

		return CanvasAPIImpl;
	}();

	return CanvasAPIImpl;
});
//# sourceMappingURL=DeprecatedCanvas.js.map