/*
 * 
 */
package org.gcube.portlets.user.geoportaldataviewer.client;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.gcube.application.geoportalcommon.shared.gis.BoundsMap;
import org.gcube.application.geoportalcommon.shared.products.BaseConcessioneDV;
import org.gcube.application.geoportalcommon.shared.products.content.WorkspaceContentDV;
import org.gcube.application.geoportalcommon.shared.products.model.LayerConcessioneDV;
import org.gcube.application.geoportalcommon.shared.products.model.UploadedImageDV;
import org.gcube.portlets.user.geoportaldataviewer.client.GeoportalDataViewerConstants.LayerType;
import org.gcube.portlets.user.geoportaldataviewer.client.GeoportalDataViewerConstants.MAP_PROJECTION;
import org.gcube.portlets.user.geoportaldataviewer.client.GeoportalDataViewerConstants.MapEventType;
import org.gcube.portlets.user.geoportaldataviewer.client.events.AddedLayerToMapEvent;
import org.gcube.portlets.user.geoportaldataviewer.client.events.AddedLayerToMapEventHandler;
import org.gcube.portlets.user.geoportaldataviewer.client.events.QueryDataEvent;
import org.gcube.portlets.user.geoportaldataviewer.client.events.QueryDataEventHandler;
import org.gcube.portlets.user.geoportaldataviewer.client.events.ShowDetailsEvent;
import org.gcube.portlets.user.geoportaldataviewer.client.events.ZoomOutOverMinimumEvent;
import org.gcube.portlets.user.geoportaldataviewer.client.events.ZoomOutOverMinimumEventHandler;
import org.gcube.portlets.user.geoportaldataviewer.client.gis.ExtentWrapped;
import org.gcube.portlets.user.geoportaldataviewer.client.gis.MapUtils;
import org.gcube.portlets.user.geoportaldataviewer.client.gis.OpenLayerMap;
import org.gcube.portlets.user.geoportaldataviewer.client.ui.ModalWindow;
import org.gcube.portlets.user.geoportaldataviewer.client.util.StringUtil;
import org.gcube.portlets.user.geoportaldataviewer.client.util.URLUtil;
import org.gcube.portlets.user.geoportaldataviewer.shared.GeoNaSpatialQueryResult;
import org.gcube.portlets.user.geoportaldataviewer.shared.gis.GeoQuery;
import org.gcube.portlets.user.geoportaldataviewer.shared.gis.LayerItem;
import org.gcube.portlets.user.geoportaldataviewer.shared.gis.LayerObject;
import org.gcube.portlets.user.geoportaldataviewer.shared.gis.wfs.FeatureRow;
import org.gcube.portlets.user.geoportaldataviewer.shared.gis.wms.GeoInformationForWMSRequest;
import org.gcube.portlets.user.geoportaldataviewer.shared.gis.wms.ZAxis;

import com.github.gwtbootstrap.client.ui.Button;
import com.github.gwtbootstrap.client.ui.Heading;
import com.github.gwtbootstrap.client.ui.Label;
import com.github.gwtbootstrap.client.ui.constants.ButtonType;
import com.github.gwtbootstrap.client.ui.constants.IconType;
import com.github.gwtbootstrap.client.ui.constants.LabelType;
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.dom.client.Style.Unit;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.shared.HandlerManager;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Element;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.EventListener;
import com.google.gwt.user.client.Random;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.FlexTable;
import com.google.gwt.user.client.ui.FlowPanel;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.ScrollPanel;
import com.google.gwt.user.client.ui.VerticalPanel;

import ol.Coordinate;
import ol.Extent;
import ol.OLFactory;
import ol.format.GeoJson;
import ol.geom.Geometry;

/**
 * The Class LayerManager.
 *
 * @author Francesco Mangiacrapa at ISTI-CNR (francesco.mangiacrapa@isti.cnr.it)
 * 
 *         Oct 27, 2020
 */
public class LayerManager {

	/** The ol map. */
	private OpenLayerMap olMap;

	private Map<String, LayerObject> mapDetailLayerObjects = new HashMap<String, LayerObject>();
	private Map<String, LayerObject> mapBaseLayerObjects = new HashMap<String, LayerObject>();

	private HandlerManager layerManagerBus = new HandlerManager("");

	private HandlerManager applicationBus;

	private org.gcube.application.geoportalcommon.shared.LayerItem baseLayerFromISProfile;

	private OverlayLayerManager overlayLayerManager;

	/**
	 * Instantiates a new layer manager.
	 *
	 * @param applicationBus the application bus
	 */
	public LayerManager(HandlerManager applicationBus) {
		this.applicationBus = applicationBus;
		overlayLayerManager = new OverlayLayerManager(applicationBus);
		bindEvents();
	}

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

