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

import java.io.File;
import java.util.Collection;
import java.util.ServiceLoader;

import org.gcube.informationsystem.base.reference.AccessType;
import org.gcube.informationsystem.base.reference.Element;
import org.gcube.informationsystem.discovery.ISModelRegistrationProvider;
import org.gcube.informationsystem.discovery.RegistrationProvider;
import org.gcube.informationsystem.discovery.knowledge.ModelKnowledge;
import org.gcube.informationsystem.tree.Node;
import org.gcube.informationsystem.tree.NodeElaborator;
import org.gcube.informationsystem.tree.Tree;
import org.gcube.informationsystem.types.TypeMapper;
import org.gcube.informationsystem.types.reference.Type;
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";
	
	public TreeGenerator() {
	}
	
	public void elaborateTree(final AccessType at, Tree<Class<Element>> tree, File file, RegistrationProvider rp) throws Exception {
		logger.info("Going to elaborate the following type tree\n{}", tree.toString());
		
		Collection<Package> packages = rp.getPackagesToRegister();
		
		NodeElaborator<Class<Element>> documentationNE = new NodeElaborator<Class<Element>>() {
			
			@Override
			public void elaborate(Node<Class<Element>> node, int level) throws Exception {
				Class<Element> clz = node.getNodeElement(); 
				if(level!=0 && !packages.contains(clz.getPackage())) {
					logger.debug("Discarding {} because it does not belong to {}", clz.getSimpleName(), rp.getModelName());
					return;
				}
				Type type = TypeMapper.createTypeDefinition(clz);
				if(level==0) {
					/*
					 * Root node has been already documented in IS_MODEL_FILENAME
					 * Going to skip it
					 */
					writeSectionOnly(type, file, level);
				} else {
					writeTypeToFile(type, file, level);
				}
				
			}

		};
		
		tree.elaborate(documentationNE);
	}
	
	public void generate() throws Exception {
		
		ModelKnowledge modelKnowledge = ModelKnowledge.getInstance();
		modelKnowledge.createKnowledge();
		
		File is = getFile(IS_MODEL_FILENAME, true);
		File file = null;
		
		for(AccessType at : AccessType.getModelTypes()) {
			
			
			switch (at) {
				case PROPERTY:
					file = getFile(PROPERTIES_FILENAME, true);
					break;
				
				case RESOURCE:
					file = getFile(ENTITIES_FILENAME, true);
					Type type = TypeMapper.createTypeDefinition(AccessType.ENTITY.getTypeClass());
					writeTypeToFile(type, is);
					break;
				
				case IS_RELATED_TO:
					file = getFile(RELATIONS_FILENAME, true);
					type = TypeMapper.createTypeDefinition(AccessType.RELATION.getTypeClass());
					writeTypeToFile(type, is);
					break;
				
				default:
					break;
			}
			
			Type type = TypeMapper.createTypeDefinition(at.getTypeClass());
			writeTypeToFile(type, is);
			
			Tree<Class<Element>> tree = modelKnowledge.getClassesTree(at);
			
			ServiceLoader<? extends RegistrationProvider> registrationProviders = ServiceLoader
					.load(RegistrationProvider.class);
			for(RegistrationProvider rp : registrationProviders) {
				if(!(rp instanceof ISModelRegistrationProvider)) {
					elaborateTree(at, tree, file, rp);
				}
			}
						
		}
		
	}
	
}