package org.gcube.portlets.user.geoportaldataentry.client.ui;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.gcube.application.geoportalcommon.shared.SearchingFilter;
import org.gcube.application.geoportalcommon.shared.SearchingFilter.LOGICAL_OP;
import org.gcube.application.geoportalcommon.shared.SearchingFilter.ORDER;
import org.gcube.application.geoportalcommon.shared.WhereClause;
import org.gcube.application.geoportalcommon.shared.geoportal.ConfigurationDV;
import org.gcube.application.geoportalcommon.shared.geoportal.DocumentDV;
import org.gcube.application.geoportalcommon.shared.geoportal.GEOPORTAL_DATA_HANDLER;
import org.gcube.application.geoportalcommon.shared.geoportal.HandlerDeclarationDV;
import org.gcube.application.geoportalcommon.shared.geoportal.UseCaseDescriptorDV;
import org.gcube.application.geoportalcommon.shared.geoportal.config.GcubeProfileDV;
import org.gcube.application.geoportalcommon.shared.geoportal.config.ItemFieldDV;
import org.gcube.application.geoportalcommon.shared.products.ConcessioneDV;
import org.gcube.portlets.user.geoportaldataentry.client.events.CreateNewProjectEvent;
import org.gcube.portlets.user.geoportaldataentry.client.events.GetListOfRecordsEvent;
import org.gcube.portlets.user.geoportaldataentry.client.ui.form.GeonaDataEntryMainForm;
import org.gcube.portlets.user.geoportaldataentry.client.ui.utils.DialogInform;
import org.gcube.portlets.user.geoportaldataentry.client.ui.utils.LoaderIcon;
import org.gcube.portlets.user.geoportaldataentry.client.ui.utils.UCD_Util;

import com.github.gwtbootstrap.client.ui.Alert;
import com.github.gwtbootstrap.client.ui.Button;
import com.github.gwtbootstrap.client.ui.Dropdown;
import com.github.gwtbootstrap.client.ui.Hero;
import com.github.gwtbootstrap.client.ui.NavLink;
import com.github.gwtbootstrap.client.ui.PageHeader;
import com.github.gwtbootstrap.client.ui.Tab;
import com.github.gwtbootstrap.client.ui.TabPanel;
import com.github.gwtbootstrap.client.ui.TextBox;
import com.github.gwtbootstrap.client.ui.constants.AlertType;
import com.github.gwtbootstrap.client.ui.constants.ButtonType;
import com.github.gwtbootstrap.client.ui.constants.IconSize;
import com.google.gwt.core.client.GWT;
import com.google.gwt.core.client.Scheduler;
import com.google.gwt.core.client.Scheduler.ScheduledCommand;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.dom.client.KeyPressEvent;
import com.google.gwt.event.dom.client.KeyPressHandler;
import com.google.gwt.event.shared.HandlerManager;
import com.google.gwt.uibinder.client.UiBinder;
import com.google.gwt.uibinder.client.UiField;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.HTMLPanel;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.VerticalPanel;
import com.google.gwt.user.client.ui.Widget;

/**
 * The Class GeonaMainTabPanel.
 *
 * @author Francesco Mangiacrapa at ISTI-CNR francesco.mangiacrapa@isti.cnr.it
 * 
 *         Aug 5, 2021
 */
public class GeonaMainTabPanel extends Composite {

	private static final String LABEL_FILTER_SEPARATOR = " - ";

	protected static final int MIN_LENGHT_SERCHING_STRING = 3;

	private static GeonaMainTabPanelUiBinder uiBinder = GWT.create(GeonaMainTabPanelUiBinder.class);

	/**
	 * The Interface GeonaMainTabPanelUiBinder.
	 *
	 * @author Francesco Mangiacrapa at ISTI-CNR francesco.mangiacrapa@isti.cnr.it
	 * 
	 *         Aug 5, 2021
	 */
	interface GeonaMainTabPanelUiBinder extends UiBinder<Widget, GeonaMainTabPanel> {
	}

