geoportal-service/src/main/java/org/gcube/application/geoportal/service/engine/legacy/SDIManager.java

package org.gcube.application.geoportal.service.engine.legacy;

import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.List;

import org.gcube.application.geoportal.model.fault.SDIInteractionException;
import org.gcube.application.geoportal.service.model.legacy.concessioni.GeoServerContent;
import org.gcube.application.geoportal.service.model.legacy.concessioni.SDILayerDescriptor;
import org.gcube.application.geoportal.utils.Files;
import org.gcube.data.transfer.library.DataTransferClient;
import org.gcube.data.transfer.library.TransferResult;
import org.gcube.data.transfer.library.faults.DestinationNotSetException;
import org.gcube.data.transfer.library.faults.FailedTransferException;
import org.gcube.data.transfer.library.faults.InitializationException;
import org.gcube.data.transfer.library.faults.InvalidDestinationException;
import org.gcube.data.transfer.library.faults.InvalidSourceException;
import org.gcube.data.transfer.library.faults.SourceNotSetException;
import org.gcube.data.transfer.model.Destination;
import org.gcube.data.transfer.model.DestinationClashPolicy;
import org.gcube.spatial.data.gis.GISInterface;
import org.gcube.spatial.data.gis.is.AbstractGeoServerDescriptor;

import it.geosolutions.geoserver.rest.GeoServerRESTPublisher;
import it.geosolutions.geoserver.rest.GeoServerRESTPublisher.UploadMethod;
import it.geosolutions.geoserver.rest.encoder.GSLayerEncoder;
import it.geosolutions.geoserver.rest.encoder.datastore.GSPostGISDatastoreEncoder;
import it.geosolutions.geoserver.rest.encoder.feature.GSFeatureTypeEncoder;
import lombok.extern.slf4j.Slf4j;


@Slf4j
public class SDIManager {

	static private String DEFAULT_CRS="EPSG:4326";
	
	
	private GISInterface gis;
	private DataTransferClient dtGeoServer; 
	private String geoserverHostName;


	public SDIManager() throws SDIInteractionException {
		try{
			log.debug("Initializing GIS Interface..");
			gis=GISInterface.get();
			AbstractGeoServerDescriptor geoserver=gis.getCurrentGeoServer();						
			if(geoserver==null)	
				throw new Exception("Unable to contact data transfer for geoserver ");

			log.debug("Found geoserver descriptor "+geoserver);
			geoserverHostName=new URL(gis.getCurrentGeoServer().getUrl()).getHost();

			log.debug("Contacting Data Transfer from geoserver {} ",geoserverHostName);
			dtGeoServer=DataTransferClient.getInstanceByEndpoint("http://"+geoserverHostName);

		}catch(Exception e) {
			throw new SDIInteractionException("Unable to initialize SDI Manager",e);
		}
	}

	public String createWorkspace(String toCreate) throws SDIInteractionException {
		try {
			if(!gis.getCurrentGeoServer().getPublisher().createWorkspace(toCreate))
				log.warn("Unable to create workspace "+toCreate+". Assuming already exisintg..");
			return toCreate;
		} catch (IllegalArgumentException | MalformedURLException e) {
			throw new SDIInteractionException("Unable to create workspace "+toCreate,e);
		}
	}


	// GEOSERVER-PERSISTENCE-ID / GNA / PROJECT-ID /LAYER-ID/ FILENAME

