software-versions-processor-lib/src/main/java/org/gcube/common/software/analyser/SoftwareConfigAnalyser.java

package org.gcube.common.software.analyser;

import java.io.File;
import java.net.URL;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.gcube.com.fasterxml.jackson.databind.JsonNode;
import org.gcube.com.fasterxml.jackson.databind.ObjectMapper;
import org.gcube.com.fasterxml.jackson.databind.node.ArrayNode;
import org.gcube.com.fasterxml.jackson.databind.node.ObjectNode;
import org.gcube.com.fasterxml.jackson.databind.node.TextNode;
import org.gcube.common.software.model.SoftwareConfig;
import org.gcube.common.software.model.SoftwareVersionConfig;
import org.gcube.common.software.model.Variables;
import org.gcube.common.software.utils.Utils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author Luca Frosini (ISTI - CNR)
 */
public class SoftwareConfigAnalyser {
	
	private static final Logger logger = LoggerFactory.getLogger(SoftwareConfigAnalyser.class);

	public static final String EXPORT_FILENAME_EXTENSION = ".json";
	
	public static final String GLOBAL_PROPERTY_NAME = "global";
	public static final String VERSIONS_PROPERTY_NAME = "versions";
	
	protected ObjectMapper objectMapper;
	protected JsonNode jsonNode;
	
	public SoftwareConfigAnalyser(File jsonFile) throws Exception {
		this.objectMapper = Utils.getObjectMapper();
		this.jsonNode = objectMapper.readTree(jsonFile);
	}
	
	public SoftwareConfigAnalyser(String json) throws Exception {
		this.objectMapper = Utils.getObjectMapper();
		this.jsonNode = objectMapper.readTree(json);
	}
	
	protected SoftwareVersionConfig actualizeSoftwareVersionConfig(JsonNode version) throws Exception {
		Variables variables = objectMapper.treeToValue(version, Variables.class);
		Set<String> missingVariables = variables.parse();
		int size = missingVariables.size();
		if(size>0) {
			throw new Exception("The following variables has been used but not defined or cannot be actualised" + 
					missingVariables.toArray(new String[size]).toString());
		}
		JsonNode swVersion = objectMapper.convertValue(variables.getProperties(), JsonNode.class);
		SoftwareVersionConfig softwareVersion = objectMapper.treeToValue(swVersion, SoftwareVersionConfig.class);
		return softwareVersion;
	}
	
	protected SoftwareConfig actualizeSoftwareConfig(JsonNode node) throws Exception {
		Variables variables = objectMapper.treeToValue(node, Variables.class);
		variables.parse();
		JsonNode sc = objectMapper.convertValue(variables.getProperties(), JsonNode.class);
		SoftwareConfig softwareConfig = objectMapper.treeToValue(sc, SoftwareConfig.class);
		return softwareConfig;
	}
	
	public void analyse() throws Exception {
		ObjectNode originalGlobal = (ObjectNode) jsonNode.get(GLOBAL_PROPERTY_NAME).deepCopy();
		SoftwareConfig softwareConfig = actualizeSoftwareConfig(originalGlobal);
		softwareConfig.setOriginalJson(originalGlobal);
		
		ObjectNode global = originalGlobal.deepCopy();
		global.remove(SoftwareConfig.EXPORT_FILENAME_PROPERTY_NAME);
		
		ArrayNode versions = (ArrayNode) jsonNode.get(VERSIONS_PROPERTY_NAME);
		
		SoftwareVersionConfig previous = null;
		
		int i = 0; 
				
		ArrayNode exportingVersions = objectMapper.createArrayNode();  
		try {
			for(i=0; i<versions.size(); i++) {
				ObjectNode originalVersion = (ObjectNode) versions.get(i).deepCopy();
				exportingVersions.add(originalVersion);
				
				
				JsonNode version = Utils.merge(global, originalVersion);
				SoftwareVersionConfig softwareVersion = actualizeSoftwareVersionConfig(version);
				softwareVersion.setOriginalJson(originalVersion);
					
				boolean newDOI = false;
				if(softwareVersion.getDOIURL()==null) {
					newDOI = true;
				}
				
				softwareVersion.setPrevious(previous);
				if(previous!=null) {
					previous.setNext(softwareVersion);
				}
				
				logger.trace("Going to process {}", softwareVersion.getTitle());			
				
				try {
					SoftwareVersionConfigAnalyser softwareVersionAnalyser = new SoftwareVersionConfigAnalyser(softwareVersion);
					softwareVersionAnalyser.setSoftwareConfig(softwareConfig);
					softwareVersionAnalyser.setFirst(i==0);
					softwareVersionAnalyser.analyse();
					
					previous = softwareVersion;
				}finally {
					
					/* Need to export the original file with the DOI and Version DOI */
					URL doiURL = softwareVersion.getDOIURL();
					if(doiURL!=null) {
						originalVersion.put(SoftwareVersionConfig.DOI_URL_PROPERTY_NAME, doiURL.toString());
					}
					
					if(softwareVersion.getVersionDOIURL()!=null) {
						originalVersion.put(SoftwareVersionConfig.VERSION_DOI_URL_PROPERTY_NAME, softwareVersion.getVersionDOIURL().toString());
					}
					
					if(newDOI) {
						softwareConfig.addAdditionalProperty(SoftwareVersionConfig.DOI_URL_PROPERTY_NAME, new TextNode(doiURL.toString()));
						originalGlobal.put(SoftwareVersionConfig.DOI_URL_PROPERTY_NAME, doiURL.toString());
					}
				}
				Thread.sleep(TimeUnit.SECONDS.toMillis(2));
			}
		} catch (Exception e) {
			for(int j=i+1; j<versions.size(); j++) {
				ObjectNode originalVersion = (ObjectNode) versions.get(j).deepCopy();
				exportingVersions.add(originalVersion);
			}
			throw e;
		}finally {
			ObjectNode toBeExported = objectMapper.createObjectNode();
			toBeExported.replace(GLOBAL_PROPERTY_NAME, originalGlobal);
			
//			if(originalGlobal.has(SoftwareGlobalConfig.DOI_URL_PROPERTY_NAME) 
//					&& originalGlobal.get(SoftwareGlobalConfig.DOI_URL_PROPERTY_NAME).getNodeType()!=JsonNodeType.NULL) {
//				String conceptDOIURL = originalGlobal.get(SoftwareGlobalConfig.DOI_URL_PROPERTY_NAME).asText();
//				
//				for(i=0; i<exportingVersions.size(); i++) {
//					ObjectNode v = (ObjectNode) exportingVersions.get(i);
//					if(v.has(SoftwareVersionConfig.DOI_URL_PROPERTY_NAME) 
//							&& v.get(SoftwareVersionConfig.DOI_URL_PROPERTY_NAME).getNodeType()!=JsonNodeType.NULL){
//						String vDOI = v.get(SoftwareVersionConfig.DOI_URL_PROPERTY_NAME).asText();
//						if(conceptDOIURL.compareTo(vDOI)==0) {
//							v.remove(SoftwareVersionConfig.DOI_URL_PROPERTY_NAME);
//						}
//					}
//				}
//			}
			
			toBeExported.replace(VERSIONS_PROPERTY_NAME, exportingVersions);
			
			String fileName = softwareConfig.getExportFileName();
			
			File file = new File(fileName+EXPORT_FILENAME_EXTENSION);
			objectMapper.writeValue(file, toBeExported);
			
		}
		
	} 
	
}