package org.gcube.portlets.user.geoportaldataviewer.client.gis;

import org.gcube.portlets.user.geoportaldataviewer.client.GeoportalDataViewerConstants;
import org.gcube.portlets.user.geoportaldataviewer.client.events.AddedLayerToMapEvent;
import org.gcube.portlets.user.geoportaldataviewer.shared.gis.LayerItem;

import com.google.gwt.core.client.GWT;
import com.google.gwt.dom.client.Style.Visibility;
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 ol.Collection;
import ol.Coordinate;
import ol.Map;
import ol.MapBrowserEvent;
import ol.MapEvent;
import ol.MapOptions;
import ol.OLFactory;
import ol.Overlay;
import ol.OverlayOptions;
import ol.Size;
import ol.View;
import ol.ViewOptions;
import ol.control.Attribution;
import ol.event.EventListener;
import ol.interaction.Draw;
import ol.interaction.DrawOptions;
import ol.interaction.Extent;
import ol.interaction.ExtentOptions;
import ol.interaction.Interaction;
import ol.interaction.KeyboardPan;
import ol.interaction.KeyboardZoom;
import ol.layer.Base;
import ol.layer.Image;
import ol.layer.LayerOptions;
import ol.layer.Tile;
import ol.proj.Projection;
import ol.proj.ProjectionOptions;
import ol.source.ImageWms;
import ol.source.ImageWmsOptions;
import ol.source.ImageWmsParams;
import ol.source.Osm;
import ol.source.Vector;
import ol.source.XyzOptions;


// TODO: Auto-generated Javadoc
/**
 * The Class OpenLayerOSM.
 *
 * @author Francesco Mangiacrapa at ISTI-CNR (francesco.mangiacrapa@isti.cnr.it)
 * 
 * Oct 27, 2020
 */
public abstract class OpenLayerOSM {
	
	public abstract void clickListener(MapBrowserEvent event);
	
	public abstract void moveEndListener(MapEvent event);
	
	public abstract void moveStartListener(MapEvent event);
	
	public abstract void mapZoomListener(MapEvent event);
	
	public abstract void mapZoomEndListener(MapEvent event);

	/** The map. */
	private Map map;
	
	/** The view. */
	private View view;
	
	/** The view options. */
	private ViewOptions viewOptions = OLFactory.createOptions();
	
	/** The projection options. */
	private ProjectionOptions projectionOptions = OLFactory.createOptions();
	
	/** The point draw. */
	private Draw queryPoint;
	
	private Extent queryBox;
	
	/** The popup overlay. */
	private Overlay popupOverlay;

	private HandlerManager eventBus;
	
	private boolean isQueryBoxActive;
	
	private boolean isQueryPointActive;
	

    /**
     * Instantiates a new open layer OSM.
     *
     * @param divTargetId the div target id
     * @param eventBus the event bus
     */
    /* (non-Javadoc)
     * @see de.desjardins.ol3.demo.client.example.Example#show()
     */
	public OpenLayerOSM(String divTargetId, HandlerManager eventBus) {
		this.eventBus = eventBus;

        // create a OSM-layer
        XyzOptions osmSourceOptions = OLFactory.createOptions();

        Osm osmSource = new Osm(osmSourceOptions);
        LayerOptions osmLayerOptions = OLFactory.createOptions();
        osmLayerOptions.setSource(osmSource);

        Tile osmLayer = new Tile(osmLayerOptions);
		// create a projection
		projectionOptions.setCode(GeoportalDataViewerConstants.EPSG_3857);
		projectionOptions.setUnits("m");

		Projection projection = new Projection(projectionOptions);
		viewOptions.setProjection(projection);
		viewOptions.setMaxZoom(19);
		//viewOptions.setExtent(new Extent(-180, -90, 180, 90));

        // create a view
        view = new View(viewOptions);
        
        // create the map
        MapOptions mapOptions = OLFactory.createOptions();
        mapOptions.setTarget(divTargetId);
        mapOptions.setView(view);

        map = new Map(mapOptions);

        map.addLayer(osmLayer);
        //map.addLayer(tileDebugLayer);

        // add some controls
        map.addControl(OLFactory.createScaleLine());
        MapUtils.addDefaultControls(map.getControls());

        Attribution attribution = new Attribution();
        attribution.setCollapsed(true);
        map.addControl(attribution);
        
        // add some interactions
        map.addInteraction(new KeyboardPan());
        map.addInteraction(new KeyboardZoom());
        
        bindEvents();

    }
	
