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

import java.util.ArrayList;
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.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.OpenLayerOSM;
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.Label;
import com.github.gwtbootstrap.client.ui.constants.ButtonType;
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.Window;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.FlexTable;
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 OpenLayerOSM olMap;

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

	private HandlerManager layerManagerBus = new HandlerManager("");

	private HandlerManager applicationBus;

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

	/**
	 * Instantiates a new layer manager.
	 *
	 * @param applicationBus the application bus
	 */
	public LayerManager(HandlerManager applicationBus) {
		this.applicationBus = 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() + ")");

//					for (LayerObject layerObj : layerObjects.values()) {
//						// TODO
//						isLayerVisible(layerObj.getLayerItem());
//					}

					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<String> mapLayers = olMap.getLayers();
////					List<LayerObject> listLO = new ArrayList<LayerObject>(mapLayers.size());
//					for (String layerName : mapLayers) {
////						LayerItem layerItem = new LayerItem();
////						layerItem.setName(layerName);
////						listLO.add(new LayerObject("Concessione",layerItem));
//						GWT.log("Layer found: "+layerName);
//					}
					
					List<LayerObject> listLO = new ArrayList<LayerObject>(layerObjects.values());
					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;

									FeatureRow feature = null;

									// TODO SWTCH FOR EARCH ITEM TYPE
									for (GeoNaSpatialQueryResult geoNaDataObject : listGeonaDataObjects) {
										List<FeatureRow> features = geoNaDataObject.getFeatures();

										GWT.log("GeoNaDataObject Source layer item name: "
												+ geoNaDataObject.getSourceLayerObject().getLayerItem().getName());

										// USING ONLY THE FIRST FEATURE IN THE LIST
										if (features != null && features.size() > 0) {
											String theProductId = null;
											// I need to show exactly the feature with produc_id == recordId
											if (mongoItemId != null) {
												for (FeatureRow fRow : features) {
													List<String> productIdLst = fRow.getMapProperties()
															.get("product_id");
													theProductId = productIdLst.get(0);
													try {
														// long productId = Long.parseLong(thePID);
														if (theProductId == mongoItemId) {
															feature = fRow;
															GWT.log("Found recorId == product_id with id: "
																	+ theProductId);
															break;
														}
													} catch (Exception e) {
														// TODO: handle exception
													}
												}
											}

											// If mongoItemId not passed, I'm using the first feature returned
											if (mongoItemId == null) {
												feature = features.get(0);
												List<String> productIdLst = feature.getMapProperties()
														.get("product_id");
												if (productIdLst == null) {
													// 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 (queryEvent.getSourceMapEventType()
															.equals(MapEventType.MOUSE_CLICK)
															&& olMap.getCurrentZoomLevel() > OLMapManager.QUERY_MIN_ZOOM_LEVEL) {
														
														//Here I need to pass only the visible layers
														showPopupInfoForLayer(listGeonaDataObjects,
																queryEvent.getOnFailureCenterTo());
													}
													return;
												}
												theProductId = productIdLst.get(0);
											} else {
												// the recordId to show has been passed but not found into list of
												// FeatureRow
												if (feature == null) {
													return;
												}
											}

											GWT.log("the product id is: " + theProductId);
											// Displaying popup info for centroid layer
											showPopupInfoForCentroidLayer(geoNaDataObject, feature,
													queryEvent.getOnFailureCenterTo());

											// retrieving and showing WMS layers of a concessione if the ZOOM level is >
											// QUERY_MIN_ZOOM_LEVEL
											if (olMap.getCurrentZoomLevel() > OLMapManager.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) {
																GWT.log("Adding layers: " + result);
																for (LayerConcessioneDV layer : result) {
																	addLayer("concessione", layer.getLayerName(),
																			layer.getLayerName(), layer.getWmsLink(),
																			false, false, layer.getLayerUUID(), true,
																			OLMapManager.LAYER_DETAIL_MIN_RESOLUTION,
																			OLMapManager.LAYER_DETAIL_MAX_RESOLUTION);
																}

															}
														});
											} else {
												// removing all WMS detail layers if the ZOOM level is <
												// QUERY_MIN_ZOOM_LEVEL
												olMap.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);
				olMap.removeAllDetailLayers();
				applicationBus.fireEvent(zoomOutEvent);
			}
		});
	}

	/**
	 * 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
	 */
	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) {

//		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);

						String key = layerItem.getMapServerHost() + "/layer/" + layerItem.getName();

						// if a detail layer checking if it is already added to map
						if (asDetailLayer && layerObjects.containsKey(key)) {
							GWT.log("Skipping layer " + key + " already added to Map");
						} else {
							layerObjects.put(key, lo);
							if (!asDetailLayer)
								olMap.addWMSLayer(layerItem);
							else
								olMap.addWMSDetailLayer(layerItem);
						}
					}
				});
	}

	/**
	 * 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 geoNaDataObject   the geo na data object
	 * @param feature           the feature
	 * @param onFailureCenterTo the on failure center to
	 */
	public void showPopupInfoForLayer(List<GeoNaSpatialQueryResult> listGeoNaDataObject,
			Coordinate onFailureCenterTo) {
		
		ScrollPanel scrollPanel = new ScrollPanel();
		VerticalPanel vpPanel = new VerticalPanel();
		scrollPanel.add(vpPanel);
		
		for (GeoNaSpatialQueryResult geoNaSpatialQueryResult : listGeoNaDataObject) {
			
			GWT.log("baseLayerFromISProfile.getName() :"+baseLayerFromISProfile.getName());
			String layerSource = geoNaSpatialQueryResult.getSourceLayerObject().getLayerItem().getName();
			
			//skipping centroid layer
			if(layerSource==null || layerSource.compareToIgnoreCase(baseLayerFromISProfile.getName())==0) {
				continue;
			}
			
			Label layerLabel = new Label();
			layerLabel.setType(LabelType.INFO);
			
			layerLabel.setText(layerSource);
			layerLabel.getElement().getStyle().setMarginTop(10, Unit.PX);
			layerLabel.getElement().getStyle().setMarginBottom(5, Unit.PX);
			vpPanel.add(layerLabel);
			
			List<FeatureRow> features = geoNaSpatialQueryResult.getFeatures();

			if (features == null || features.isEmpty()) {
				FlexTable flex = new FlexTable();
				flex.setCellPadding(1);
				flex.setCellSpacing(1);
				flex.getElement().addClassName("table-feature");
				flex.setHTML(0, 0, new HTML("No data available").toString());
				vpPanel.add(flex);
				continue;
				//olMap.showPopup(vpPanel.toString(), onFailureCenterTo);
			}
			
			for (FeatureRow feature : 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());
				intFlex.setHTML(1, 0, new HTML(feature.getId()).toString());
	
				// Showing properties belonging to concessioni centroid layer
				Map<String, List<String>> entries = feature.getMapProperties();
	
				if (entries.size() == 0) {
					intFlex.setHTML(1, 1, new HTML("No property available").toString());
				}
				int j = 1;
				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);
					intFlex.setHTML(0, j, new HTML(key).toString());
					intFlex.setHTML(1, j, new HTML(valueToDisplay).toString());
					j++;
	
				}
				
				vpPanel.add(intFlex);
			}
		
		}

		olMap.showPopup(scrollPanel.toString(), onFailureCenterTo);

	}

	/**
	 * 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.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);
						}
					}
				});
			}
		});

	}

	/**
	 * Checks if is layer visible.
	 *
	 * @param layerItem the layer item
	 * @return true, if is layer visible
	 */
	public boolean isLayerVisible(LayerItem layerItem) {
		return olMap.isLayerVisible(layerItem.getName());
	}

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

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

	public void setBaseLayerFromIsProfile(org.gcube.application.geoportalcommon.shared.LayerItem layerItem) {
		this.baseLayerFromISProfile = layerItem;
	}

	public org.gcube.application.geoportalcommon.shared.LayerItem getBaseLayerFromISProile() {
		return baseLayerFromISProfile;
	}

}