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

import java.io.IOException;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

import org.bson.Document;
import org.bson.types.ObjectId;
import org.gcube.application.geoportal.common.model.legacy.AssociatedContent;
import org.gcube.application.geoportal.common.model.legacy.Concessione;
import org.gcube.application.geoportal.common.model.legacy.LayerConcessione;
import org.gcube.application.geoportal.common.model.legacy.OtherContent;
import org.gcube.application.geoportal.common.model.legacy.PersistedContent;
import org.gcube.application.geoportal.common.model.legacy.RelazioneScavo;
import org.gcube.application.geoportal.common.model.legacy.SDILayerDescriptor;
import org.gcube.application.geoportal.common.model.legacy.UploadedImage;
import org.gcube.application.geoportal.common.model.legacy.WorkspaceContent;
import org.gcube.application.geoportal.common.model.legacy.report.PublicationReport;
import org.gcube.application.geoportal.common.rest.TempFile;
import org.gcube.application.geoportal.model.fault.ConfigurationException;
import org.gcube.application.geoportal.service.engine.ImplementationProvider;
import org.gcube.application.geoportal.service.engine.StorageClientProvider;
import org.gcube.application.geoportal.service.engine.WorkspaceManager;
import org.gcube.application.geoportal.service.engine.WorkspaceManager.FileOptions;
import org.gcube.application.geoportal.service.engine.WorkspaceManager.FolderOptions;
import org.gcube.application.geoportal.service.utils.Serialization;
import org.gcube.common.storagehub.client.dsl.FolderContainer;
import org.gcube.common.storagehub.model.exceptions.StorageHubException;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.mongodb.client.MongoDatabase;

import lombok.Synchronized;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ConcessioniMongoManager extends MongoManager{

	
	
	public ConcessioniMongoManager() throws ConfigurationException {
		super();
		// TODO Auto-generated constructor stub
	}
	private static final String collectionName="legacyConcessioni";
	private static final String DB_NAME="gna_dev";
	
	
	private MongoDatabase db=null;
	
	@Override
	@Synchronized
	protected MongoDatabase getDatabase() {
		if(db==null) {
			db=client.getDatabase(DB_NAME);
		}
		return db;
	}
	
	protected static Document asDocument (Concessione c) throws JsonProcessingException {
		Document toReturn=Document.parse(Serialization.write(c));
		if(c.getMongo_id()!=null&&!c.getMongo_id().isEmpty())
			toReturn.append(ID, new ObjectId(c.getMongo_id()));
		return toReturn;
	}
	
	protected static Concessione asConcessione (Document d) throws JsonProcessingException, IOException {
		return Serialization.read(d.toJson(), Concessione.class);
	}
	
	public Concessione registerNew(Concessione toRegister) throws IOException {
		ObjectId id=insert(asDocument(toRegister), collectionName);
		
		Concessione toReturn=asConcessione(getById(id,collectionName));
		toReturn.setMongo_id(id.toHexString());
		
		return asConcessione(replace(asDocument(toReturn),collectionName));
	}
	
	public Concessione update(Concessione toRegister) throws IOException {
		return asConcessione(replace(asDocument(toRegister),collectionName));
	}
	
	public List<Concessione> list(){
		ArrayList<Concessione> toReturn=new ArrayList<>();
		iterate(null, collectionName).forEach((Document d)->{
			try {
				toReturn.add(asConcessione(d));
			}catch(Throwable t) {
				log.error("Unable to read Document as concessione ",t);
				log.debug("Document was "+d.toJson());				
			}
		});	
		return toReturn;
	}
	
	public Concessione getById(String id) throws JsonProcessingException, IOException {
		log.debug("Loading by ID "+id);
		return asConcessione(getById(new ObjectId(id),collectionName));
	}
	public void deleteById(String id) {
		delete(new ObjectId(id), collectionName);
	}
	
	public Concessione publish(String id) throws JsonProcessingException, IOException{
		Concessione toReturn=asConcessione(getById(new ObjectId(id),collectionName));
		toReturn.setDefaults();
		toReturn.validate();
		publish(toReturn);
		return asConcessione(replace(asDocument(toReturn),collectionName));
	}
	
	
	public Concessione persistContent(String id, String destinationPath, List<TempFile> files) throws Exception {
		Concessione c = getById(id);
		WorkspaceManager ws=new WorkspaceManager();
		c.setDefaults();
		
		//Check Init Base folder
		FolderContainer baseFolder=null;
		if(c.getFolderId()==null) {					
			String folderName="mConcessione"+"_"+c.getNome()+"_"+Serialization.FULL_FORMATTER.format(LocalDateTime.now());
			log.info("Creating folder {} for Concessione ID {} ",folderName,id);
			FolderContainer folder=ws.createFolder(new FolderOptions(folderName, "Base Folder for "+c.getNome(),null));
			c.setFolderId(folder.getId());
		}
		
		baseFolder=ws.getFolderById(c.getFolderId());
		
		AssociatedContent section=c.getContentByPath(destinationPath);
		
		store(section,files,ws,baseFolder);
		return asConcessione(replace(asDocument(c),collectionName));
	}
	
	private static PublicationReport publish(Concessione c) {
		//TODO implement
		return null;
	}
	
	private static final void store(AssociatedContent content,List<TempFile> files, WorkspaceManager ws, FolderContainer base) throws Exception {
		FolderContainer sectionParent=null;		
		
		if(content instanceof RelazioneScavo)
			sectionParent = ws .createFolder(new FolderOptions(
					"relazione","Relazione di scavo : "+content.getTitolo(),base));
			
		else if (content instanceof UploadedImage) 
			sectionParent = ws .createFolder(new FolderOptions(
					"imgs","Immagini rappresentative : "+content.getTitolo(),base));
			
		else if (content instanceof SDILayerDescriptor)
			//SDI Section
			if(content instanceof LayerConcessione) 
				sectionParent = ws .createFolder(new FolderOptions(
						content.getTitolo(),"Layer Concessione : "+content.getTitolo(),ws.getSubFolder(base,"layers")));
			else throw new Exception("Invalid SDI Content "+content);
		else if (content instanceof OtherContent ) 
			sectionParent = ws .createFolder(new FolderOptions(
					content.getTitolo(),"Relazione di scavo : "+content.getTitolo(),ws.getSubFolder(base,"other")));
		else throw new Exception("Invalid Content "+content);
		
		content.setActualContent(new ArrayList<PersistedContent>());
		StorageClientProvider storage=ImplementationProvider.get().getStorageProvider();
		for(TempFile f : files) {
			WorkspaceContent wsContent=ws.storeToWS(new FileOptions(f.getFilename(), storage.open(f.getId()), "Imported via GeoPortal", sectionParent));
			log.debug("Registered "+wsContent+" for "+content);
			content.getActualContent().add(wsContent);
		}
	}
	
}