	/** The geona main form panel. */
	@UiField
	HTMLPanel geonaMainFormPanel;

	@UiField
	HTMLPanel geonaListOfRecordsPanel;

	/** The geona main form panel. */
	@UiField
	HTMLPanel contTabNewProject;

	@UiField
	HTMLPanel contTabGetListOfProjects;

	/** The loader. */
	@UiField
	LoaderIcon loader;

//	@UiField
//	NavLink buttCreateNewProject;

	@UiField
	NavLink buttonReloadConcessioni;

	@UiField
	TabPanel tabPanel;

	@UiField
	Tab tabNewProject;

	@UiField
	Tab tabGetListOfProjects;

	@UiField
	Dropdown dropdownSortBy;

	@UiField
	Dropdown dropdownSearchFor;

	@UiField
	Alert alertSortBy;

	@UiField
	Alert alertSearchFor;

	@UiField
	NavLink navShowOnMap;

	@UiField
	NavLink navShowReport;

	@UiField
	NavLink navEditMode;

	@UiField
	NavLink navDelete;

	@UiField
	TextBox searchField;

	@UiField
	Button resetSearch;

	@UiField
	Label roleLabel;

	@UiField
	Dropdown ddCreateNewProject;

	@UiField
	Dropdown ddProjectType;

	@UiField
	PageHeader pageHeaderDataEntry;

	@UiField
	Hero introGNAHero;

	private HandlerManager appManagerBus;

	private List<ItemFieldDV> sortByFields;

	private List<ItemFieldDV> searchForFields;

	private SearchingFilter currentSortFilter;

	private GeonaRecordsPaginatedView grpw = null;

	private List<ItemFieldDV> displayFields;

	private List<UseCaseDescriptorDV> listUCDescriptors;

	/**
	 * Instantiates a new geona main tab panel.
	 *
	 * @param appManagerBus     the first name
	 * @param initialSortFilter
	 * @param defaultItemField
	 */
	public GeonaMainTabPanel(HandlerManager appManagerBus, List<ItemFieldDV> defaultItemField,
			SearchingFilter initialSortFilter) {
		initWidget(uiBinder.createAndBindUi(this));
		this.appManagerBus = appManagerBus;
		setFilteringParameters(defaultItemField, defaultItemField, defaultItemField, initialSortFilter);
		alertSortBy.setType(AlertType.INFO);
		alertSortBy.setClose(false);

		alertSearchFor.setType(AlertType.INFO);
		alertSearchFor.setClose(false);

		bindEvents();
		resetSearch.setIconSize(IconSize.TWO_TIMES);
		resetSearch.setType(ButtonType.LINK);
		setLoaderVisible("", false);
	}

	/**
	 * Sets the filtering parameters.
	 *
	 * @param displayFields     the display fields
	 * @param sortByFields      the sort by fields
	 * @param searchForFields   the search for fields
	 * @param initialSortFilter the initial sort filter
	 */
	public void setFilteringParameters(List<ItemFieldDV> displayFields, List<ItemFieldDV> sortByFields,
			List<ItemFieldDV> searchForFields, SearchingFilter initialSortFilter) {
		this.displayFields = displayFields;
		this.sortByFields = sortByFields;
		this.currentSortFilter = initialSortFilter;
		this.searchForFields = searchForFields;

		alertSearchFor.setText(searchForFields.get(0).getDisplayName());
		alertSortBy.setText(toLabelFilter((initialSortFilter.getOrderByFields().get(0)), initialSortFilter.getOrder()));
	}

	/**
	 * Sets the internal height.
	 *
	 * @param height the new internal height
	 */
	public void setInternalHeight(int height) {
		contTabNewProject.asWidget().setHeight(height + "px");
		contTabGetListOfProjects.asWidget().setHeight(height + "px");
	}