	public GeoServerContent pushShapeLayerFileSet(SDILayerDescriptor currentElement,List<TempFile> files,String workspace) throws SDIInteractionException{
		try {
			String remoteFolder=null;
			String fileName=null;

			log.debug("Transferring "+files.size()+" files to geoserver @ "+geoserverHostName);

			GeoServerContent content=new GeoServerContent();
			content.setGeoserverHostName(geoserverHostName);
			content.setWorkspace(workspace);
			
			
			for(TempFile f:files) {
				Destination destination=new Destination(f.getOriginalFileName());
				destination.setCreateSubfolders(true);
				destination.setOnExistingFileName(DestinationClashPolicy.REWRITE);
				destination.setOnExistingSubFolder(DestinationClashPolicy.ADD_SUFFIX);
				destination.setPersistenceId("geoserver");
				destination.setSubFolder("GNA/"+currentElement.getRecord().getId()+"/"+currentElement.getLayerName());
				TransferResult result=dtGeoServer.localFile(f.getTheFile(), destination);
				content.getFileNames().add(f.getOriginalFileName());
				
				remoteFolder=result.getRemotePath().substring(0,result.getRemotePath().lastIndexOf("/"));
				fileName=f.getOriginalFileName();
				content.setGeoserverPath(remoteFolder);
			}
			
			
			
			String toSetLayerName=fileName.substring(0,fileName.lastIndexOf("."));

			content.setStore(toSetLayerName+"_store");
			content.setFeatureType(toSetLayerName);

			GeoServerRESTPublisher publisher=gis.getCurrentGeoServer().getPublisher();
			log.debug("Trying to create remote workspace : "+workspace);
			gis.getCurrentGeoServer().getPublisher().createWorkspace(workspace);						
			log.debug("Publishing remote folder "+remoteFolder);			

			URL directoryPath=new URL("file:"+remoteFolder);

			

			//TODO Evaluate SRS 

			boolean published=publisher.publishShp(
					workspace, 
					toSetLayerName+"_store", 
					null, 
					toSetLayerName, 
					//					UploadMethod.FILE, // neeeds zip
					UploadMethod.EXTERNAL, // needs shp
					directoryPath.toURI(), 
					DEFAULT_CRS, //SRS
					""); // default style

			if(!published) {
				throw new SDIInteractionException("Unable to publish layer "+toSetLayerName+" under "+workspace+". Unknown Geoserver fault.");
			}

			currentElement.setLayerName(toSetLayerName);
			

			// TODO Metadata
			return content;
		} catch (InvalidSourceException | SourceNotSetException | FailedTransferException | InitializationException
				| InvalidDestinationException | DestinationNotSetException e) {
			throw new SDIInteractionException("Unable to transfer fileSet for content "+currentElement,e);
		} catch (SDIInteractionException e) {
			throw e;
		} catch (Throwable t) {
			throw new SDIInteractionException("Unexpected internal fault while interacting with SDI.",t);
		}
	}

	private String createStoreFromPostgisDB(String workspace,String storeName) throws SDIInteractionException  {
		//SET BY PROVISIONING
		GSPostGISDatastoreEncoder encoder=new GSPostGISDatastoreEncoder(storeName);
		encoder.setJndiReferenceName("java:comp/env/jdbc/postgres");
		encoder.setLooseBBox(true);
		encoder.setDatabaseType("postgis");
		encoder.setEnabled(true);
		encoder.setFetchSize(1000);
		encoder.setValidateConnections(true);
		try {
			if(!gis.getCurrentGeoServer().getDataStoreManager().create(workspace, encoder))
				log.warn("Unable to create workspace "+storeName+". Assuming already exisintg..");
			return storeName;
		} catch (IllegalArgumentException | MalformedURLException e) {
			throw new SDIInteractionException("Unable to create store "+storeName,e);
		}
		
	}
	
	private String publishLayer(File sldFile,String name) throws SDIInteractionException {
		try {
			if(!gis.getCurrentGeoServer().getPublisher().publishStyle(sldFile, name))
				log.warn("Unable to create style "+name+". Assuming already exisintg..");
			return name;
		} catch (IllegalArgumentException | MalformedURLException e) {
			throw new SDIInteractionException("Unable to create style "+name,e);
		}
		
	}
	
	public String configureCentroidLayer(String name,String workspace,String storeName) throws SDIInteractionException {
		
		GSFeatureTypeEncoder fte=new GSFeatureTypeEncoder();
		fte.setAbstract("Centroid layer for "+name);
		fte.setEnabled(true);
		fte.setNativeCRS(DEFAULT_CRS);
		fte.setTitle(name);
		
		String style="clustered_centroids";
		
		GSLayerEncoder layerEncoder=new GSLayerEncoder();
		layerEncoder.setDefaultStyle(style);
		layerEncoder.setEnabled(true);
		layerEncoder.setQueryable(true);
		try {
			//Checking workspace 
			createWorkspace(workspace);
			//Checking store 
			createStoreFromPostgisDB(workspace, storeName);
			//Checkig layer
			publishLayer(Files.getFileFromResources("styles/clustered_points.sld"),style);
			
			if(!gis.getCurrentGeoServer().getPublisher().publishDBLayer(workspace, storeName, fte, layerEncoder))
				log.warn("Unable to create layer "+name+". Assuming already exisintg..");
			return name;
		} catch (IllegalArgumentException | MalformedURLException e) {
			throw new SDIInteractionException("Unable to create layer "+name,e);
		}
		
		
	}
}