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

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

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.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 EXTENSION = ".rst";
	
	protected RegistrationProvider rp;
	protected boolean splittedFiles;

	public TreeGenerator(RegistrationProvider rp) {
		super();
		this.rp = rp;
		this.splittedFiles = false;
	}
	
	public void setSplittedFiles(boolean splittedFiles) {
		if(rp instanceof ISModelRegistrationProvider && splittedFiles) {
			throw new RuntimeException(rp.getModelName() + " documentation can be only produced in a single file");
		}
		this.splittedFiles = splittedFiles;
	}
	
	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);
	}
	
	protected String getFileName(AccessType accessType) {
		String modelName = rp.getModelName();
		StringBuffer stringBuffer = new StringBuffer();
		stringBuffer.append(modelName.toLowerCase().replaceAll(" ", "_"));
		if(accessType!=null && splittedFiles) {
			stringBuffer.append("_");
			stringBuffer.append(accessType.getName().toLowerCase());
		}
		stringBuffer.append(EXTENSION);
		return stringBuffer.toString();
	}
	
	public void generate() throws Exception {
		
		modelKnowledge.addRegistrationProvider(rp);
		modelKnowledge.createKnowledge();
		
		File file = null;
		
		if(!splittedFiles) {
			file = getFile(getFileName(null), true);
		}
		
		for(AccessType at : AccessType.getModelTypes()) {
			if(splittedFiles) {
				file = getFile(getFileName(at), true);
			}
			
			switch (at) {
				case PROPERTY:
					break;
				
				case RESOURCE:
					if(rp instanceof ISModelRegistrationProvider) {
						Type type = TypeMapper.createTypeDefinition(AccessType.ENTITY.getTypeClass());
						writeTypeToFile(type, file);
					}
					break;
				
				case IS_RELATED_TO:
					if(rp instanceof ISModelRegistrationProvider) {
						Type type = TypeMapper.createTypeDefinition(AccessType.RELATION.getTypeClass());
						writeTypeToFile(type, file);
					}
					break;
				
				default:
					break;
			}
			
			Tree<Class<Element>> tree = modelKnowledge.getClassesTree(at);
			elaborateTree(at, tree, file, rp);
						
		}
		
	}
	
}