		layerManagerBus.addHandler(QueryDataEvent.TYPE, new QueryDataEventHandler() {

			@Override
			public void onQueryInteraction(final QueryDataEvent queryEvent) {
				// GeoportalDataViewerConstants.print("fired QueryDataEvent:
				// "+queryEvent.toString());

				if (queryEvent.getGeoQuery() != null) {
					GeoQuery selectDataInfo = queryEvent.getGeoQuery();
					String mongoItemId = queryEvent.getMongoItemId();

					GWT.log("(" + selectDataInfo.getX1() + "," + selectDataInfo.getY1() + ")(" + selectDataInfo.getX2()
							+ "," + selectDataInfo.getY2() + ")");

					BoundsMap mapBBOX = new BoundsMap();
					double minX = queryEvent.getGeoQuery().getX1();
					double minY = queryEvent.getGeoQuery().getY1();
					Coordinate centerCoordinate = new Coordinate(minX, minY);
					centerCoordinate = olMap.transform(centerCoordinate, MAP_PROJECTION.EPSG_3857.getName(),
							MAP_PROJECTION.EPSG_4326.getName());
					mapBBOX.setLowerLeftX(centerCoordinate.getX());
					mapBBOX.setLowerLeftY(centerCoordinate.getY());

//					double maxX = olMap.getExtent().getUpperRightX();
//					double maxY = olMap.getExtent().getUpperRightY();
					double maxX = queryEvent.getGeoQuery().getX2();
					double maxY = queryEvent.getGeoQuery().getY2();
					centerCoordinate = new Coordinate(maxX, maxY);
					centerCoordinate = olMap.transform(centerCoordinate, MAP_PROJECTION.EPSG_3857.getName(),
							MAP_PROJECTION.EPSG_4326.getName());
					mapBBOX.setUpperRightX(centerCoordinate.getX());
					mapBBOX.setUpperRightY(centerCoordinate.getY());

					mapBBOX.setCrs(MAP_PROJECTION.EPSG_4326.getName());

					GWT.log("Bounds is: " + mapBBOX);
					GWT.log("MAX_WFS_FEATURES is: " + GeoportalDataViewerConstants.MAX_WFS_FEATURES);
					// GeoportalDataViewerConstants.print("calling getDataResult");

					List<LayerObject> listLO = new ArrayList<LayerObject>();
					// for querying base layers
					listLO.addAll(mapBaseLayerObjects.values());

					// for querying detail layers only in this case
					if (olMap.getCurrentResolution() < OLMapManager.LAYER_DETAIL_MAX_RESOLUTION) {
						Collection<LayerObject> collLO = mapDetailLayerObjects.values();
						listLO.addAll(collLO);

						ArrayList<LayerObject> layerVisibility = new ArrayList<LayerObject>(collLO.size());
						layerVisibility.addAll(collLO);
						// Managing layer visibility. If a layer is not visible has to be not queryable
						for (LayerObject layerObject : layerVisibility) {
							String layerName = layerObject.getLayerItem().getName();
							boolean isLayerVisible = olMap.isLayerVisible(layerName);
							if (!isLayerVisible) {
								GWT.log("From querying removing layername: " + layerName + ", it is not visible");
								listLO.remove(layerObject);
							}
//							else {
//								ExtentWrapped layerExtent = olMap.getSourceExtentForLayer(layerName);
//								if(layerExtent!=null) {
//									ExtentWrapped centerQueryPoint = new ExtentWrapped(minX, minY, maxX,maxY);
//								
//									boolean contains = layerExtent.containsExtent(centerQueryPoint);
//									GWT.log("layer: "+layerName + " contains the queried BBOX: "+contains);
//								}
//							}
//							
						}
					}

					GeoportalDataViewerServiceAsync.Util.getInstance().getDataResult(listLO, olMap.getProjectionCode(),
							mapBBOX, GeoportalDataViewerConstants.MAX_WFS_FEATURES, olMap.getCurrentZoomLevel(),
							new AsyncCallback<List<GeoNaSpatialQueryResult>>() {

								@Override
								public void onFailure(Throwable caught) {
									// GeoportalDataViewerConstants.print("on Failure DataResult:
									// "+caught.getMessage());
								}

								@Override
								public void onSuccess(List<GeoNaSpatialQueryResult> listGeonaDataObjects) {

									GWT.log("GeoNaDataObject's is/are " + listGeonaDataObjects.size());
									// GWT.log("GeoNaDataObject's: " + listGeonaDataObjects);
//									 GeoportalDataViewerConstants.print("GeoNaDataObject's:
//									 "+listGeonaDataObjects);

									if (listGeonaDataObjects == null || listGeonaDataObjects.isEmpty())
										return;

									List<FeatureRow> theFeatures = null;

									MapEventType sourceEvent = queryEvent.getSourceMapEventType();

									// TODO SWTCH FOR EARCH ITEM TYPE
									for (GeoNaSpatialQueryResult geoNaDataObject : listGeonaDataObjects) {
										GWT.log("GeoNaDataObject: " + geoNaDataObject);
										List<FeatureRow> features = geoNaDataObject.getFeatures();
										LayerItem layerItem = geoNaDataObject.getSourceLayerObject().getLayerItem();
										GWT.log("   features: " + features);
										GWT.log("   layerItem: " + layerItem);

										GWT.log("GeoNaDataObject Source layer item name: " + layerItem.getName());

										HashMap<String, List<FeatureRow>> listUniqueProducts = new HashMap<String, List<FeatureRow>>();
										// Clustering features for productId
										if (features != null && features.size() > 0) {
											String theProductId = null;
											for (FeatureRow fRow : features) {
												List<String> productIdLst = fRow.getMapProperties().get("product_id");
												if (productIdLst != null) {
													theProductId = productIdLst.get(0);
													if (theProductId != null) {
														List<FeatureRow> listFeatures = listUniqueProducts
																.get(theProductId);
														if (listFeatures == null) {
															listFeatures = new ArrayList<FeatureRow>();
														}

														listFeatures.add(fRow);
														listUniqueProducts.put(theProductId, listFeatures);
													}
												}
											}

										}

										GWT.log("listUniqueProducts keyset: " + listUniqueProducts.keySet());

										// USING ONLY THE FIRST FEATURE IN THE LIST
										if (features != null && features.size() > 0) {

											// I need to show exactly the feature with produc_id == recordId
											if (mongoItemId != null) {
												GWT.log("MongoItemId is not null: " + mongoItemId);
												// Searching mongoItemId in the list of product
												theFeatures = listUniqueProducts.get(mongoItemId);
												GWT.log("Loaded mongoItemId == product_id with id: " + mongoItemId
														+ ", the features are: " + theFeatures);

												// the recordId/mongoItemId to show has been passed but not found into
												// list of
												// FeatureRow
												if (theFeatures == null || theFeatures.isEmpty()) {
													return;
												}
											}

											// If mongoItemId not passed
											if (mongoItemId == null) {
												GWT.log("MongoItemId is null");
												// Checking if the features returned belonging to detail layers (not
												// centroids).
												if (listUniqueProducts.isEmpty()) {
													// in this case the feature/s returned is/are a (detail) layer/s
													// belonging
													// to a record/concessione (not centroid layer),
													// so calling show popuup info on detail layers if the
													// following events are true.
													if (sourceEvent.equals(MapEventType.MOUSE_CLICK) && olMap
															.getCurrentZoomLevel() > OLMapManager.QUERY_MIN_ZOOM_LEVEL) {

														// Here I need to pass only the visible layers
														showPopupInfoForLayer(listGeonaDataObjects,
																queryEvent.getQueryClickExtent());
													}
													return;
												}
											}

											// The features of the first centroid layer selected
											if (theFeatures == null || theFeatures.size() == 0) {
												for (String theProductId : listUniqueProducts.keySet()) {

													theFeatures = listUniqueProducts.get(theProductId);

													if (theFeatures.size() > 0)
														break;

												}
											}

											// Displaying popup info for centroid layer passing the first feature
											if (sourceEvent.equals(MapEventType.MOUSE_CLICK)
													|| sourceEvent.equals(MapEventType.ADDED_CENTROID_LAYER_TO_MAP)) {
												GWT.log("Source event is: " + MapEventType.MOUSE_CLICK + ", or "
														+ MapEventType.ADDED_CENTROID_LAYER_TO_MAP);

												// Displaying popup info for centroid layer passing the first feature
												showPopupInfoForCentroidLayer(geoNaDataObject, theFeatures.get(0),
														queryEvent.getQueryClickExtent().getCenter());
											}

											if (olMap.getCurrentZoomLevel() > OLMapManager.QUERY_MIN_ZOOM_LEVEL) {
												GWT.log("Current zoom level is less than QUERY_MIN_ZOOM_LEVEL, Loading all layers of any product");
												for (String theProductId : listUniqueProducts.keySet()) {
													GWT.log("Loading layers of theProductId: " + theProductId);
													// retrieving and showing WMS layers of a concessione if the ZOOM
													// level
													// is >
													// QUERY_MIN_ZOOM_LEVEL

													GeoportalDataViewerServiceAsync.Util.getInstance().getLayersForId(
															"concessione", theProductId,
															new AsyncCallback<List<LayerConcessioneDV>>() {

																@Override
																public void onFailure(Throwable caught) {
																	// TODO Auto-generated method stub

																}

																@Override
																public void onSuccess(List<LayerConcessioneDV> result) {

																	for (LayerConcessioneDV layer : result) {
																		GWT.log("Adding layer: "
																				+ layer.getLayerName());
																		addLayer("concessione", layer.getLayerName(),
																				layer.getLayerName(),
																				layer.getWmsLink(), false, false,
																				layer.getLayerUUID(), true,
																				OLMapManager.LAYER_DETAIL_MIN_RESOLUTION,
																				OLMapManager.LAYER_DETAIL_MAX_RESOLUTION,
																				layer.getRefersTo());
																	}

																}
															});
												}
											} else {
												// removing all WMS detail layers if the ZOOM level is <
												// QUERY_MIN_ZOOM_LEVEL
												removeAllDetailLayers();
											}
										}
									}
								}
							});
				}
			}
		});

