#I LOVE YOU EVERDAY#

;( function( elementor, $, window ) {

var TemplateLibraryTemplateModel = Backbone.Model.extend({
		defaults: {
			template_id: 0,
			title: '',
			source: '',
			type: '',
			subtype: '',
			author: '',
			thumbnail: '',
			url: '',
			export_link: '',
			tags: []
		}
	});

var TemplateLibraryCollection = Backbone.Collection.extend({
		model: TemplateLibraryTemplateModel
	});

var TemplateLibraryTemplateView = Marionette.ItemView.extend({
		className: function className() {
			var classes = 'elementor-template-library-template',
				source = this.model.get('source');
			classes += ' elementor-template-library-template-remote';
			classes += ' elementor-template-library-template-' + source;

if ('hub_collections' === source) {
				classes += ' elementor-template-library-template-' + this.model.get('type');
			}

if (this.model.get('isPro')) {
				classes += ' elementor-template-library-pro-template';
			}

return classes;
		},
		ui: function ui() {
			return {
				previewButton: '.elementor-template-library-template-preview'
			};
		},
		events: function events() {
			return {
				'click @ui.previewButton': 'onPreviewButtonClick'
			};
		},
		behaviors: {
			insertTemplate: {
				behaviorClass: TemplateLibraryInsertTemplateBehavior
			}
		}
	});

if (!isFavorite && hub_templates_lib.templates.getFilter('favorite')) {
				elementor.channels.templates.trigger('filter:change');
			}
		}
	});

var TemplateLibraryPreviewView = Marionette.ItemView.extend( {
		template: '#tmpl-elementor-template-library-preview',
	
		id: 'elementor-template-library-preview',
	
		ui: {
			iframe: '> iframe',
		},
	
		onRender: function() {
			this.ui.iframe.attr( 'src', this.getOption( 'url' ) );
		},
	} );

var TemplateLibraryHeaderPreviewView = Marionette.ItemView.extend({
		template: '#tmpl-elementor-template-library-header-preview-hub',
		id: 'elementor-template-library-header-preview',
		behaviors: {
			insertTemplate: {
				behaviorClass: TemplateLibraryInsertTemplateBehavior
			}
		}
	});

var TemplateLibraryHeaderBackView = Marionette.ItemView.extend( {
		template: '#tmpl-elementor-template-library-header-back',
	
		id: 'elementor-template-library-header-preview-back',
	
		events: {
			click: 'onClick',
		},
	
		onClick: function() {
			$e.routes.restoreState( 'hub_collections' );
		},
	} );

if (!filterValue) {
					return;
				}

if (this.callback) {
					var callbackResult = this.callback.call(childModel, filterValue);

if (!callbackResult) {
						passingFilter = false;
					}

return callbackResult;
				}

var filterResult = filterValue === childModel.get(filterTermName);

if (!filterResult) {
					passingFilter = false;
				}