	/**
	 * Bind events.
	 */
	private void bindEvents() {

//		buttCreateNewProject.addClickHandler(new ClickHandler() {
//
//			@Override
//			public void onClick(ClickEvent event) {
//				appManagerBus.fireEvent(new CreateNewProjectEvent());
//
//			}
//		});

		buttonReloadConcessioni.addClickHandler(new ClickHandler() {

			@Override
			public void onClick(ClickEvent event) {
				Window.alert("buttonReloadConcessioni MUST BE REVISITED");
				/*
				 * appManagerBus.fireEvent(new GetListOfRecordsEvent(RECORD_TYPE.CONCESSIONE,
				 * getCurrentSortFilter()));
				 */

			}
		});

		tabGetListOfProjects.addClickHandler(new ClickHandler() {

			@Override
			public void onClick(ClickEvent event) {

				instanceAndShowListOfConcessioni();
			}
		});

		for (ItemFieldDV record_FIELD : sortByFields) {

//			if (record_FIELD.equals(RECORD_FIELD.RECORD_STATUS))
//				continue;

			// ASC
			String labelASC = toLabelFilter(record_FIELD, ORDER.ASC);
			NavLink nav = new NavLink(labelASC);
			dropdownSortBy.add(nav);

			nav.addClickHandler(new ClickHandler() {

				@Override
				public void onClick(ClickEvent event) {
					alertSortBy.setText(labelASC);
					Window.alert("ASC MUST BE REVISITED");
					/*
					 * appManagerBus.fireEvent(new GetListOfRecordsEvent(RECORD_TYPE.CONCESSIONE,
					 * getCurrentSortFilter()));
					 */
				}
			});

//			//DESC
			String labelDESC = toLabelFilter(record_FIELD, ORDER.DESC);
			NavLink nav2 = new NavLink(labelDESC);
			dropdownSortBy.add(nav2);

			nav2.addClickHandler(new ClickHandler() {

				@Override
				public void onClick(ClickEvent event) {
					alertSortBy.setText(labelDESC);
					Window.alert("DESC MUST BE REVISITED");
					/*
					 * appManagerBus.fireEvent(new GetListOfRecordsEvent(RECORD_TYPE.CONCESSIONE,
					 * getCurrentSortFilter()));
					 */
				}
			});
		}

		for (ItemFieldDV record_FIELD : searchForFields) {

			NavLink nav = new NavLink(record_FIELD.getDisplayName());
			dropdownSearchFor.add(nav);

			nav.addClickHandler(new ClickHandler() {

				@Override
				public void onClick(ClickEvent event) {
					alertSearchFor.setText(record_FIELD.getDisplayName());

					if (searchField.getText().length() >= MIN_LENGHT_SERCHING_STRING) {
						doSearchEvent();
					}

				}
			});
		}

		navShowOnMap.addClickHandler(new ClickHandler() {

			@Override
			public void onClick(ClickEvent event) {
				List<DocumentDV> listConcessioni = null;
				if (grpw != null && grpw.getSelectItems() != null) {
					listConcessioni = grpw.getSelectItems();
				}

				Window.alert("ACTION_ON_ITEM.VIEW_ON_MAP must be implemented");
				/*
				 * appManagerBus .fireEvent(new
				 * ActionOnItemEvent<ConcessioneDV>(listConcessioni,
				 * ACTION_ON_ITEM.VIEW_ON_MAP));
				 */

			}
		});

		navShowReport.addClickHandler(new ClickHandler() {

			@Override
			public void onClick(ClickEvent event) {
				List<DocumentDV> listConcessioni = null;
				if (grpw != null && grpw.getSelectItems() != null) {
					listConcessioni = grpw.getSelectItems();
				}

				Window.alert("ACTION_ON_ITEM.VIEW_REPORT must be implemented");
				/*
				 * appManagerBus .fireEvent(new
				 * ActionOnItemEvent<ConcessioneDV>(listConcessioni,
				 * ACTION_ON_ITEM.VIEW_REPORT));
				 */
			}
		});

		navEditMode.addClickHandler(new ClickHandler() {

			@Override
			public void onClick(ClickEvent event) {

				List<DocumentDV> listConcessioni = null;
				if (grpw != null && grpw.getSelectItems() != null) {
					listConcessioni = grpw.getSelectItems();
				}

				Window.alert("ACTION_ON_ITEM.EDIT_PROJECT must be implemented");

				/*
				 * appManagerBus .fireEvent(new
				 * ActionOnItemEvent<ConcessioneDV>(listConcessioni,
				 * ACTION_ON_ITEM.EDIT_PROJECT));
				 */
			}
		});

		navDelete.addClickHandler(new ClickHandler() {

			@Override
			public void onClick(ClickEvent event) {
				List<DocumentDV> listConcessioni = null;
				if (grpw != null && grpw.getSelectItems() != null) {
					listConcessioni = grpw.getSelectItems();
				}

				Window.alert("ACTION_ON_ITEM.DELETE_PROJECT must be implemented");
				/*
				 * appManagerBus.fireEvent( new
				 * ActionOnItemEvent<ConcessioneDV>(listConcessioni,
				 * ACTION_ON_ITEM.DELETE_PROJECT));
				 */
			}
		});

		searchField.addKeyPressHandler(new KeyPressHandler() {

			@Override
			public void onKeyPress(KeyPressEvent event) {
				GWT.log("CHAR CODE: " + event.getCharCode());
				if (com.google.gwt.event.dom.client.KeyCodes.KEY_ENTER == event.getCharCode()) {
					GWT.log(searchField.getText());
					doSearchEvent();
				}

			}
		});

		resetSearch.addClickHandler(new ClickHandler() {

			@Override
			public void onClick(ClickEvent event) {
				searchField.setText("");
				Window.alert("resetSearch MUST BE REVISITED");
				/*
				 * appManagerBus.fireEvent(new GetListOfRecordsEvent(RECORD_TYPE.CONCESSIONE,
				 * getCurrentSortFilter())); resetSearch.setVisible(false);
				 */
			}
		});

	}