	private void bindEvents() {
		
		map.addClickListener(new EventListener<MapBrowserEvent>() {

			@Override
			public void onEvent(MapBrowserEvent event) {
				clickListener(event);
			}
		});

		map.addMoveEndListener(new EventListener<MapEvent>() {

			@Override
			public void onEvent(MapEvent event) {
				moveEndListener(event);
			}
		});
		
		map.addMoveStartListener(new EventListener<MapEvent>() {

			@Override
			public void onEvent(MapEvent event) {
				moveStartListener(event);
			}
		});
		
		map.addMapZoomListener(new EventListener<MapEvent>() {

			@Override
			public void onEvent(MapEvent event) {
				mapZoomListener(event);
			}
		});
		
		map.addMapZoomEndListener(new EventListener<MapEvent>() {

			@Override
			public void onEvent(MapEvent event) {
				mapZoomEndListener(event);
			}
		});
	}
	
	/**
	 * Sets the center.
	 *
	 * @param centerCoordinate the new center
	 */
	public void setCenter(Coordinate centerCoordinate) {
        view.setCenter(centerCoordinate);
	}
	
	/**
	 * Sets the center.
	 *
	 * @param centerCoordinate the new center
	 */
	public void setZoom(int zoom) {
        view.setZoom(zoom);
	}

	
	public void showPopup(String html, Coordinate coordinate) {
		GWT.log("Showing popup on: "+coordinate);
		Element elPopup = DOM.getElementById("popup");
		elPopup.getStyle().setVisibility(Visibility.VISIBLE);
		if(popupOverlay==null) {
			popupOverlay = addOverlay(elPopup);
			addPopupCloserHandelr(popupOverlay);
		}
		Element popContent = DOM.getElementById("popup-content");
		popContent.setInnerHTML(html);
		popupOverlay.setPosition(coordinate);
	}
	
	public void hidePopup() {
		if(popupOverlay!=null) {
			Element elPopup = DOM.getElementById("popup");
			elPopup.getStyle().setVisibility(Visibility.HIDDEN);
		}
	}
	
	/**
	 * Adds the popup closer handelr.
	 *
	 * @param popupOverlay the popup overlay
	 */
	private void addPopupCloserHandelr(Overlay popupOverlay) {
		Element elPopupCloser = DOM.getElementById("popup-closer");
		Event.sinkEvents(elPopupCloser, Event.ONCLICK);
		Event.setEventListener(elPopupCloser, new com.google.gwt.user.client.EventListener() {

			@Override
			public void onBrowserEvent(Event event) {
				if (Event.ONCLICK == event.getTypeInt()) {
					popupOverlay.setPosition(null);
				}

			}
		});
	}
	
	/**
	 * Handler popu closer.
	 *
	 * @param divId the div id
	 * @param overlayId the overlay id
	 */
	public static native void handlerPopuCloser(String divId, String overlayId) /*-{
		var closer = $doc.getElementById(divId);
		var overlay = $doc.getElementById(overlayId);
		closer.onclick = function() {
			overlay.setPosition(undefined);
			closer.blur();
			return false;
		};

	}-*/;

	
	/**
	 * Adds the WMS layer.
	 *
	 * @param layerItem the layer item
	 */
	public void addWMSLayer(LayerItem layerItem) {
		
		ImageWmsParams imageWMSParams = OLFactory.createOptions();
		imageWMSParams.setLayers(layerItem.getName());

		ImageWmsOptions imageWMSOptions = OLFactory.createOptions();
		imageWMSOptions.setUrl(layerItem.getMapServerHost());
		imageWMSOptions.setParams(imageWMSParams);
		//imageWMSOptions.setRatio(1.5f);

		ImageWms imageWMSSource = new ImageWms(imageWMSOptions);

		LayerOptions layerOptions = OLFactory.createOptions();
		layerOptions.setSource(imageWMSSource);

		Image wmsLayer = new Image(layerOptions);
		
		//visibleLayerItems 
		
		map.addLayer(wmsLayer);
		GWT.log("Fired the event Added Layer");
		eventBus.fireEvent(new AddedLayerToMapEvent(layerItem));
		
	}
	
//	/**
//	 * Adds the WMS layer.
//	 *
//	 * @param mapServerHost the map server host
//	 * @param layerName the layer name
//	 */
//	public void addWMSLayer(String mapServerHost, String layerName) {
//		
//		ImageWmsParams imageWMSParams = OLFactory.createOptions();
//		imageWMSParams.setLayers(layerName);
//
//		ImageWmsOptions imageWMSOptions = OLFactory.createOptions();
//		imageWMSOptions.setUrl(mapServerHost);
//		imageWMSOptions.setParams(imageWMSParams);
//		//imageWMSOptions.setRatio(1.5f);
//
//		ImageWms imageWMSSource = new ImageWms(imageWMSOptions);
//
//		LayerOptions layerOptions = OLFactory.createOptions();
//		layerOptions.setSource(imageWMSSource);
//
//		Image wmsLayer = new Image(layerOptions);
//		
//		//visibleLayerItems 
//		
//		map.addLayer(wmsLayer);
//	}
	
	
	/**
	 * Adds the point vector source.
	 *
	 * @return the draw
	 */
	public Draw addPointVectorSource() {
		if(queryPoint==null)
			initPointInteraction();
		
		map.addInteraction(queryPoint);
		isQueryPointActive = true;
		return queryPoint;
	}
	
