information-system-model/src/main/java/org/gcube/informationsystem/knowledge/ModelKnowledge.java

package org.gcube.informationsystem.knowledge;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import org.gcube.informationsystem.base.reference.AccessType;
import org.gcube.informationsystem.tree.NodeInformation;
import org.gcube.informationsystem.tree.Tree;
import org.gcube.informationsystem.types.reference.entities.FacetType;
import org.gcube.informationsystem.types.reference.entities.ResourceType;
import org.gcube.informationsystem.types.reference.properties.LinkedEntity;
import org.gcube.informationsystem.types.reference.properties.PropertyDefinition;
import org.gcube.informationsystem.types.reference.relations.ConsistsOfType;
import org.gcube.informationsystem.types.reference.relations.IsRelatedToType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author Luca Frosini (ISTI - CNR)
 */
public class ModelKnowledge<T, NI extends NodeInformation<T>> {
	
	private static final Logger logger = LoggerFactory.getLogger(ModelKnowledge.class);
	
	protected NI nodeInformation;
	protected Map<AccessType, Tree<T>> trees;
	protected Map<AccessType, UsageKnowledge<?>> usageKnowledges;

	public ModelKnowledge() {
		reset();
	}
	
	private void reset() {
		
		this.trees = new HashMap<>();
		this.usageKnowledges = new HashMap<>();
		
		AccessType[] modelTypes = AccessType.getModelTypes();
		for(AccessType accessType : modelTypes) {
			T t = nodeInformation.getRoot(accessType);
			
			Tree<T> tree = new Tree<>(t, nodeInformation);
			trees.put(accessType, tree);
			
			UsageKnowledge<?> usageKnowledge;
			if(accessType == AccessType.PROPERTY) {
				/*
				 * In this case we get the type which uses such a property
				 * and the property definition.
				 * In this way we have a complete overview of the usege of the
				 * property type
				 */
				usageKnowledge = new UsageKnowledge<Map<T,PropertyDefinition>>(accessType);
			}else {
				usageKnowledge = new UsageKnowledge<LinkedEntity>(accessType);
			}
			usageKnowledges.put(accessType, usageKnowledge);
		}
				
	}
	
	protected void add(LinkedEntity linkedEntity, UsageKnowledge<LinkedEntity> relationUsage, UsageKnowledge<LinkedEntity> targetEntityUsage) {
		if (linkedEntity != null) {
			@SuppressWarnings("unchecked")
			UsageKnowledge<LinkedEntity> resourceUsage = (UsageKnowledge<LinkedEntity>) usageKnowledges.get(AccessType.RESOURCE);
			String source = linkedEntity.getSource();
			resourceUsage.add(source, linkedEntity);
			String relation = linkedEntity.getRelation();
			relationUsage.add(relation, linkedEntity);
			String target = linkedEntity.getTarget();
			targetEntityUsage.add(target, linkedEntity);
		}
	}

	protected void addAll(Collection<LinkedEntity> linkedEntities, UsageKnowledge<LinkedEntity> relationUsage, UsageKnowledge<LinkedEntity> targetEntityUsage) {
		if(linkedEntities!=null) {
			for(LinkedEntity le : linkedEntities) {
				add(le, relationUsage, targetEntityUsage);
			}
		}
	}

	protected void addPropertyUsage(Set<PropertyDefinition> properties, UsageKnowledge<PropertyDefinition> propertyUsage) {
		// for()
	}
	
	public void addType(T t) {
		AccessType accessType = nodeInformation.getAccessType(t);
		
		@SuppressWarnings("unchecked")
		UsageKnowledge<PropertyDefinition> propertyUsage = (UsageKnowledge<PropertyDefinition>) usageKnowledges.get(AccessType.PROPERTY);
		
		@SuppressWarnings("unchecked")
		UsageKnowledge<LinkedEntity> resourceUsage = (UsageKnowledge<LinkedEntity>) usageKnowledges.get(AccessType.RESOURCE);
		@SuppressWarnings("unchecked")
		UsageKnowledge<LinkedEntity> facetUsage = (UsageKnowledge<LinkedEntity>) usageKnowledges.get(AccessType.FACET);
		@SuppressWarnings("unchecked")
		UsageKnowledge<LinkedEntity> isRelatedToUsage = (UsageKnowledge<LinkedEntity>) usageKnowledges.get(AccessType.IS_RELATED_TO);
		@SuppressWarnings("unchecked")
		UsageKnowledge<LinkedEntity> consistsOfUsage = (UsageKnowledge<LinkedEntity>) usageKnowledges.get(AccessType.CONSISTS_OF);
		
		switch (accessType) {
			case PROPERTY:
				// Nothing to do
				break;
	
			case RESOURCE:
				ResourceType resourceType = (ResourceType) t;
				addAll(resourceType.getFacets(), consistsOfUsage, facetUsage);
				addAll(resourceType.getResources(), isRelatedToUsage, resourceUsage);
				break;
			
			case FACET:
				FacetType facetType = (FacetType) t;
				addPropertyUsage(facetType.getProperties(), propertyUsage);
				break;
			
			case IS_RELATED_TO:
				IsRelatedToType isRelatedToType = (IsRelatedToType) t;
				
				break;
			
			case CONSISTS_OF:
				ConsistsOfType consistsOfType = (ConsistsOfType) t;
				
				break;
			
			default:
				break;
		}
		
		if(accessType == AccessType.RESOURCE) {
			
			
		}
	}
	
	public Tree<T> getTree(AccessType accessType) {
		return trees.get(accessType);
	}
	
	public UsageKnowledge<?> getUsageKnowledge(AccessType accessType) {
		return usageKnowledges.get(accessType);
	}
}