	/**
	 * Sets the role label.
	 *
	 * @param msg the new role label
	 */
	public void setRoleLabel(String msg) {
		roleLabel.setText(msg);
	}

	/**
	 * Do search event.
	 */
	private void doSearchEvent() {
		String searchText = searchField.getText();
		if (searchText.length() < MIN_LENGHT_SERCHING_STRING) {
			Window.alert("Please enter at least " + MIN_LENGHT_SERCHING_STRING + " characters");
			return;
		}

		resetSearch.setVisible(true);

		Window.alert("doSearchEvent MUST BE REVISITED");
		/*
		 * appManagerBus.fireEvent(new GetListOfRecordsEvent(RECORD_TYPE.CONCESSIONE,
		 * getCurrentSortFilter()));
		 */
	}

	/**
	 * To label filter.
	 *
	 * @param itemField the item field
	 * @param direction the direction
	 * @return the string
	 */
	private String toLabelFilter(ItemFieldDV itemField, ORDER direction) {
		String labelFilter = itemField.getDisplayName() + LABEL_FILTER_SEPARATOR + direction.name();
		return labelFilter;
	}

	/**
	 * Adds the form panel.
	 *
	 * @param formPanel the form panel
	 */
	public void addFormPanel(GeonaDataEntryMainForm formPanel) {
		geonaMainFormPanel.add(formPanel);
	}

	/**
	 * Show list of concessioni view.
	 *
	 * @param grpw the grpw
	 */
	public void showListOfConcessioniView(GeonaRecordsPaginatedView grpw) {
		this.grpw = grpw;
		geonaListOfRecordsPanel.clear();
		VerticalPanel htmllPanel = new VerticalPanel();
		htmllPanel.add(grpw.getCellPanel());
		htmllPanel.add(grpw.getPagerPanel());
		geonaListOfRecordsPanel.add(htmllPanel);
	}

	/**
	 * Sets the loader visible.
	 *
	 * @param txtHTML the txt HTML
	 * @param visible the visible
	 */
	public void setLoaderVisible(String txtHTML, boolean visible) {
		loader.setText(txtHTML);
		loader.setVisible(visible);
	}

