package org.gcube.informationsystem.tobereplaced;

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.base.reference.entities.EntityElement;
import org.gcube.informationsystem.base.reference.properties.PropertyElement;
import org.gcube.informationsystem.base.reference.relations.RelationElement;
import org.gcube.informationsystem.discovery.DiscoveredElementAction;
import org.gcube.informationsystem.discovery.Discovery;
import org.gcube.informationsystem.discovery.RegistrationProvider;
import org.gcube.informationsystem.types.reference.Type;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DiscoveryUtility {

	public static Logger logger = LoggerFactory.getLogger(DiscoveryUtility.class);
	
	public static List<Package> discoverPackages(){
		List<Package> packages = new ArrayList<Package>();
		
		Class<Type> tdClz = Type.class;
		packages.add(tdClz.getPackage());
		
		AccessType[] accessTypes = AccessType.values();
		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 static void discover(DiscoveredElementAction schemaAction) throws Exception {
		List<Package> packages = DiscoveryUtility.discoverPackages();
		DiscoveryUtility.manageISM(schemaAction , packages);
	}

	public static void manageISM(DiscoveredElementAction dea, Package... packages) throws Exception {
		Discovery<PropertyElement> propertyDiscovery = new Discovery<>(PropertyElement.class);
		if(Objects.nonNull(packages)) {
			Arrays.stream(packages).forEach(p -> propertyDiscovery.addPackage(p));
		}
		propertyDiscovery.discover();
		for(Class<? extends PropertyElement> property : propertyDiscovery.getDiscoveredElement()) {
			logger.trace("Going to manage : {}", property);
			dea.analizeElement(property);
		}
		
		Discovery<EntityElement> entityDiscovery = new Discovery<>(EntityElement.class);
		if(Objects.nonNull(packages)) {
			Arrays.stream(packages).forEach(p -> entityDiscovery.addPackage(p));
		}
		entityDiscovery.discover();
		
		for(Class<? extends EntityElement> entity : entityDiscovery.getDiscoveredElement()) {
			logger.trace("Going to manage : {}", entity);
			dea.analizeElement(entity);
		}
		
		@SuppressWarnings("rawtypes")
		Discovery<RelationElement> relationDiscovery = new Discovery<RelationElement>(RelationElement.class);
		if(Objects.nonNull(packages))
			Arrays.stream(packages).forEach(p -> relationDiscovery.addPackage(p));
		relationDiscovery.discover();
		
		for(@SuppressWarnings("rawtypes")
		Class<? extends RelationElement> relation : relationDiscovery.getDiscoveredElement()) {
			logger.trace("Going to manage : {}", relation);
			dea.analizeElement(relation);
		}
	}

	public static void manageISM(DiscoveredElementAction schemaAction, List<Package> packages) throws Exception {
		if(Objects.nonNull(packages) && packages.size() > 0) {
			manageISM(schemaAction, packages.stream().toArray(Package[]::new));
		} else {
			manageISM(schemaAction);
		}
	}
	
}