/**
 * 
 */
package org.gcube.informationsystem.model.impl.entities;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import org.gcube.com.fasterxml.jackson.annotation.JsonTypeName;
import org.gcube.informationsystem.model.impl.relations.ConsistsOfImpl;
import org.gcube.informationsystem.model.reference.entities.Facet;
import org.gcube.informationsystem.model.reference.entities.Resource;
import org.gcube.informationsystem.model.reference.relations.ConsistsOf;
import org.gcube.informationsystem.model.reference.relations.IsRelatedTo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author Luca Frosini (ISTI - CNR)
 */
@JsonTypeName(value=Resource.NAME)
public abstract class ResourceImpl extends EntityImpl implements Resource {

	/**
	 * Generated Serial Version UID
	 */
	private static final long serialVersionUID = -3117918737458706846L;

	
	private static Logger logger = LoggerFactory.getLogger(ResourceImpl.class);
	
	protected List<ConsistsOf<? extends Resource, ? extends Facet>> consistsOfList;
	protected List<IsRelatedTo<? extends Resource, ? extends Resource>> isRelatedToList;
	
	/*
	private List<Facet> facets;
	@SuppressWarnings("rawtypes")
	private Map<Class<Relation>, List<Relation>> relationByClass;
	@SuppressWarnings("rawtypes")
	private Map<Entry<Class<Relation>, Class<Entity>>, List<Relation>> relationByClassAndTarget;
	private Map<Class<Entity>, List<Entity>> entityByClass;
	@SuppressWarnings("rawtypes")
	private Map<Entry<Class<Relation>, Class<Entity>>, List<Entity>> entityByClassAndTarget;
	*/
	
	protected ResourceImpl() {
		super();
		consistsOfList = new ArrayList<>();
		isRelatedToList = new ArrayList<>();
		
		/*
		facets = new ArrayList<>();
		
		relationByClass = new HashMap<>();
		relationByClassAndTarget = new HashMap<>();
		
		entityByClass = new HashMap<>();
		entityByClassAndTarget = new HashMap<>();
		*/
	}
	
	/*
	@SuppressWarnings({ "rawtypes"})
	private void addRelationByClassAndTarget(Entry<Class<Relation>, Class<Entity>> entry, Relation relation){
		List<Relation> relations = relationByClassAndTarget.get(entry);
		if(relations==null){
			relations = new ArrayList<>();
			relationByClassAndTarget.put(entry, relations);
		}
		relations.add(relation);
		
		addRelationByClass(entry.getKey(), relation);
	}
	
	@SuppressWarnings({ "rawtypes"})
	private void addRelationByClass(Class<Relation> relationClass, Relation r){
		List<Relation> relations = (List<Relation>) relationByClass.get(relationClass);
		if(relations==null){
			relations = new ArrayList<>();
			relationByClass.put(relationClass, relations);
		}
		relations.add(r);
	}
	
	@SuppressWarnings({ "rawtypes"})
	private void addEntityByClassAndTarget(Entry<Class<Relation>, Class<Entity>> entry, Entity entity){
		List<Entity> entities = entityByClassAndTarget.get(entry);
		if(entities==null){
			entities = new ArrayList<>();
			entityByClassAndTarget.put(entry, entities);
		}
		entities.add(entity);
		
		addEntityByClass(entry.getValue(), entity);
	}
	
	private void addEntityByClass(Class<Entity> entityClass, Entity entity){
		List<Entity> entities = entityByClass.get(entityClass);
		if(entities==null){
			entities = new ArrayList<>();
			entityByClass.put(entityClass, entities);
		}
		entities.add(entity);
	}
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	private Entry<Class<Relation>, Class<Entity>> getEntry(Class<Relation> realtionClass, Class<Entity> entityClass){
		Map<Class<Relation>, Class<Entity>> mapForEntry = new HashMap<>();
		mapForEntry.put(realtionClass, entityClass);
		return (Entry<Class<Relation>, Class<Entity>>) mapForEntry.entrySet().toArray()[0];
	}
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	private void addRelation(Relation relation){
		Entity entity = (Entity) relation.getTarget();
		Entry<Class<Relation>, Class<Entity>> entry = getEntry((Class<Relation>) relation.getClass(), (Class<Entity>) entity.getClass());
		addRelationByClassAndTarget(entry, relation);
		addEntityByClassAndTarget(entry, entity);
	}
	*/
	
	@Override
	public void addFacet(UUID uuid) {
		Facet facet = new DummyFacet(uuid);
		addFacet(facet);
	}
	
	@Override
	public <F extends Facet > void addFacet(F facet) {
		ConsistsOf<Resource, Facet> consistsOf = new ConsistsOfImpl<Resource, Facet>(this, facet, null); 
		addFacet(consistsOf);
	}