	/**
	 * To sort filter.
	 *
	 * @param labelFilter the label filter
	 * @return the searching filter
	 */
	public SearchingFilter toSortFilter(String labelFilter) {
		GWT.log("toSortFilter for label " + labelFilter);
		String[] array = labelFilter.split(LABEL_FILTER_SEPARATOR);

		SearchingFilter sortFilter = null;
		try {
			ItemFieldDV recordField = null;
			for (ItemFieldDV value : sortByFields) {
				if (array[0].equalsIgnoreCase(value.getDisplayName())) {
					recordField = value;
					break;
				}
			}
			ORDER orderField = ORDER.valueOf(array[1]);
			sortFilter = new SearchingFilter(Arrays.asList(recordField), orderField);
		} catch (Exception e) {

		}
		GWT.log("toSortFilter Got " + sortFilter);
		return sortFilter;

	}

	/**
	 * Built searching filter.
	 *
	 * @return the searching filter
	 */
	private SearchingFilter builtSearchingFilter() {
		SearchingFilter searchingFilter = toSortFilter(alertSortBy.getText());
		String searchText = searchField.getText();
		if (searchText != null && !searchText.isEmpty()) {
			Map<String, Object> searchInto = new HashMap<String, Object>();

			String searchForField = "";

			for (ItemFieldDV recordField : searchForFields) {
				if (recordField.getDisplayName().equals(alertSearchFor.getText())) {
					searchForField = recordField.getJsonFields().get(0);
					continue;
				}
			}
			searchInto.put(searchForField, searchText);
			WhereClause where = new WhereClause();
			where.setSearchInto(searchInto);
			where.setOperator(LOGICAL_OP.OR);
			searchingFilter.setConditions(Arrays.asList(where));
		}
		return searchingFilter;
	}

	/**
	 * Gets the current sort filter.
	 *
	 * @return the current sort filter
	 */
	public SearchingFilter getCurrentSortFilter() {
		currentSortFilter = builtSearchingFilter();
		GWT.log("currentSortFilter: " + currentSortFilter);
		return currentSortFilter;
	}

	/**
	 * Removes the tab.
	 *
	 * @param index the index
	 */
	public void removeTab(int index) {
		tabPanel.remove(index);
	}

	/**
	 * Sets the tab active.
	 *
	 * @param index the new tab active
	 */
	public void setTabActive(int index) {
		tabPanel.selectTab(index);
	}

	/**
	 * Dirty solution. I created this one because I had problem on firing click
	 * event for Tab element
	 * 
	 */
	public void instanceAndShowListOfConcessioni() {
		Window.alert("instanceAndShowListOfConcessioni MUST BE REVISITED");
		/*
		 * grpw = new GeonaRecordsPaginatedView(appManagerBus, RECORD_TYPE.CONCESSIONE,
		 * displayFields, currentSortFilter); showListOfConcessioniView(grpw);
		 */
	}

