information-system-model-documentation-generator/src/main/java/org/gcube/informationsystem/utils/documentation/generator/TreeGenerator.java

package org.gcube.informationsystem.utils.documentation.generator;

import java.io.File;
import java.nio.file.Files;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import org.gcube.informationsystem.base.reference.AccessType;
import org.gcube.informationsystem.model.reference.properties.Encrypted;
import org.gcube.informationsystem.model.reference.properties.Header;
import org.gcube.informationsystem.model.reference.properties.PropagationConstraint;
import org.gcube.informationsystem.model.reference.properties.Property;
import org.gcube.informationsystem.types.TypeMapper;
import org.gcube.informationsystem.types.reference.Type;
import org.gcube.informationsystem.utils.documentation.knowledge.Node;
import org.gcube.informationsystem.utils.documentation.knowledge.NodeElaborator;
import org.gcube.informationsystem.utils.documentation.knowledge.Tree;
import org.gcube.informationsystem.utils.documentation.model.DocumentationGenerator;
import org.gcube.informationsystem.utils.documentation.model.entities.ResourceDocumentationGenerator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author Luca Frosini (ISTI - CNR)
 */
public class TreeGenerator extends Generator {

	private static final Logger logger = LoggerFactory.getLogger(TreeGenerator.class);
	
	public static final String IS_MODEL_FILENAME = "is-model.rst";
	public static final String PROPERTIES_FILENAME = "properties.rst";
	public static final String ENTITIES_FILENAME = "entities.rst";
	public static final String RELATIONS_FILENAME = "relations.rst";
	
	protected static final List<Class<? extends Property>> isModelProperties;
	protected static final List<String> isModelPropertyNames;
	
	static {
		isModelProperties = new ArrayList<>();
		isModelProperties.add(Header.class);
		isModelProperties.add(Encrypted.class);
		isModelProperties.add(PropagationConstraint.class);
		
		isModelPropertyNames= new ArrayList<>();
		isModelPropertyNames.add(Header.NAME);
		isModelPropertyNames.add(Encrypted.NAME);
		isModelPropertyNames.add(PropagationConstraint.NAME);
		
	}
	
	protected Map<AccessType, Tree> types;
	
	public TreeGenerator() {
		types = new TreeMap<>();
	}
	
	public void addType(Type type) {
		AccessType accessType = type.getAccessType();
		if(types.get(accessType)==null) {
			Type head = TypeMapper.createTypeDefinition(accessType.getTypeClass());
			Tree tree = new Tree(head);
			types.put(accessType, tree);
		}
		if(type.getName().compareTo(accessType.getName())==0) {
			// Head has been already added
			return;
		}
		Tree tree = types.get(accessType);
		tree.addNode(type);
	}
	
	public void elaborateTree(final AccessType at, Tree tree, final File file) throws Exception {
		logger.info("Going to elaborate the following type tree\n{}", tree.toString());
		
		NodeElaborator documentationNE = new NodeElaborator() {
			
			protected void writeSectionOnly(Type type, int level) throws Exception {
				DocumentationGenerator dg = getDocumentationGenerator(type);
				dg.setLevel(level);
				StringBuffer sb = dg.generateSection(); 
				Files.write(file.toPath(), sb.toString().getBytes(), StandardOpenOption.APPEND);
			}
			
			@Override
			public void elaborate(Node node, int level) throws Exception {
				Type type = node.getType();
				if(level==0) {
					/*
					 * Root node has been already documented in IS_MODEL_FILENAME
					 * Going to skip it
					 */
					writeSectionOnly(type, level);
				}else if(isModelPropertyNames.contains(type.getName())){
					// Can be Header, Encrypted or PropagationConstraint
					if(node.getChildrenNodes()!=null && node.getChildrenNodes().size()>0) {
						// If they have specialization I just add the section
						// to maintain the level, otherwise I skip it
						writeSectionOnly(type, level);
					}
				} else {
					writeTypeToFile(type, file, level);
				}
				
			}
		};
		
		tree.elaborate(documentationNE);
	}
	
	
	public void createUsageKnowledge(Tree tree) throws Exception {
		
		NodeElaborator usageKnowledgeNE = new NodeElaborator() {
			
			@Override
			public void elaborate(Node node, int level) throws Exception {
				Type type = node.getType();
				ResourceDocumentationGenerator dg = new ResourceDocumentationGenerator(type);
				dg.createUsageKnowledge();
			}
		};
		
		tree.elaborate(usageKnowledgeNE);
	}
	
	public void generate() throws Exception {
		
		File is = getFile(IS_MODEL_FILENAME, true);
		File file = null;
		
		for(AccessType at : accessTypes) {
			Type type = TypeMapper.createTypeDefinition(at.getTypeClass());
			writeTypeToFile(type, is);
			
			switch (at) {
				case PROPERTY:
					file = getFile(PROPERTIES_FILENAME, true);
					for(Class<? extends Property> clz : isModelProperties) {
						Type t = TypeMapper.createTypeDefinition(clz);
						writeTypeToFile(t, is, 1);
					}
					break;
				
				case ENTITY:
					file = getFile(ENTITIES_FILENAME, true);
					continue;
				
				case RELATION:
					file = getFile(RELATIONS_FILENAME, true);
					continue;
				
				default:
					break;
			}
			
			Tree tree = types.get(at);
			elaborateTree(at, tree, file);
		}
		
	}
	
}