AUI.add(
	'form-error-handler',
	function(A) {

		var ERROR_BLOCK_DIV = '<div class="form-validator-stack help-block" id="{nameSpace}{fieldId}Helper">'+
								'<div role="alert" class="required">{messageError}</div>'+
								'</div>';

		var FormErrorHandler = {

			init: function(params) {
				var instance = this;
				var portletNamespace = params.nameSpace;
				var errorMessages = params.errorMessages;
				try{
					if(errorMessages !== '' && typeof errorMessages !== 'undefined'){
						var errorMessagesArray = JSON.parse(errorMessages);
						var arrayLength = errorMessagesArray.length;
						for (var i = 0; i < arrayLength; i++) {
							var entryItem = errorMessagesArray[i];
							var fieldId = entryItem.fieldId;
							var messageKey = entryItem.messageKey;
							instance._manageFieldError(portletNamespace, fieldId, messageKey);
						}
					}
				}catch(err){
					//
				}
			},
			
			_manageFieldError: function(portletNamespace, fieldId, messageKey){
				var instance = this;
				var fieldElement = instance._getFieldThatHasError(portletNamespace, fieldId);
				var outerFieldDiv = instance._getDivToAppendError(fieldElement);
				var htmlToAppend = A.Lang.sub(
						ERROR_BLOCK_DIV,
						{
							nameSpace: portletNamespace,
							fieldId: fieldId,
							messageError: Liferay.Language.get(messageKey)
						}
				); 
				
				$(fieldElement).addClass('error-field');
				$(outerFieldDiv).addClass('has-error');
				$(outerFieldDiv).append(htmlToAppend);
			},
			
			_getFieldThatHasError: function(portletNamespace, fieldId){
				var instance = this;
				var fieldElement = $('#'+portletNamespace+fieldId);
				if(instance._hasNoValue(fieldElement)){
					fieldElement = $('#'+portletNamespace+fieldId+'CustomId');
				}
				return fieldElement;
			},
			
			_getDivToAppendError: function(fieldElement){
				var instance = this;
				var outerFieldDiv = $(fieldElement).closest('.input-text-wrapper');
				if(instance._hasNoValue(outerFieldDiv)){
					outerFieldDiv = $(fieldElement).closest('.field-wrapper');
					if(instance._hasNoValue(outerFieldDiv)){
						outerFieldDiv = fieldElement;
					}
				}
				return outerFieldDiv;
			},
			
			_hasNoValue: function(itemToCheck){
				return itemToCheck === null || typeof itemToCheck === 'undefined' || itemToCheck.length <=0;
			}

		};
		A.FormErrorHandler = FormErrorHandler;
	},
	'',
	{
		requires: [	
			'aui-base'
		]
	}
);


AUI.add(
	'group-suggestions',
	function(A) {

		var TPL_BLOCK_SUGGESTION_ROW = '<div class="nameplate">' +
							'<div class="nameplate-field">' +
							'<img class="img-circle group-logo-default-small" src="{portraitURL}">' +
							'</div>' +
							'<div class="nameplate-content">' +
							'<h4>{name}</h4>' +
							'</div>' +
							'</div>';

		var GroupSuggestions = {

			init: function(params) {

				var instance = this;
				instance.getGroupSuggestionsResourceURL = params.getGroupSuggestionsResourceURL;
				instance.form = params.form;
				instance.inputNodeFieldId = '#' + params.nameSpace + 'groupSuggestions';
				instance.requestTemplate = '&' + params.nameSpace + 'keyword={query}';
				instance.groupIdFieldId = '#' + params.nameSpace + 'groupId';

				var dataSource = new A.DataSource.IO(
					{
					source: instance.getGroupSuggestionsResourceURL
					}
				);

				var autoComplete = new A.AutoCompleteList({
					allowBrowserAutocomplete: false,
					activateFirstItem: true,
					inputNode: instance.inputNodeFieldId,
					maxResults: 10,
					minQueryLength: 2,
					on: {
						select: function(event) {
							var result = event.result.raw;
							A.one(instance.groupIdFieldId).val(result.groupId);
							A.one(instance.inputNodeFieldId).val('');
							document.forms[instance.form].submit();
						}
					},
					render: true,
					source: dataSource,
					requestTemplate: instance.requestTemplate,
					resultFormatter: function(query, results){

						var groupListEntries = A.Array.map(results, function(result){

							var groupListEntryMarkUp  = A.Lang.sub(
											TPL_BLOCK_SUGGESTION_ROW,
											{
												portraitURL: result.raw.portraitURL,
												name: result.raw.name,
											}
										);


							return groupListEntryMarkUp;
						});

						return groupListEntries;
					},
					resultListLocator: function (response) {
						return A.JSON.parse(response[0].responseText);
					},
					resultTextLocator: function (result) {
						return '';
					}
				});
			}

		};

		A.GroupSuggestions = GroupSuggestions;
	},
	'',
	{
		requires: [	
			'aui-base',
			'datasource-io',
			'autocomplete-list'
		]
	}
);


