geoportal-data-viewer-app/src/main/java/org/gcube/portlets/user/geoportaldataviewer/client/LayerManager.java

/*
 * 
 */
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.portlets.user.geoportaldataviewer.client.GeoportalDataViewerConstants.LayerType;
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.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.BoundsMap;
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.wfs.PointsPath;
import org.gcube.portlets.user.geoportaldataviewer.shared.gis.wms.GeoInformationForWMSRequest;
import org.gcube.portlets.user.geoportaldataviewer.shared.gis.wms.ZAxis;
import org.gcube.portlets.user.geoportaldataviewer.shared.products.content.WorkspaceContentDV;
import org.gcube.portlets.user.geoportaldataviewer.shared.products.model.UploadedImageDV;

import com.github.gwtbootstrap.client.ui.Button;
import com.github.gwtbootstrap.client.ui.constants.ButtonType;
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.shared.HandlerManager;
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.VerticalPanel;

import ol.Coordinate;


/**
 * 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 List<LayerObject> layerObjects = new ArrayList<LayerObject>();
	
	private HandlerManager layerManagerBus = new HandlerManager("");

	private HandlerManager applicationBus;

	/**
	 * 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) {
				
				if(queryEvent.getGeoQuery()!=null) {
					GeoQuery selectDataInfo = queryEvent.getGeoQuery();
					GWT.log("("+selectDataInfo.getX1()+","+selectDataInfo.getY1()+")("+selectDataInfo.getX2()+","+selectDataInfo.getY2()+")");
					
					for (LayerObject layerObj : layerObjects){
						//TODO
						isLayerVisible(layerObj.getLayerItem());
						
					}
					
					BoundsMap mapBBOX = new BoundsMap();
					//THIS IS SHOULD BE CORRET, THE BOUND AND CRS ARE READ FROM MAP
					/*mapBBOX.setCrs(olMap.getProjectionCode());
					mapBBOX.setLowerLeftX(olMap.getExtent().getLowerLeftX());
					mapBBOX.setLowerLeftY(olMap.getExtent().getLowerLeftY());
					mapBBOX.setUpperRightX(olMap.getExtent().getUpperRightX());
					mapBBOX.setUpperRightY(olMap.getExtent().getUpperRightY());
					*/
					
					//THE FOLLOWING SHOULD BE NOT NEEDED BUT THE GETFEATURE WITH EPSG_3857 SEEMS NOT WORK IN OUR GEOSERVER