return filterResult;
			});
			return passingFilter;
		},
		order: function order(by, reverseOrder) {
			var comparator = this.comparators[by] || by;

if (reverseOrder) {
				comparator = this.reverseOrder(comparator);
			}

this.collection.comparator = comparator;
			this.collection.sort();
		},
		reverseOrder: function reverseOrder(comparator) {
			if ('function' !== typeof comparator) {
				var comparatorValue = comparator;

comparator = function comparator(model) {
					return model.get(comparatorValue);
				};
			}

return function (left, right) {
				var l = comparator(left),
					r = comparator(right);

if (undefined === l) {
					return -1;
				}

if (undefined === r) {
					return 1;
				}

if (l < r) {
					return 1;
				}

if (l > r) {
					return -1;
				}

return 0;
			};
		},
		addSourceData: function addSourceData() {
			var isEmpty = this.children.isEmpty();
			this.$el.attr('data-template-source', isEmpty ? 'empty' : hub_templates_lib.templates.getFilter('source'));
		},
		setFiltersUI: function setFiltersUI() {
			var $filters = this.$(this.ui.selectFilter);
			$filters.select2({
				placeholder: elementor.translate('category'),
				allowClear: true,
				width: 150,
				dropdownParent: this.$el
			});
		},
		setMasonrySkin: function setMasonrySkin() {
			var masonry = new elementorModules.utils.Masonry({
				container: this.$childViewContainer,
				items: this.$childViewContainer.children()
			});
			this.$childViewContainer.imagesLoaded(masonry.run.bind(masonry));
		},
		toggleFilterClass: function toggleFilterClass() {
			this.$el.toggleClass('elementor-templates-filter-active', !!(hub_templates_lib.templates.getFilter('text') || hub_templates_lib.templates.getFilter('favorite')));
		},
		onRender: function onRender() {
			if ('hub_collections' === hub_templates_lib.templates.getFilter('source')) {
				this.setFiltersUI();
			}
		},
		onRenderCollection: function onRenderCollection() {
			this.addSourceData();
			this.toggleFilterClass();

if ('hub_collections' === hub_templates_lib.templates.getFilter('source') && 'page' !== hub_templates_lib.templates.getFilter('type')) {
				this.setMasonrySkin();
			}
		},
		onBeforeRenderEmpty: function onBeforeRenderEmpty() {
			this.addSourceData();
		},
		onTextFilterInput: function onTextFilterInput() {
			hub_templates_lib.templates.setFilter('text', this.ui.textFilter.val());
		},
		onSelectFilterChange: function onSelectFilterChange(event) {
			var $select = jQuery(event.currentTarget),
				filterName = $select.data('elementor-filter');
			hub_templates_lib.templates.setFilter(filterName, $select.val());
		},
		onMyFavoritesFilterChange: function onMyFavoritesFilterChange() {
			hub_templates_lib.templates.setFilter('favorite', this.ui.myFavoritesFilter[0].checked);
		},
		onOrderLabelsClick: function onOrderLabelsClick(event) {
			var $clickedInput = jQuery(event.currentTarget.control),
				toggle;

if (!$clickedInput[0].checked) {
				toggle = 'asc' !== $clickedInput.data('default-ordering-direction');
			}

$clickedInput.toggleClass('elementor-template-library-order-reverse', toggle);
			this.order($clickedInput.val(), $clickedInput.hasClass('elementor-template-library-order-reverse'));
		}
	});

if (clickCallback) {
				clickCallback();
			}
		},
	});

var TemplateLibraryHeaderMenuView = Marionette.ItemView.extend({
		template: '#tmpl-elementor-template-library-header-menu',
		id: 'elementor-template-library-header-menu',
		templateHelpers: function templateHelpers() {
			return {
				tabs: $e.components.get('hub_collections').getTabs()
			};
		}
	});

if ( ! this.manager.layout ) {
				this.manager.layout = this.layout;
			}
	
			this.manager.layout.setHeaderDefaultParts();
	
			return true;
		};
		Component.prototype.close = function() {
			if ( ! parent.close.call( this ) ) {
				return false;
			}
	
			this.manager.modalConfig = {};
	
			return true;
		};
		Component.prototype.show = function( args ) {
			this.manager.modalConfig = args;
	
			if ( args.toDefault || ! $e.routes.restoreState( 'hub_collections' ) ) {
				$e.route( this.getDefaultRoute() );
			}
		};
		Component.prototype.insertTemplate = function( args ) {
			var autoImportSettings = false,
				model = args.model,
				self = this;
	
			var withPageSettings = args.withPageSettings || null;
	
			if ( autoImportSettings ) {
				withPageSettings = true;
			}
	
			if ( null === withPageSettings && model.get( 'hasPageSettings' ) ) {
				var insertTemplateHandler = this.getImportSettingsDialog();
	
				insertTemplateHandler.showImportDialog( model );
	
				return;
			}
	
			this.manager.layout.showLoadingView();
	
			this.manager.requestTemplateContent( model.get( 'source' ), model.get( 'template_id' ), {
				data: {
					with_page_settings: withPageSettings,
				},
				success: function( data ) {
					// Clone the `modalConfig.importOptions` because it deleted during the closing.
					var importOptions = jQuery.extend( {}, self.manager.modalConfig.importOptions );
	
					importOptions.withPageSettings = withPageSettings;
	
					// Hide for next open.
					self.manager.layout.hideLoadingView();
	
					self.manager.layout.hideModal();
	
					$e.run( 'document/elements/import', {
						model:model,
						data:data,
						options: importOptions,
					} );
				},
				error: function( data ) {
					self.manager.showErrorDialog( data );
				},
				complete: function() {
					self.manager.layout.hideLoadingView();
				},
			} );

Component.prototype.getImportSettingsDialog = function() {
				var InsertTemplateHandler = {
					dialog: null,
		
					showImportDialog: function( model ) {
						var dialog = InsertTemplateHandler.getDialog();
		
						dialog.onConfirm = function() {
							$e.run( 'library/insert-template', {
								model:model,
								withPageSettings: true,
							} );
						};
		
						dialog.onCancel = function() {
							$e.run( 'library/insert-template', {
								model:model,
								withPageSettings: false,
							} );
						};
		
						dialog.show();
					},
		
					initDialog: function() {
						InsertTemplateHandler.dialog = elementorCommon.dialogsManager.createWidget( 'confirm', {
							id: 'elementor-insert-template-settings-dialog',
							headerMessage: elementor.translate( 'import_template_dialog_header' ),
							message: elementor.translate( 'import_template_dialog_message' ) + '<br>' + elementor.translate( 'import_template_dialog_message_attention' ),
							strings: {
								confirm: elementor.translate( 'yes' ),
								cancel: elementor.translate( 'no' ),
							},
						} );
					},
		
					getDialog: function() {
						if ( ! InsertTemplateHandler.dialog ) {
							InsertTemplateHandler.initDialog();
						}
		
						return InsertTemplateHandler.dialog;
					},
				};
		
				return InsertTemplateHandler;
			};
		};
		Component.prototype.getTabsWrapperSelector = function() {
			return '#elementor-template-library-header-menu';
		};
		Component.prototype.getModalLayout = function() {
			return TemplateLibraryLayoutView;
		};
		Component.prototype.maybeOpenLibrary = function() {
			if ('#hub_collections' === location.hash) {
				$e.run('hub_collections/open');
				location.hash = '';
			}
		};