AUI().ready('aui-module', function(A){ 
    let focusEnabled = false;
	$("#p_p_id_com_liferay_login_web_portlet_LoginPortlet_, #p_p_id_com_liferay_login_web_portlet_FastLoginPortlet_").find(".field.form-control").each(function() {
        if ($(this)[0].type === 'text' && !$(this)[0].value && focusEnabled === false) {
            $(this).focus();
            focusEnabled = true;
        }
    });
});
AUI.add(
	'settings-nav',
	function(A) {
		var SettingsNav = {

			init: function() {

				var dropdown = $('.settings-nav.dropdown'); 

				// Open dropdown when user clicks on settings block

				$('.settings-nav .dropdown-toggle').on('click', function() {
					dropdown.toggleClass('open');
				});

				// Close dropdown when close button is clicked

				$('.settings-nav .dropdown-menu .btn-close').on('click', function() {
					dropdown.toggleClass('open');
				});

				// Close dropdown when user clicks outside of the dropdown

				$(document).mouseup(function (e) {
				    var openDropdown = $(".settings-nav.dropdown.open");

				    if (!openDropdown.is(e.target) // if the target of the click isn't the dropdown...
				        && openDropdown.has(e.target).length === 0) // ... nor a descendant of the dropdown
				    {
				    	openDropdown.toggleClass('open');
				    }
				});
			}

		};
		A.SettingsNav = SettingsNav;
	},
	'',
	{
		requires: [	
			'aui-base'
		]
	}
);


var	NAME = 'teamworxxsigninmodal';
AUI.add(
	'teamworxx-sign-in-modal',
	function(A) {

		var WIN = A.config.win;

		var TeamworxxSignInModal = A.Component.create(
			{
				ATTRS: {
					resetFormValidator: {
						value: true
					},

					signInPortlet: {
						setter: A.one,
						value: '#p_p_id_com_liferay_login_web_portlet_LoginPortlet_'
					}
				},

				EXTENDS: A.Plugin.Base,

				NAME: NAME,

				NS: NAME,

				prototype: {
					initializer: function(config) {
						var instance = this;

						var signInPortlet = instance.get('signInPortlet');

						if (signInPortlet) {
							instance._signInPortletBody = signInPortlet.one('.portlet-content');
						}

						var host = instance.get('host');

						instance._host = host;
						instance._signInPortlet = signInPortlet;

						instance._signInURL = host.attr('href');

						if (signInPortlet) {
							var formNode = signInPortlet.one('form');

							if (formNode) {
								var form = Liferay.Form.get(formNode.attr('id'));

								instance._formValidator = '';

								if (form) {
									instance._formValidator = form.formValidator;
								}

								instance._hasSignInForm = formNode.hasClass('sign-in-form');
								
							}
						}

						instance._bindUI();
					},

					destructor: function() {
						var dialog = Liferay.Util.getWindow(NAME);

						if (dialog) {
							dialog.destroy();
						}
					},

					_bindUI: function() {
						var instance = this;
						instance._host.on('click', A.bind('_load', instance));

						var destroyModal = function(event) {
							instance.destroy();

							Liferay.detach('screenLoad', destroyModal);
						};

						Liferay.on('screenLoad', destroyModal);
					},

					_load: function(event) {
						var instance = this;

						event.preventDefault();

						if (instance._signInPortletBody && instance._hasSignInForm) {
							instance._loadDOM();
						}
						else {
							instance._loadIO();
						}
					},

					_loadDOM: function() {
						var instance = this;

						var signInPortletBody = instance._signInPortletBody;

						if (!instance._originalParentNode) {
							instance._originalParentNode = signInPortletBody.ancestor();
						}

						instance._setModalContent(signInPortletBody);

						var uri = new A.Url(instance._signInURL);

						var redirect = uri.getParameter('redirect');

						signInPortletBody.one('input[id$=redirectTwoFactor]').set("value",redirect);

						Liferay.Util.focusFormField(signInPortletBody.one('input:text'));
					},

					_loadIO: function() {
						var instance = this;

						var modalSignInURL = Liferay.Util.addParams('windowState=exclusive', instance._signInURL);

						A.io.request(
							modalSignInURL,
							{
								on: {
									failure: A.bind('_redirectPage', instance),
									success: function(event, id, obj) {
										var responseData = this.get('responseData');

										if (responseData) {
											instance._setModalContent(responseData);
										}
										else {
											instance._redirectPage();
										}
									}
								}
							}
						);
					},

					_redirectPage: function() {
						var instance = this;
						WIN.location.href = instance._redirectPage;
					},

					_setModalContent: function(content) {
						var instance = this;
						
						var uri = new A.Url(instance._signInURL);

						var redirect = uri.getParameter('redirect');
						var currentURL = $(location).attr('href');
						var portletURL = new Liferay.PortletURL.createRenderURL(currentURL);

						portletURL.setPortletId('com_liferay_login_web_portlet_FastLoginPortlet');
						portletURL.setWindowState('POP_UP');
						portletURL.setParameter('p_auth', Liferay.authToken);
						portletURL.setParameter('redirect', redirect);

						Liferay.Util.openWindow(
							{
								dialog: {
									destroyOnHide: true,
									height: 605,
									width: 340
								},
								id: NAME,
								title: 'Log\x20in',
								uri: portletURL.toString()
							}
						);
					}
				}
			}
		);

		Liferay.TeamworxxSignInModal = TeamworxxSignInModal;
	},
	'',
	{
		requires: ['aui-base', 'aui-component', 'aui-io-request', 'aui-parse-content', 'liferay-form', 'liferay-portlet-url', 'liferay-util-window', 'plugin']
	}
);

