package org.gcube.informationsystem.utils.documentation;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.ServiceLoader;

import org.gcube.informationsystem.base.reference.AccessType;
import org.gcube.informationsystem.base.reference.Element;
import org.gcube.informationsystem.types.TypeMapper;
import org.gcube.informationsystem.types.reference.Type;
import org.gcube.informationsystem.utils.discovery.ElementSpecilizationDiscovery;
import org.gcube.informationsystem.utils.discovery.RegistrationProvider;
import org.gcube.informationsystem.utils.documentation.model.DocumentationGenerator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author Luca Frosini (ISTI - CNR)
 */
public class DocGenerator {

	private static final Logger logger = LoggerFactory.getLogger(DocGenerator.class);
	
	protected File baseDirectory;

	public DocGenerator(File baseDirectory) {
		this.baseDirectory = baseDirectory;
	}
	
	protected List<Package> getPackages(){
		
		List<Package> packages = new ArrayList<Package>();
			
		AccessType[] accessTypes = new AccessType[] {
			AccessType.PROPERTY, 
			AccessType.ENTITY,
			AccessType.RELATION
		};
		
		for(AccessType accessType : accessTypes) {
			Class<Element> clz = accessType.getTypeClass();
			packages.add(clz.getPackage());
		}
			
		ServiceLoader<? extends RegistrationProvider> regsitrationProviders = ServiceLoader
				.load(RegistrationProvider.class);
		for(RegistrationProvider registrationProvider : regsitrationProviders) {
			packages.addAll(registrationProvider.getPackagesToRegister());
		}
			
		return packages;
	}
	
	public void generate() throws Exception {
		List<Package> pkgs = getPackages();
		generate(pkgs.toArray(new Package[pkgs.size()]));
	}
	
	protected File getFile(ModelTypes cm) throws IOException {
		String fileName = cm.getFilename();
		File file = new File(fileName);
		
		if(cm.requiresNewFile()) {
		
			if(file.exists()) {
				file.delete();
			}

		}
		
		if(!file.exists()) {
			logger.info("Goign to create {}", file.getAbsolutePath());
			file.createNewFile();
		}
		
		return file;
	}
	
	protected <E extends Element> void  generateAllOfType(ModelTypes cm, Package[] packages) throws Exception {
		ElementSpecilizationDiscovery<E> discovery = new ElementSpecilizationDiscovery<>(cm.getAccessType().getTypeClass());
		if(Objects.nonNull(packages)) {
			Arrays.stream(packages).forEach(p -> discovery.addPackage(p));
		}
		discovery.discover();
		
		File f = getFile(cm);
		
		for(Class<? extends E> clz : discovery.getDiscovered()) {
			Type type = TypeMapper.createTypeDefinition(clz);
			DocumentationGenerator dgInstance = cm.getDocumentationGeneratorInstance(type);
			StringBuffer sb = dgInstance.generateSection();
			Files.write(f.toPath(), sb.toString().getBytes(), StandardOpenOption.APPEND);
		}
	}
	
	protected void generateSingle(ModelTypes cm) throws Exception {
		File f = getFile(cm);
		Class<? extends Element> clz = cm.getAccessType().getTypeClass();
		Type type = TypeMapper.createTypeDefinition(clz);
		DocumentationGenerator dgInstance = cm.getDocumentationGeneratorInstance(type);
		StringBuffer sb = dgInstance.generateSection();
		Files.write(f.toPath(), sb.toString().getBytes(), StandardOpenOption.APPEND);
	}
	
	protected void generate(Package[] packages) throws Exception {
		for(ModelTypes cm : ModelTypes.values()) {
			if(cm.discover()) {
				generateAllOfType(cm, packages);
			}else {
				generateSingle(cm);
			}
		}
		
	}
}