return Component;
	}($e.modules.ComponentModalBase);

var TemplateLibraryManager = function TemplateLibraryManager() {
		var self = this,
			errorDialog,
			config = {},
			templateTypes = {
				page: {},
				section: {}
			},
			filterTerms = {},
			templatesCollection = false;

this.modalConfig = {};

var registerDefaultFilterTerms = function() {
			filterTerms = {
				text: {
					callback: function callback(value) {
						value = value.toLowerCase();

if (this.get('title').toLowerCase().indexOf(value) >= 0) {
							return true;
						}

return _.any(this.get('tags'), function (tag) {
							return tag.toLowerCase().indexOf(value) >= 0;
						});
					}
				},
				type: {},
				subtype: {},
				favorite: {}
			};
		};

this.getFilter = function (name) {
			return elementor.channels.templates.request('filter:' + name);
		};

this.setFilter = function (name, value, silent) {
			elementor.channels.templates.reply('filter:' + name, value);

if (!silent) {
				elementor.channels.templates.trigger('filter:change');
			}
		};

this.setScreen = function (args) {
			elementor.channels.templates.stopReplying();
			self.setFilter('source', args.source, true);
			self.setFilter('type', args.type, true);
			self.setFilter('subtype', args.subtype, true);
			self.showTemplates();
		};

this.getTemplatesCollection = function () {
			return templatesCollection;
		};

this.getConfig = function (item) {
			if (item) {
				return config[item] ? config[item] : {};
			}

return config;
		};

this.getFilterTerms = function (termName) {
			if (termName) {
				return filterTerms[termName];
			}

return filterTerms;
		};

this.requestLibraryData = function (options) {
			if (templatesCollection && !options.forceUpdate) {
				if (options.onUpdate) {
					options.onUpdate();
				}

return;
			}

if (options.onBeforeUpdate) {
				options.onBeforeUpdate();
			}

var ajaxOptions = {
				data: {},
				success: function success(data) {
					templatesCollection = new TemplateLibraryCollection(data.templates);

if (data.config) {
						config = data.config;
					}

if (options.onUpdate) {
						options.onUpdate();
					}
				}
			};

if (options.forceSync) {
				ajaxOptions.data.sync = true;
			}

elementorCommon.ajax.addRequest('hub_get_library_data', ajaxOptions);
		};

this.loadTemplates = function (_onUpdate) {
			self.requestLibraryData({
				onBeforeUpdate: self.layout.showLoadingView.bind(self.layout),
				onUpdate: function onUpdate() {
					self.layout.hideLoadingView();

if (_onUpdate) {
						_onUpdate();
					}
				}
			});
		};

this.showTemplates = function () {
			// The tabs should exist in DOM on loading.
			self.layout.setHeaderDefaultParts();
			self.layout.showModal();
			//self.layout.modal.refreshPosition();
			self.loadTemplates(function () {
				var templatesToShow = self.filterTemplates();
				self.layout.showTemplatesView(new TemplateLibraryCollection(templatesToShow));
			});
		};

this.filterTemplates = function () {
			//var activeSource = 'hub_collections';
			return templatesCollection.filter(function (model) {
				if ('hub_collections' !== model.get('source')) {
					return false;
				}

return 'block' === model.get('type') || 'page' === model.get('type');
			});
		};

this.requestTemplateContent = function (source, id, ajaxOptions) {
			var options = {
				unique_id: id,
				data: {
					source: source,
					edit_mode: true,
					display: true,
					template_id: id
				}
			};

if (ajaxOptions) {
				jQuery.extend(true, options, ajaxOptions);
			}

return elementorCommon.ajax.addRequest('get_template_data', options);
		};

this.markAsFavorite = function (templateModel, favorite) {
			var options = {
				data: {
					source: templateModel.get('source'),
					template_id: templateModel.get('template_id'),
					favorite: favorite
				}
			};
			return elementorCommon.ajax.addRequest('mark_template_as_favorite', options);
		};

this.getErrorDialog = function() {
			if ( ! errorDialog ) {
				errorDialog = elementorCommon.dialogsManager.createWidget( 'alert', {
					id: 'elementor-template-library-error-dialog',
					headerMessage: elementor.translate( 'an_error_occurred' ),
				} );
			}
	
			return errorDialog;
		};

this.showErrorDialog = function( errorMessage ) {
			if ( 'object' === typeof errorMessage ) {
				var message = '';
	
				_.each( errorMessage, function( error ) {
					message += '<div>' + error.message + '.</div>';
				} );
	
				errorMessage = message;
			} else if ( errorMessage ) {
				errorMessage += '.';
			} else {
				errorMessage = '<i>&#60;The error message is empty&#62;</i>';
			}
	
			self.getErrorDialog()
				.setMessage( elementor.translate( 'templates_request_error' ) + '<div id="elementor-template-library-error-info">' + errorMessage + '</div>' )
				.show();
		};

this.init = function() {
			registerDefaultFilterTerms();
			this.component = $e.components.register(new Component({
				manager: this
			}));
		};
	};