AUI().ready('aui-module', function(A){ 
	var popUp = Liferay.Util.getWindow(NAME);
	if (Liferay.ThemeDisplay.isSignedIn() && typeof popUp != 'undefined') {
		window.top.location.reload();
		popUp.destroy();
	}
});
AUI.add(
	'user-suggestions',
	function(A) {

		var TPL_BLOCK_SUGGESTION_ROW = '<div class="nameplate">' +
							'<div class="nameplate-field">' +
							'<img class="img-circle user-logo-small" src="{portraitURL}">' +
							'</div>' +
							'<div class="nameplate-content">' +
							'<h4>{fullName}{userStatus}</h4>' +
							'<p>{emailAddress}</p>' +
							'</div>' +
							'</div>';

		var UserSuggestions = {

			init: function(params) {

				var instance = this;
				instance.getUserSuggestionsResourceURL = params.getUserSuggestionsResourceURL;
				instance.form = params.form;
				instance.inputNodeFieldId = '#' + params.nameSpace + 'userSuggestions';
				instance.requestTemplate = '&' + params.nameSpace + 'keyword={query}';
				var userIdParamName = params.userIdParam;
				if(userIdParamName == undefined){
					userIdParamName = 'userId';
				}
				instance.userIdFieldId = '#' + params.nameSpace + userIdParamName;

				var dataSource = new A.DataSource.IO(
					{
					source: instance.getUserSuggestionsResourceURL
					}
				);

				var autoComplete = new A.AutoCompleteList({
					allowBrowserAutocomplete: false,
					activateFirstItem: true,
					inputNode: instance.inputNodeFieldId,
					maxResults: 10,
					minQueryLength: 2,
					on: {
						select: function(event) {
							var result = event.result.raw;
							A.one(instance.userIdFieldId).val(result.userId);
							A.one(instance.inputNodeFieldId).val('');
							document.forms[instance.form].submit();
						}
					},
					render: true,
					source: dataSource,
					requestTemplate: instance.requestTemplate,
					resultFormatter: function(query, results){

						var userListEntries = A.Array.map(results, function(result){
							var userStatusLabel = '';
							if(result.raw.inactive){
								userStatusLabel = ' ('+'Inactive'+')';
							}
							var userListEntryMarkUp  = A.Lang.sub(
											TPL_BLOCK_SUGGESTION_ROW,
											{
												portraitURL: result.raw.portraitURL,
												fullName: result.raw.fullName,
												userStatus: userStatusLabel,
												emailAddress: result.raw.emailAddress
											}
										);


							return userListEntryMarkUp;
						});

						return userListEntries;
					},
					resultListLocator: function (response) {
						return A.JSON.parse(response[0].responseText);
					},
					resultTextLocator: function (result) {
						return '';
					}
				});
			}

		};

		A.UserSuggestions = UserSuggestions;
	},
	'',
	{
		requires: [	
			'aui-base',
			'datasource-io',
			'autocomplete-list'
		]
	}
);