		layerManagerBus.addHandler(AddedLayerToMapEvent.TYPE, new AddedLayerToMapEventHandler() {

			@Override
			public void onLayerRendered(AddedLayerToMapEvent addedLayerToMapEvent) {
				GWT.log("Fired into layerManagerBus " + addedLayerToMapEvent);
				applicationBus.fireEvent(addedLayerToMapEvent);
			}
		});

		layerManagerBus.addHandler(ZoomOutOverMinimumEvent.TYPE, new ZoomOutOverMinimumEventHandler() {

			@Override
			public void onZoomOut(ZoomOutOverMinimumEvent zoomOutEvent) {
				GWT.log("Fired into layerManagerBus " + zoomOutEvent);
				removeAllDetailLayers();
				applicationBus.fireEvent(zoomOutEvent);
			}
		});
	}

	/**
	 * Removes the all detail layers.
	 */
	public void removeAllDetailLayers() {
		mapDetailLayerObjects.clear();
		olMap.removeAllDetailLayers();
		overlayLayerManager.resetLayers();
	}

	/**
	 * Parses the geona references.
	 *
	 * @param itemType the item type
	 * @param fRow     the f row
	 * @return the show details event
	 */
	private ShowDetailsEvent parseGeonaReferences(String itemType, FeatureRow fRow) {
		if (fRow == null)
			return null;

		List<String> productIds = fRow.getMapProperties().get("product_id");
		if (productIds != null && productIds.size() > 0) {
			String productId = productIds.get(0);
			String itemName = "Dettagli Prodotto";
			List<String> listName = fRow.getMapProperties().get("nome");
			if (listName != null && listName.size() > 0) {
				itemName = listName.get(0);
			}

			return new ShowDetailsEvent(itemType, productId, itemName, fRow);
		}

		return null;
	}

	/**
	 * Adds the layer.
	 *
	 * @param geonaItemType           the geona item type
	 * @param layerTitle              the layer title
	 * @param layerName               the layer name
	 * @param wmsLink                 the wms link
	 * @param isBase                  the is base
	 * @param displayInLayerSwitcher  the display in layer switcher
	 * @param UUID                    the uuid
	 * @param asDetailLayer           the as detail layer
	 * @param minResolution           the min resolution
	 * @param maxResolution           the max resolution
	 * @param refersToBaseConcessione the refers to base concessione
	 */
	public void addLayer(final String geonaItemType, final String layerTitle, final String layerName,
			final String wmsLink, final boolean isBase, final boolean displayInLayerSwitcher, final String UUID,
			final boolean asDetailLayer, Double minResolution, Double maxResolution,
			BaseConcessioneDV refersToBaseConcessione) {

//		final LayoutContainer westPanel = (LayoutContainer) layersPanel.getParent();
//
//		if(layersPanel.getLayerItems().size()==0)
//			westPanel.mask("Adding..."+layerName, "x-mask-loading");
//		else
//			layersPanel.mask("Adding..."+layerName, "x-mask-loading");

		final LayerType featureType = isBase ? LayerType.RASTER_BASELAYER : LayerType.FEATURE_TYPE;
//		Info.display("Adding Layer", layerName);

		if (wmsLink == null || wmsLink.isEmpty()) {
			GeoportalDataViewerConstants.printJs("Skipping add layer for wmsLink as null or empty");
			return;
		}

		GeoportalDataViewerServiceAsync.Util.getInstance().parseWmsRequest(wmsLink, layerName,
				new AsyncCallback<GeoInformationForWMSRequest>() {

					@Override
					public void onFailure(Throwable caught) {

						Window.alert(caught.getMessage());
					}

					@Override
					public void onSuccess(GeoInformationForWMSRequest geoInfoWMS) {

						GWT.log("Parsed WMS Request returned: " + geoInfoWMS);
						// ddLayerByWms(featureType, layerTitle, result.getLayerName(),
						// result.getWmsRequest(), result.getBaseWmsServiceHost(), true, isBase,
						// displayInLayerSwitcher, (ArrayList<String>)
						// result.getStyles().getGeoStyles(), result.getWmsRequest(), false,
						// result.getMapWMSNoStandard(), result.isNcWMS(), UUID, result.getZAxis());

						LayerItem layerItem = toLayerItem(featureType, layerTitle, geoInfoWMS.getLayerName(),
								geoInfoWMS.getWmsRequest(), geoInfoWMS.getBaseWmsServiceHost(), true, isBase,
								displayInLayerSwitcher, (ArrayList<String>) geoInfoWMS.getStyles().getGeoStyles(),
								geoInfoWMS.getWmsRequest(), false, geoInfoWMS.getMapWMSNoStandard(),
								geoInfoWMS.isNcWMS(), UUID, geoInfoWMS.getZAxis(), minResolution, maxResolution);

						LayerObject lo = new LayerObject();
						lo.setLayerItem(layerItem);
						lo.setItemType(geonaItemType);
						lo.setSourceConcessione(refersToBaseConcessione);

						String key = layerItem.getName(); // should be unique
						// layerObjects.put(key, lo);

						if (!asDetailLayer) {
							// is a base layer
							LayerObject blo = mapBaseLayerObjects.get(key);
							if (blo == null) {
								olMap.addWMSLayer(layerItem);
								mapBaseLayerObjects.put(key, lo);
							} else {
								GWT.log("Skipping base layer " + key + " already added to Map");
							}
						} else {
							LayerObject dlo = mapDetailLayerObjects.get(key);
							if (dlo == null) {
								mapDetailLayerObjects.put(key, lo);
								olMap.addWMSDetailLayer(layerItem);
								overlayLayerManager.addLayerItem(lo);
								// overlayLayerManager.show();
							} else {
								GWT.log("Skipping detail layer " + key + " already added to Map");
							}
						}
					}
				});
	}

	/**
	 * To layer item.
	 *
	 * @param layerType              the layer type
	 * @param layerTitle             the layer title
	 * @param layerName              the layer name
	 * @param layerURL               the layer URL
	 * @param mapServerHost          the map server host
	 * @param isExternal             the is external
	 * @param isBase                 the is base
	 * @param displayInLayerSwitcher the display in layer switcher
	 * @param styles                 the styles
	 * @param wmsLink                the wms link
	 * @param onTop                  the on top
	 * @param wmsNotStandardParams   the wms not standard params
	 * @param isNcWms                the is nc wms
	 * @param UUID                   the uuid
	 * @param zAxis                  the z axis
	 * @param minResolution          the min resolution
	 * @param maxResolution          the max resolution
	 * @return the layer item
	 */
	private LayerItem toLayerItem(LayerType layerType, String layerTitle, String layerName, String layerURL,
			String mapServerHost, boolean isExternal, boolean isBase, boolean displayInLayerSwitcher,
			ArrayList<String> styles, String wmsLink, boolean onTop, HashMap<String, String> wmsNotStandardParams,
			boolean isNcWms, String UUID, ZAxis zAxis, Double minResolution, Double maxResolution) {

//		GWT.log("Add addLayerByWms 1");
		LayerItem layerItem = new LayerItem();
		layerItem.setBaseLayer(isBase);
		layerItem.setTitle(layerTitle);
		layerItem.setName(layerName);
		layerItem.setUrl(layerURL);
		layerItem.setMapServerHost(mapServerHost);
		// l.setExternal(isExternal);
		layerItem.setOpacity(1d);
		layerItem.setBuffer(2);
		layerItem.setWmsLink(wmsLink);
		layerItem.setWmsNotStandardParams(wmsNotStandardParams);
		layerItem.setNcWms(isNcWms);
		layerItem.setUUID(UUID);
		layerItem.setZAxis(zAxis);
		layerItem.setMinResolution(minResolution);
		layerItem.setMaxResolution(maxResolution);

		switch (layerType) {

		// TODO IMPLEMENT THIS CASE
		case RASTER_BASELAYER:

//				l.setHasLegend(false);
			layerItem.setBaseLayer(true);
			layerItem.setTrasparent(false);
			layerItem.setClickData(false);
			break;

		case FEATURE_TYPE:

			// CASE FEATURE TYPE
			layerItem.setBaseLayer(false);
			layerItem.setClickData(true);
			layerItem.setTrasparent(true);
			break;

		}

		GWT.log("styles " + styles);

		if (styles != null && styles.size() > 0) {
			layerItem.setHasLegend(true);
			layerItem.setDefaultStyle(styles.get(0));
			layerItem.setStyle(styles.get(0));
			layerItem.setStyles(styles);
		} else {
			String style = URLUtil.getValueOfParameter("styles", wmsLink);
			if (style != null) { // CASE OF STYLE ="";
				// TENTATIVE TO GET LEGEND
				layerItem.setHasLegend(true);
			}
		}
		GWT.log("Built layer: " + layerItem);
		return layerItem;
	}

	/**
	 * Show popup info for layer.
	 *
	 * @param listGeoNaDataObject the list geo na data object
	 * @param queryClick          the query click
	 */
	public void showPopupInfoForLayer(List<GeoNaSpatialQueryResult> listGeoNaDataObject, ExtentWrapped queryClick) {

		ScrollPanel scrollPanel = new ScrollPanel();
		final FlowPanel flowPanel = new FlowPanel();
		flowPanel.getElement().getStyle().setProperty("maxHeight", "600px");
		scrollPanel.add(flowPanel);

		List<Button> listOpenProject = new ArrayList<Button>();

		final Button expandButton = new Button("Expand");
		expandButton.setType(ButtonType.LINK);
		expandButton.setIcon(IconType.EXPAND);
		expandButton.getElement().setId("expand-query");
		expandButton.setTitle("Show this view in new Window");

		flowPanel.add(expandButton);

		Scheduler.get().scheduleDeferred(new ScheduledCommand() {

			@Override
			public void execute() {
				Element buttonElement = DOM.getElementById("expand-query");
				Event.sinkEvents(buttonElement, Event.ONCLICK);
				Event.setEventListener(buttonElement, new EventListener() {

					@Override
					public void onBrowserEvent(Event event) {
						if (Event.ONCLICK == event.getTypeInt()) {
							expandButton.setVisible(false);
							// hiding the Open Project in expand mode (Modal Window)
							for (Button butt : listOpenProject) {
								butt.setVisible(false);
							}
							flowPanel.getElement().getStyle().setProperty("maxHeight", "100%");
							int width = Window.getClientWidth() * 75 / 100;
							int height = Window.getClientHeight() * 70 / 100;
							Coordinate center = queryClick.getCenter();
							double x = center.getX();
							double y = center.getY();
							// "with center x: "+x +", y: "+y;
							ModalWindow mw = new ModalWindow("Query results...", width, height);
							mw.add(flowPanel);
							mw.show();
						}
					}
				});
			}
		});

		String prevConcessioneName = "";
		for (GeoNaSpatialQueryResult geoNaSpatialQueryResult : listGeoNaDataObject) {
			try {
				GWT.log("baseLayerFromISProfile.getName() :" + baseLayerFromISProfile.getName());
				LayerObject lo = geoNaSpatialQueryResult.getSourceLayerObject();
				LayerItem sourceLI = lo.getLayerItem();

				String layerSourceName = sourceLI.getName();

				// skipping centroid layer
				if (layerSourceName == null
						|| layerSourceName.compareToIgnoreCase(baseLayerFromISProfile.getName()) == 0) {
					continue;
				}

				List<FeatureRow> features = geoNaSpatialQueryResult.getFeatures();

				if (features == null || features.isEmpty()) {
					continue;
				}

				String nomeConcessione = lo.getSourceConcessione().getNome();
				if (prevConcessioneName.compareTo(nomeConcessione) != 0) {
					String concessioneIntro = nomeConcessione.length() > 100
							? StringUtil.ellipsize(nomeConcessione, 100)
							: nomeConcessione;
					Heading heading = new Heading(4, concessioneIntro);
					heading.setTitle(nomeConcessione);
					heading.getElement().getStyle().setMarginBottom(10, Unit.PX);
					flowPanel.add(heading);

					Button buttOpenProject = new Button("Open Project");
					final String buttId = "open-details-" + Random.nextInt();
					Element bEl = buttOpenProject.getElement();
					bEl.setId(buttId);
					bEl.getStyle().setPaddingLeft(0, Unit.PX);
					buttOpenProject.setType(ButtonType.LINK);

					if (buttOpenProject != null) {
						flowPanel.add(buttOpenProject);
						buttOpenProject.setType(ButtonType.LINK);
						Scheduler.get().scheduleDeferred(new ScheduledCommand() {

							@Override
							public void execute() {
								Element buttonElement = DOM.getElementById(buttId);
								Event.sinkEvents(buttonElement, Event.ONCLICK);
								Event.setEventListener(buttonElement, new EventListener() {

									@Override
									public void onBrowserEvent(Event event) {
										if (Event.ONCLICK == event.getTypeInt()) {
											applicationBus.fireEvent(new ShowDetailsEvent("concessione",
													lo.getSourceConcessione().getItemId(), nomeConcessione, null));

										}
									}
								});
							}
						});
					}
					listOpenProject.add(buttOpenProject);

					HTML subText = new HTML(
							"<p style=\"color:#999; font-size:14px; margin:5px 0 5px 0;\">Layers and Properties</p>");
					flowPanel.add(subText);
				}

				prevConcessioneName = nomeConcessione;

				Label layerLabel = new Label();
				layerLabel.setType(LabelType.INFO);

				String layerName = StringUtil.fullNameToLayerName(layerSourceName, ":");
				layerLabel.setText(layerName);
				layerLabel.setTitle(layerSourceName);
				layerLabel.getElement().getStyle().setMarginTop(10, Unit.PX);
				layerLabel.getElement().getStyle().setMarginBottom(5, Unit.PX);
				flowPanel.add(layerLabel);

				GWT.log("Displaying " + features.size() + " features");
				FlexTable intFlex = new FlexTable();
				intFlex.setCellPadding(1);
				intFlex.setCellSpacing(1);
				intFlex.getElement().addClassName("table-feature");
				intFlex.setHTML(0, 0, new HTML("Feature Id").toString());

				int i = 0;
				for (FeatureRow feature : features) {

					intFlex.setHTML(i + 1, 0, new HTML(feature.getId()).toString());

					// Showing properties belonging to concessioni layer
					Map<String, List<String>> entries = feature.getMapProperties();

					if (entries.size() == 0) {
						// Adding this row to show "no property" for feature
						// intFlex.setHTML(i + 1, 1, new HTML("<i>No property</i>").toString());
					}
					int j = 0;
					for (String key : entries.keySet()) {
						List<String> theValues = entries.get(key);
						String valueToDisplay = "";
						for (String value : theValues) {
							valueToDisplay += value + ", ";

						}
						valueToDisplay = valueToDisplay.substring(0, valueToDisplay.length() - 2);

						// adding the keys only of first feature row. They are equal for all features
						// (beloning to same layer).
						if (i == 0)
							intFlex.setHTML(0, j + 1, new HTML(key).toString());

						intFlex.setHTML(i + 1, j + 1, new HTML(valueToDisplay).toString());
						j++;

					}
					i++;
				}
				flowPanel.add(intFlex);
			} catch (Exception e) {
				GeoportalDataViewerConstants.printJs("Error: " + e.getMessage());
			}
		}

		olMap.showPopup(scrollPanel.toString(), queryClick.getCenter());

	}

	/**
	 * Show popup info for centroid layer.
	 *
	 * @param geoNaDataObject   the geo na data object
	 * @param feature           the feature
	 * @param onFailureCenterTo the on failure center to
	 */
	public void showPopupInfoForCentroidLayer(GeoNaSpatialQueryResult geoNaDataObject, FeatureRow feature,
			Coordinate onFailureCenterTo) {

		FlexTable flex = new FlexTable();
		flex.setCellPadding(1);
		flex.setCellSpacing(1);
		flex.getElement().addClassName("popup-table");
		VerticalPanel vpPanel = new VerticalPanel();
		vpPanel.add(flex);

		if (feature == null) {
			flex.setHTML(0, 0, new HTML("No data available").toString());
			olMap.showPopup(vpPanel.toString(), onFailureCenterTo);
			return;
		}

		// Showing properties belonging to concessioni centroid layer
		Map<String, List<String>> entries = feature.getMapProperties();

		String nome = "";
		String descrizione = "";
		String date = "";

		for (String key : entries.keySet()) {
			String theValue = entries.get(key).get(0);
			if (key.equalsIgnoreCase("nome")) {
				nome = theValue != null ? theValue : "";
			} else if (key.equalsIgnoreCase("descrizione")) {
				descrizione = theValue != null ? theValue : "";
			} else if (key.equalsIgnoreCase("date_scavo")) {
				date = theValue != null ? theValue : "";
			}
		}

		// GeoportalDataViewerConstants.print("0: "+nome);
		flex.setHTML(0, 0, new HTML(nome).toString());
		try {
			descrizione = StringUtil.ellipsize(descrizione, 100);
			GWT.log("reduced: " + descrizione);
		} catch (Exception e) {
			GWT.log("error: " + e.getMessage());
		}
		// GeoportalDataViewerConstants.print("1: "+descrizione);
		flex.setText(1, 0, descrizione);
		// GeoportalDataViewerConstants.print("2: "+date);
		date = StringUtil.formatDate(date);
		flex.setHTML(2, 0, new HTML("<code>" + date + "</code>").toString());

		if (geoNaDataObject.getMapImages() != null) {
			for (String key : geoNaDataObject.getMapImages().keySet()) {
				List<UploadedImageDV> listUI = geoNaDataObject.getMapImages().get(key);
				GWT.log("Adding images: " + listUI);
				if (listUI != null && listUI.size() > 0) {
					UploadedImageDV img = listUI.get(0);
					if (img != null && img.getListWsContent() != null) {
						WorkspaceContentDV wsContent = img.getListWsContent().get(img.getListWsContent().size() - 1);
						String theImgHTML = "<img src=\"" + wsContent.getLink() + "\"></img>";
						GWT.log("theImgHTML: " + theImgHTML);
						// GeoportalDataViewerConstants.print("The row are:
						// "+flex.getRowCount());
						flex.setHTML(flex.getRowCount() + 1, 0, theImgHTML);
					}
				}
			}
		}

		GWT.log("The selected Feature is: " + feature);
		// GeoportalDataViewerConstants.print("The selected Feature is: "+feature);
		FeatureRow theFeature = feature;
		Button button = new Button("Open Details");
		button.getElement().setId("open-details");
		button.setType(ButtonType.LINK);

		if (button != null) {
			vpPanel.add(button);
			button.setType(ButtonType.LINK);
			button.addClickHandler(new ClickHandler() {

				@Override
				public void onClick(ClickEvent event) {
					ShowDetailsEvent toEvent = parseGeonaReferences(
							geoNaDataObject.getSourceLayerObject().getItemType(), theFeature);
					applicationBus.fireEvent(toEvent);

				}
			});
		}

		Coordinate centerTo = null;
		GWT.log("geometry is: " + feature.getGeometry());
		if (feature.getGeometry() != null) {
			GWT.log("trasforming geometry: " + feature.getGeometry().getToJSONObject());

			Geometry geom = new GeoJson().readGeometry(feature.getGeometry().getToJSONObject(), null);

			// POINT
			if (geom.getType().equalsIgnoreCase("Point")) {
				GWT.log("geometry: is a point");
				String coordinateJSON = feature.getGeometry().getCoordinatesJSON();
				JSONArray centerJSON = (JSONArray) JSONParser.parseStrict(coordinateJSON);
//			Coordinate center = OLFactory.createCoordinate(
//					new Double(centerJSON.get(0).toString()),
//					new Double(centerJSON.get(1).toString()));

				Coordinate center = new Coordinate(new Double(centerJSON.get(0).toString()),
						new Double(centerJSON.get(1).toString()));

				if (feature.getCrsName() != null && feature.getCrsName().endsWith(MAP_PROJECTION.EPSG_4326.getId())) {

					center = MapUtils.transformCoordiante(center, MAP_PROJECTION.EPSG_4326.getName(),
							MAP_PROJECTION.EPSG_3857.getName());
				}
				centerTo = center;
			} else {

				Extent geomExtent = geom.getExtent();

				Coordinate lower = OLFactory.createCoordinate(geomExtent.getLowerLeftX(), geomExtent.getLowerLeftY());
				Coordinate upper = OLFactory.createCoordinate(geomExtent.getUpperRightX(), geomExtent.getUpperRightY());
				Coordinate lowerCoord = lower;
				Coordinate upperCoord = upper;
				if (feature.getCrsName() != null && feature.getCrsName().endsWith(MAP_PROJECTION.EPSG_4326.getId())) {

					lowerCoord = MapUtils.transformCoordiante(lower, MAP_PROJECTION.EPSG_4326.getName(),
							MAP_PROJECTION.EPSG_3857.getName());
					upperCoord = MapUtils.transformCoordiante(upper, MAP_PROJECTION.EPSG_4326.getName(),
							MAP_PROJECTION.EPSG_3857.getName());
				}

				ExtentWrapped ew = new ExtentWrapped(lowerCoord.getX(), lowerCoord.getY(), upperCoord.getX(),
						upperCoord.getY());

				centerTo = new Coordinate(ew.getCenter().getX(), ew.getCenter().getY());

			}
			GWT.log("center is: " + centerTo);
		}

		// fallback
		if (centerTo == null)
			centerTo = onFailureCenterTo;

		olMap.showPopup(vpPanel.toString(), centerTo);

		Scheduler.get().scheduleDeferred(new ScheduledCommand() {

			@Override
			public void execute() {
				Element buttonElement = DOM.getElementById("open-details");
				Event.sinkEvents(buttonElement, Event.ONCLICK);
				Event.setEventListener(buttonElement, new EventListener() {

					@Override
					public void onBrowserEvent(Event event) {
						if (Event.ONCLICK == event.getTypeInt()) {
							ShowDetailsEvent toEvent = parseGeonaReferences(
									geoNaDataObject.getSourceLayerObject().getItemType(), theFeature);
							applicationBus.fireEvent(toEvent);
						}
					}
				});
			}

		});

	}

	/**
	 * Sets the ol map.
	 *
	 * @param olMap the new ol map
	 */
	public void setOLMap(OpenLayerMap olMap) {
		this.olMap = olMap;
	}

	/**
	 * Gets the layer manager bus.
	 *
	 * @return the layer manager bus
	 */
	public HandlerManager getLayerManagerBus() {
		return layerManagerBus;
	}

	/**
	 * Sets the base layer from is profile.
	 *
	 * @param layerItem the new base layer from is profile
	 */
	public void setBaseLayerFromIsProfile(org.gcube.application.geoportalcommon.shared.LayerItem layerItem) {
		this.baseLayerFromISProfile = layerItem;
	}

	/**
	 * Gets the base layer from IS proile.
	 *
	 * @return the base layer from IS proile
	 */
	public org.gcube.application.geoportalcommon.shared.LayerItem getBaseLayerFromISProile() {
		return baseLayerFromISProfile;
	}

	/**
	 * Gets the overlay layer manager.
	 *
	 * @return the overlay layer manager
	 */
	public OverlayLayerManager getOverlayLayerManager() {
		return overlayLayerManager;
	}

}