hub_templates_lib.templates = new TemplateLibraryManager();
	hub_templates_lib.templates.init();

elementor.on('document:loaded', function() {
		var $previewContents = elementor.$previewContents;
	
		var $templateLibBtnStyle = $( '<style />' ),
			btnStyle = '';
			btnStyle += '.elementor-add-section-area-button.hub-add-template-button { margin-left: 8px; vertical-align: bottom; }';
			btnStyle += '.elementor-add-section-area-button.hub-add-template-button img { height: 40px; padding: 5px; }';

$templateLibBtnStyle.html( btnStyle );

$previewContents.find('head').append( $templateLibBtnStyle );

$templateLibBtn.insertAfter( $previewContents.find('.elementor-add-section-area-button.elementor-add-template-button') );

$previewContents.find('body').delegate('.elementor-editor-element-add', 'click', ev => {
			const timeout = setTimeout(() => {
				
				const $currentTarget = $(ev.currentTarget);
				const $parentSection = $currentTarget.closest('.elementor-element');
				const $addSectionSection = $parentSection.prev('.elementor-add-section-inline');
				const $btnClone = $templateLibBtn.clone(false);

$btnClone.on( 'click', () => {

const sectionModelId = $parentSection.data('model-cid');
					const modelIndex = elementor.elements.findIndex(el => el['cid'] === sectionModelId);

const importOptions = {};

if ( modelIndex > -1 ) {
						importOptions['at'] = modelIndex;
					}

$e.run('hub_collections/open', { importOptions });

});

$btnClone.insertAfter( $addSectionSection.find('.elementor-add-section-area-button.elementor-add-template-button') );

$addSectionSection.find('.elementor-add-section-close').on('click', () => {
					const innerTimeout = setTimeout(() => {
						$btnClone.off();
						$btnClone.remove();
						clearTimeout(innerTimeout);
					}, 200);
				});

clearTimeout(timeout);

}, 100);
		});
	});

} )( elementor, jQuery, window );