	@Override
	public <C extends ConsistsOf<? extends Resource, ? extends Facet>> void addFacet(C relation) {
		if (relation.getSource() != this) {
			String message = String.format(
					"%s Source %s is not this. %s != %s", ConsistsOf.NAME,
					Resource.NAME, relation.getSource().toString(),
					this.toString());
			logger.error(message);
			throw new RuntimeException(message);
		}
		consistsOfList.add(relation);
		/*
		addRelation(relation);
		facets.add(relation.getTarget());
		*/
	}

	/*
	@Override
	public void attachResource(UUID uuid) {
		Resource resource = new DummyResource(uuid);
		attachResource(resource);
	}
	
	@Override
	public <R extends Resource> void attachResource(R resource) {
		IsRelatedTo<Resource, Resource> isRelatedTo = new IsRelatedToImpl<Resource, Resource>(this, resource, null);
		attachResource(isRelatedTo);
	}
	*/
	
	@Override
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public void attachResource(IsRelatedTo relation) {
		String message = String.format(
				"%s Source %s is not this. %s != %s", IsRelatedTo.NAME,
				Resource.NAME, relation.getSource(),
				this.toString());
		
		
		
		if (relation.getSource()==null){
			throw new RuntimeException(message);
		}
		
		if (relation.getSource().getMetadata()!= null &&
			relation.getSource().getID() != null &&
			this.metadata !=null &&
			this.uuid != null &&
			relation.getSource().getID().compareTo(this.uuid)!=0) {
			throw new RuntimeException(message);
		}
		
		if(relation.getSource()!=this){
			relation.setSource(this);
		}
		
		isRelatedToList.add(relation);
		/*
		addRelation(relation);
		*/
	}
	
	@Override
	public List<ConsistsOf<? extends Resource, ? extends Facet>> getConsistsOf() {
		return consistsOfList;
	}
	
	@Override
	public <C extends ConsistsOf<? extends Resource, ? extends Facet>> List<C> getConsistsOf(Class<C> clz) {
		List<C> list = new ArrayList<>();
		for(ConsistsOf<? extends Resource, ? extends Facet> consistsOf : consistsOfList){
			if(clz.isInstance(consistsOf)){
				@SuppressWarnings("unchecked")
				C c = (C) consistsOf;
				list.add(c);
			}
		}
		return list;
	}
	
	@Override
	public List<IsRelatedTo<? extends Resource, ? extends Resource>> getIsRelatedTo() {
		return isRelatedToList;
	}
	
	@Override
	public <I extends IsRelatedTo<? extends Resource, ? extends Resource>> List<I> getIsRelatedTo(Class<I> clz) {
		List<I> list = new ArrayList<>();
		for(IsRelatedTo<? extends Resource, ? extends Resource> isRelatedTo : isRelatedToList){
			if(clz.isInstance(isRelatedTo)){
				@SuppressWarnings("unchecked")
				I i = (I) isRelatedTo;
				list.add(i);
			}
		}
		return list;
	}
	
	@Override
	public List<? extends Facet> getFacets() {
		List<Facet> list = new ArrayList<>();
		for(ConsistsOf<? extends Resource, ? extends Facet> consistsOf : consistsOfList){
			list.add(consistsOf.getTarget());
		}
		return list;
	}
	
	@Override
	public <F extends Facet> List<F> getFacets(Class<F> clz) {
		List<F> list = new ArrayList<>();
		for(ConsistsOf<? extends Resource, ? extends Facet> consistsOf : consistsOfList){
			if(clz.isInstance(consistsOf.getTarget())){
				@SuppressWarnings("unchecked")
				F f = (F) consistsOf.getTarget();
				list.add(f);
			}
		}
		return list;
	}
	
	@Override
	public <F extends Facet, C extends ConsistsOf<? extends Resource, F>> List<C> getConsistsOf(Class<C> clz, Class<F> facetClz) {
		List<C> list = new ArrayList<>();
		for(ConsistsOf<? extends Resource, ? extends Facet> consistsOf : consistsOfList){
			if(clz.isInstance(consistsOf)){
				if(facetClz.isInstance(consistsOf.getTarget())){
					@SuppressWarnings("unchecked")
					C c = (C) consistsOf;
					list.add(c);
				}
			}
		}
		return list;
		
	}
	
	@Override
	public <F extends Facet, C extends ConsistsOf<? extends Resource, F>> List<F> getFacets(Class<C> clz, Class<F> facetClz) {
		List<F> list = new ArrayList<>();
		for(ConsistsOf<? extends Resource, ? extends Facet> consistsOf : consistsOfList){
			if(clz.isInstance(consistsOf)){
				if(facetClz.isInstance(consistsOf.getTarget())){
					@SuppressWarnings("unchecked")
					F f = (F) consistsOf.getTarget();
					list.add(f);
				}
			}
		}
		return list;
	}
	
}