AUI.add(
	'search-suggestions',
	function(A) {

		// Used for search bar on search portlets
		A.PortletSearchSuggestions = {
				init: function(params) {
					var instance = this;
					instance.form = params.form;
					instance.inputNodeFieldId = '#' + params.inputNodeFieldId;
					instance.autoSuggestMaxResults = params.autoSuggestMaxResults;
					instance.getAutoSuggestResourceURL = params.getAutoSuggestResourceURL;
					instance.requestTemplate = '&' + params.nameSpace + 'keywords={query}';
					instance.dataSource = getDataSource(A, params.getAutoSuggestResourceURL);
					
					instance.autoComplete = getAutoCompleteList(A, instance, params);	
				}
		},

		// Used for global search bar
		A.GlobalSearchSuggestions = {
			init: function(params) {
				var instance = this;
				
				// Destroys previous instance to handle the search group or groups condition.
				if (typeof instance.autoComplete !== 'undefined') {
					instance.autoComplete.destroy(true);
				}

				instance.form = params.form;
				instance.inputNodeFieldId = '#' + params.inputNodeFieldId;
				instance.autoSuggestMaxResults = params.autoSuggestMaxResults;
				instance.getAutoSuggestResourceURL = params.getAutoSuggestResourceURL;
				instance.requestTemplate = '&' + params.nameSpace + 'keywords={query}';
				instance.dataSource = getDataSource(A, params.getAutoSuggestResourceURL);
				instance.autoComplete = getAutoCompleteList(A, instance, params);
			}
		};
	},
	'',
	{
		requires: [	
			'aui-base',
			'datasource-io',
			'autocomplete-list'
		]
	}
);

var TPL_BLOCK_SUGGESTION_ROW = '<div class="nav-link">' +
'		{title}' +
'</div>';

function getAutoCompleteList(A, instance, params) {
	return new A.AutoCompleteList({
		allowBrowserAutocomplete: false,
		activateFirstItem: false,
		inputNode: instance.inputNodeFieldId,
		maxResults: instance.autoSuggestMaxResults,
		minQueryLength: 2,
		on: {
			select: function(event) {
				var result = event.result.raw;
				A.one(instance.inputNodeFieldId).val(result.title);
				document.forms[instance.form].submit();
			}
		},
		render: true,
		source: instance.dataSource,
		requestTemplate: instance.requestTemplate,
		resultFormatter: function(query, results){

			var searchResultEntries = A.Array.map(results, function(result){

				var searchResultListEntryMarkUp  = A.Lang.sub(
								TPL_BLOCK_SUGGESTION_ROW,
								{
									title: result.raw.title
								}
							);

				return searchResultListEntryMarkUp;
			});

			return searchResultEntries;
		},
		resultListLocator: function (response) {
			return A.JSON.parse(response[0].responseText);
		},
		resultTextLocator: function (result) {
			return '';
		}
	});
}

function getDataSource(A, url) {
	return new A.DataSource.IO( {
			source: url
		}
	);
}

;(function() {
	var adjustScrollTop = function() {
		var controlMenu;
		var controlMenuId;
		var controlMenuScroll;
		var errorFieldLabel;
		var labelScroll;

		errorFieldLabel = document.querySelector('.form-group.has-error .control-label');

		if (errorFieldLabel) {
			labelScroll = (errorFieldLabel.clientHeight || 0);

			window.scrollBy(0, -labelScroll);
		}

		if (Liferay.ControlMenu) {
			controlMenuId = Liferay.ControlMenu._namespace + 'ControlMenu';
			controlMenu = document.getElementById(controlMenuId);

			if (controlMenu) {
				controlMenuScroll = (controlMenu.offsetHeight || 0);

				window.scrollBy(0, -controlMenuScroll);
			}
		}
	};

	var handleFormRegistered = function(event) {
		if (event.form && event.form.formValidator) {
			AUI().Do.after(
				adjustScrollTop,
				event.form.formValidator,
				'focusInvalidField'
			);
		}
	};

	Liferay.on('form:registered', handleFormRegistered);
}());