//					double minX = olMap.getExtent().getLowerLeftX();
//					double minY = olMap.getExtent().getLowerLeftY();
					double minX = queryEvent.getGeoQuery().getX1();
					double minY = queryEvent.getGeoQuery().getY1();
					Coordinate centerCoordinate = new Coordinate(minX, minY);
					centerCoordinate = olMap.transform(centerCoordinate, GeoportalDataViewerConstants.EPSG_3857, GeoportalDataViewerConstants.EPSG_4326);
					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, GeoportalDataViewerConstants.EPSG_3857, GeoportalDataViewerConstants.EPSG_4326);
					mapBBOX.setUpperRightX(centerCoordinate.getX());
					mapBBOX.setUpperRightY(centerCoordinate.getY());
					
					mapBBOX.setCrs(GeoportalDataViewerConstants.EPSG_4326);
					
					GWT.log("Bounds is: "+mapBBOX);

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

						@Override
						public void onFailure(Throwable caught) {
						}

						@Override
						public void onSuccess(List<GeoNaSpatialQueryResult> listGeonaDataObjects) {
							
							GWT.log("GeoNaDataObject's: "+listGeonaDataObjects);
							
							if(listGeonaDataObjects==null || listGeonaDataObjects.isEmpty())
								return;

							FlexTable flex = new FlexTable();
							flex.setCellPadding(1);
							flex.setCellSpacing(1);
							flex.getElement().addClassName("popup-table");
							boolean featureFound = false;
							FeatureRow feature = null;
							
							//TODO SWTCH FOR EARCH ITEM TYPE
							for (GeoNaSpatialQueryResult geoNaDataObject : listGeonaDataObjects) {
								List<FeatureRow> features = geoNaDataObject.getFeatures();

								//USING ONLY THE FIRST FEATURE IN THE LIST
								if(features!=null && features.size()>0) {
									feature =  features.get(0);
									Map<String, List<String>> entries = feature.getMapProperties();
									
									for (String key : entries.keySet()) {
										String theValue = entries.get(key).get(0);
										if(key.equalsIgnoreCase("nome")) {
											flex.setHTML(0, 0, new HTML(theValue).toString());
										}
										else if(key.equalsIgnoreCase("descrizione")) {
											String reducedValue = theValue;
											try {
												reducedValue = StringUtil.ellipsize(theValue, 300);
												GWT.log("reduced: "+reducedValue);
											} catch (Exception e) {
												GWT.log("error: "+e.getMessage());
											}
											flex.setText(1, 0, reducedValue);
										}else if(key.equalsIgnoreCase("date_scavo")) {
											flex.setHTML(2, 0, new HTML("<code>"+theValue).toString()+"</code>");
										}
									}
									
									/*Scheduler.get().scheduleDeferred(new ScheduledCommand() {
										
										@Override
										public void execute() {
											List<String> listConcessioni = entries.get("product_id");
											if(listConcessioni!=null && listConcessioni.size()>0) {
												String concessioneId = listConcessioni.get(0);
												try {
													Long theConcessioneId = Long.parseLong(concessioneId);
													GeoportalDataViewerServiceAsync.Util.getInstance().getUploadedImagesForId("Concessione", theConcessioneId, 1, new AsyncCallback<List<UploadedImageDV>>() {

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

														@Override
														public void onSuccess(List<UploadedImageDV> result) {
															GWT.log("Loaded images: "+result);
															
															for (UploadedImageDV img : result) {
																if(img.getListWsContent()!=null) {
																	WorkspaceContentDV wsContent = img.getListWsContent().get(img.getListWsContent().size()-1);
																	String theImgHTML = "<img src=\""+wsContent.getLink()+"\"></img>";
																	GWT.log("theImgHTML: "+theImgHTML);
																	flex.setHTML(flex.getRowCount()+1, 0, theImgHTML);
																}
																
															}

														}
													});
												}catch (Exception e) {
													// TODO: handle exception
												}
											}

										}
									});*/
									
		
									if(geoNaDataObject.getMapImages()!=null) {
										for (Long key : geoNaDataObject.getMapImages().keySet()) {
											List<UploadedImageDV> listUI = geoNaDataObject.getMapImages().get(key);
											GWT.log("Adding images: "+listUI);
											if(listUI!=null) {
												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);
													flex.setHTML(flex.getRowCount()+1, 0, theImgHTML);
												}
											}
										}
									}
									
									featureFound = true;
									//break; //Only the first one
								}
								
								if(feature==null)
									return;
								
								GWT.log("The selected Feature is: "+feature);
								FeatureRow theFeature = feature;
								Button button = null;
								if(!featureFound) {
									flex.setHTML(0, 0, new HTML("No data available").toString());
								}else {
									button = new Button("Open Details");
									button.getElement().setId("open-details");
									button.setType(ButtonType.LINK);
								}
								
								VerticalPanel vpPanel = new VerticalPanel();
								vpPanel.add(flex);
								
								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);
											
										}
									});
								}
								
								PointsPath path = feature.getGeometry().getPath();
								GWT.log("Points Path: "+path);
								Coordinate centerTo = null;
								if(path!=null && path.getCoordinates()!=null && path.getCoordinates().length>0) {
									org.gcube.portlets.user.geoportaldataviewer.shared.gis.wfs.Coordinate center = path.getCoordinates()[0];
									centerTo = new Coordinate(center.getX(), center.getY());
								}
								
								if(centerTo==null)
									centerTo = queryEvent.getoLCoordinate();
									
								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);
										             }
										        }
										    });
									}
								});
							}
						}
					});
				}
			}
		});
		
		layerManagerBus.addHandler(AddedLayerToMapEvent.TYPE, new AddedLayerToMapEventHandler() {
			
			@Override
			public void onLayerRendered(AddedLayerToMapEvent addedLayerToMapEvent) {
				GWT.log("Fired into layerManagerBus");
				applicationBus.fireEvent(addedLayerToMapEvent);
			}
		});
		
		
		layerManagerBus.addHandler(ZoomOutOverMinimumEvent.TYPE, new ZoomOutOverMinimumEventHandler() {
			
			@Override
			public void onZoomOut(ZoomOutOverMinimumEvent zoomOutEvent) {
				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) {
			long id = Long.parseLong(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, id, 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 onTop the on top
	 */
	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 onTop) {

//		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);
		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());
				LayerObject lo = new LayerObject();
				lo.setLayerItem(layerItem);
				lo.setItemType(geonaItemType);
				layerObjects.add(lo);
				olMap.addWMSLayer(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
	 * @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) {

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

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

}