	/**
	 * Sets the list use case descriptors.
	 *
	 * @param listUCDescriptors the new list use case descriptors
	 */
	public void setListUseCaseDescriptors(List<UseCaseDescriptorDV> listUCDescriptors) {
		GWT.log("Setting listUCDescriptors: " + listUCDescriptors);
		this.listUCDescriptors = listUCDescriptors;
		ddCreateNewProject.clear();

		for (final UseCaseDescriptorDV ucd : listUCDescriptors) {

			HandlerDeclarationDV dataEntryHandler = UCD_Util.getHandlerDeclarationFor(ucd,
					GEOPORTAL_DATA_HANDLER.geoportal_data_entry);

			if (dataEntryHandler != null) {
				ConfigurationDV<?> config = dataEntryHandler.getConfiguration();
				List<GcubeProfileDV> listGcubeProfiles = toListGcubeProfiles(config);

				final List<GcubeProfileDV> listProfiles = listGcubeProfiles;

				NavLink link = new NavLink(ucd.getName());
				link.addClickHandler(new ClickHandler() {

					@Override
					public void onClick(ClickEvent event) {

						if (listProfiles == null || listProfiles.size() == 0) {
							DialogInform di = new DialogInform(null, "No configuration found",
									"No GcubeProfile found in the Configuration for " + config.getConfiguration());
							di.center();
							return;
						}

						appManagerBus.fireEvent(
								new CreateNewProjectEvent(ucd.getProfileID(), dataEntryHandler, listProfiles));
					}
				});

				ddCreateNewProject.add(link);
			}

			// Setting Project type having HANDLER DATA LIST
			HandlerDeclarationDV dataListHandler = UCD_Util.getHandlerDeclarationFor(ucd,
					GEOPORTAL_DATA_HANDLER.geoportal_data_list);

			if (dataListHandler != null) {

				NavLink link = new NavLink(ucd.getName());
				link.addClickHandler(new ClickHandler() {

					@Override
					public void onClick(ClickEvent event) {

						appManagerBus.fireEvent(new GetListOfRecordsEvent(ucd.getName(), ucd.getProfileID(),
								getCurrentSortFilter(), true));
					}
				});

				ddProjectType.add(link);

			}
		}

		// IF one type of document is available, fire
		// CreateNewProjectEvent(documentConfigDV));
		if (listUCDescriptors.size() == 1) {
			Scheduler.get().scheduleDeferred(new ScheduledCommand() {

				@Override
				public void execute() {
					GWT.log("One Config loaded. Firing CreateNewProjectEvent");
					UseCaseDescriptorDV useCaseDescriptor = listUCDescriptors.get(0);
					HandlerDeclarationDV dataEntryHandler = UCD_Util.getHandlerDeclarationFor(useCaseDescriptor,
							GEOPORTAL_DATA_HANDLER.geoportal_data_entry);
					if (dataEntryHandler != null) {
						ConfigurationDV<?> config = dataEntryHandler.getConfiguration();
						List<GcubeProfileDV> listGcubeProfiles = toListGcubeProfiles(config);
						appManagerBus.fireEvent(new CreateNewProjectEvent(useCaseDescriptor.getProfileID(),
								dataEntryHandler, listGcubeProfiles));
					}

				}

			});

		}
	}

	/**
	 * To list gcube profiles.
	 *
	 * @param config the config
	 * @return the list
	 */
	private List<GcubeProfileDV> toListGcubeProfiles(ConfigurationDV<?> config) {

		try {
			return (List<GcubeProfileDV>) config.getConfiguration();
		} catch (Exception e) {
			GWT.log("Error on casting " + ConfigurationDV.class.getName() + " to List of "
					+ GcubeProfileDV.class.getName());
		}

		return null;
	}

	/**
	 * To list item fields.
	 *
	 * @param config the config
	 * @return the list
	 */
	private List<ItemFieldDV> toListItemFields(ConfigurationDV<?> config) {

		try {
			return (List<ItemFieldDV>) config.getConfiguration();
		} catch (Exception e) {
			GWT.log("Error on casting " + ConfigurationDV.class.getName() + " to List of "
					+ ItemFieldDV.class.getName());
		}

		return null;
	}

	/**
	 * Sets the page header.
	 *
	 * @param hDV the new page header
	 */
	public void setPageHeader(HandlerDeclarationDV hDV) {
		introGNAHero.setVisible(false);
		this.pageHeaderDataEntry.setVisible(true);
		this.pageHeaderDataEntry.setText("");
		this.pageHeaderDataEntry.setSubtext("New: " + hDV.getItemType());
	}

	/**
	 * Gets the list UC descriptors.
	 *
	 * @return the list UC descriptors
	 */
	public List<UseCaseDescriptorDV> getListUCDescriptors() {
		return listUCDescriptors;
	}

	public List<ItemFieldDV> getDisplayFields() {
		return displayFields;
	}

}