	/**
	 * Inits the point interaction.
	 */
	private void initPointInteraction() {
		Vector vectorSource = new Vector();
		DrawOptions drawOptions = new DrawOptions();
		drawOptions.setSource(vectorSource);
		drawOptions.setType("Point");
		drawOptions.setMaxPoints(1);
		drawOptions.setMinPoints(1);
		drawOptions.setWrapX(false);
		queryPoint = new Draw(drawOptions);
		
		queryPoint.addChangeListener(new EventListener<ol.events.Event>() {

			@Override
			public void onEvent(ol.events.Event event) {
				GWT.log(event.getType());
				
			}
		});
	}
	
	/**
	 * Removes the interaction.
	 *
	 * @param interaction the interaction
	 */
	public void removeInteraction(Interaction interaction) {
		map.removeInteraction(interaction);	
	}
	
	/**
	 * Removes the interactions.
	 */
	public void removeQueryInteractions() {
		Collection<Interaction> interactions = map.getInteractions();
		if(interactions!=null) {
			map.removeInteraction(queryBox);
			map.removeInteraction(queryPoint);
			isQueryBoxActive = false;
			isQueryPointActive = false;
		}
	}
	
	/**
	 * Adds the extent interaction.
	 *
	 * @return the extent
	 */
	public Extent addExtentInteraction() {
		ExtentOptions extentOptions = new ExtentOptions();
		extentOptions.setWrapX(false);
		//StyleOptions styleOptions = new StyleOptions();
		//styleOptions.setStroke(stroke);
		//styleOptions.set
		//extentOptions.setBoxStyle(new ol.style.Style(styleOptions));
		queryBox = new Extent(extentOptions);
		map.addInteraction(queryBox);
		isQueryBoxActive = true;
		return queryBox;
	}
	
	
	/**
	 * Adds the overlay.
	 *
	 * @param element the element
	 * @return the overlay
	 */
	private Overlay addOverlay(Element element) {
		/**
		 * Create an overlay to anchor the popup to the map.
		 */
		OverlayOptions overlayOptions = new OverlayOptions();
		overlayOptions.setAutoPan(true);
		Overlay overlay = new Overlay(overlayOptions);
		overlay.setElement(element);
		map.addOverlay(overlay);
		return overlay;
	}

	/**
	 * Checks if is layer visible.
	 *
	 * @param layerName the layer name
	 * @return true, if is layer visible
	 */
	public boolean isLayerVisible(String layerName) {
		
		Collection<Base> layers = map.getLayers();
		
		if(layers!=null) {
			Base[] layersArr = layers.getArray();
			for (int i = 0; i < layersArr.length; i++) {
				Base layer = layersArr[i];
				String theLayerName = (String) layer.get("name");
				GWT.log("The Layer name is: "+layerName);
				if(theLayerName!=null && theLayerName.equals(layerName))
					return true;
			}
		}
		
		return false;
	}
	

	/**
	 * Gets the projection code.
	 *
	 * @return the projection code
	 */
	public String getProjectionCode() {
		return map.getView().getProjection().getCode();
	}
	

	/**
	 * Gets the current zoom level.
	 *
	 * @return the current zoom level
	 */
	public double getCurrentZoomLevel() {
		return map.getView().getZoom();
	}
	
	
	
	/**
	 * Gets the bbox.
	 *
	 * @return the bbox
	 */
	public ol.Extent getBBOX() {
		return getExtent();
	}
	
	/**
	 * Gets the extent.
	 *
	 * @return the extent
	 */
	public ol.Extent getExtent() {
		return this.map.getView().calculateExtent(map.getSize());
	}
	
	public Coordinate transform (Coordinate centerCoordinate, String source, String target){
		 return Projection.transform(centerCoordinate, source, target);
	}
	
	public boolean isQueryBoxActive() {
		return isQueryBoxActive;
	}
	
	public boolean isQueryPointActive() {
		return isQueryPointActive;
	}
	
	public Size getSize() {
		return map.getSize();
	}

	public boolean mapInstancied() {
		return this.map!=null;
	}	

}