define([
	'jsclass/class',
	'./AbstractPlugin',
	'Shared/WidgetFoundation/Util',
	'async',

	// Filters preloading
	'Shared/WidgetFoundation/CustomFilter/ApplyButton',
	'Shared/WidgetFoundation/CustomFilter/Input',
	'Shared/WidgetFoundation/CustomFilter/Select'
], function(
	Class, AbstractPlugin, Util, Async,

	// Preloaded filters
	ApplyButtonFilter, InputFilter, SelectFilter) {
	return new Class(AbstractPlugin, {

		// Shortcuts
		preloadedCustomFilters: {
			ApplyButton: ApplyButtonFilter,
			Input: InputFilter,
			Select: SelectFilter
		},

		filters: null,

		initialize: function(widget, args, callback) {
			this.callSuper(widget, args);
			this.filters = [];

			// Preserve context
			var self = this;

			// Async filter loading (some files aren't loaded yet)
			Async.each(args.filters, function(filter, cb) {
				// Constructed filter (yeah, class that not from WF-package can be used)
				if (filter.setCustomFilterPlugin) {
					filter.setCustomFilterPlugin(self);
					self.filters.push(filter);

					cb();
				}
				else {
					// Filter name only, without any parameters
					if ('string' == typeof filter) filter = [filter, {}];

					// Filter with parameters [filterName, parametersObject]
					if (2 === filter.length && 'object' == typeof  filter) {

						// Here is args structure, example - ['SomeFilter', { title: 'custom title' }]
						var filterName = filter[0],
							filterArgs = filter[1];

						var onLoad = function (filterClass) {
							var filterObject = new filterClass(filterArgs);
							filterObject.setCustomFilterPlugin(self);
							self.filters.push(filterObject);

							setTimeout(cb, 10);
						};

						// File already loaded
						if (self.preloadedCustomFilters[filterName]) onLoad(self.preloadedCustomFilters[filterName]);

						// Or load class by require-js lib
						else require([filterName], onLoad);

					}

					else throw new Error('Args type is unknown!');
				}

			}, function() {

				// Initial values
				widget.listenEvent(widget.eventsMap.stateLoaded, function() {
					Util.forEach(self.filters, function(i, filter) {
						if (filter.isPersistent()) {
							filter.setValue(widget.getFromState(
								'customFilter.' + filter.getName() + self.getContextUID(),
								filter.getDefaultValue()
							)).dataInitialized();
						}
					});
				});

				// HTML
				widget.listenEvent(widget.eventsMap.viewInitialized, function() {
					var filtersNode = widget.getNodeBodyContainer().find('.filters');
					Util.forEach(self.filters, function(i, filter) {
						var node = $(filter.getHTML());
						filter.nodeCreated(node);
						filtersNode.append(node);
						filter.nodeRendered();
					});
				});

				// Affect on data request
				widget.listenEvent(widget.eventsMap.dataRequestParametersGenerated, function(parameters) {
					Util.Object.merge(parameters.pager.customFilters, (function() {
						var filters = {};
						Util.forEach(self.filters, function (i, filter) {
							if (filter.hasValue()) {
								filters[filter.getName()] = filter.getValue();
							}
						});

						return filters;
					})());
				});

				callback();
			});
		},

		/**
		 * Store values in widget state
		 *
		 * @returns this
		 */
		persistValues: function() {
			var self = this;

			Util.forEach(self.filters, function(i, filter) {
				if (filter.isPersistent()) {
					self.getWidget().setToState(
						'customFilter.' + filter.getName() + self.getContextUID(),
						filter.getValue()
					);
				}
			});

			this.getWidget().saveStateIfChanged();

			return this;
		},

		/**
		 * Reload widget data (only update)
		 *
		 * @returns this
		 */
		reloadData: function() {
			this.getWidget().reloadGridData();

			return this;
		},

		/**
		 * Combined logic
		 *
		 * @returns this
		 */
		persistAndReloadData: function() {
			this.persistValues().reloadData();

			return this;
		},

		getContextUID: function() {
			return '';
		}
	});
});