/*
    * Copyright (c) 2007, James Leigh All rights reserved.
    * 
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    * 
    * - Redistributions of source code must retain the above copyright notice, this
    *   list of conditions and the following disclaimer.
    * - Redistributions in binary form must reproduce the above copyright notice,
   *   this list of conditions and the following disclaimer in the documentation
   *   and/or other materials provided with the distribution. 
   * - Neither the name of the openrdf.org nor the names of its contributors may
   *   be used to endorse or promote products derived from this software without
   *   specific prior written permission.
   * 
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   * 
   */
  package org.openrdf.elmo.rolemapper;
  
  import java.lang.reflect.AnnotatedElement;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.CopyOnWriteArrayList;
  
  import org.openrdf.elmo.RdfTypeFactory;
  import org.openrdf.elmo.annotations.complementOf;
  import org.openrdf.elmo.annotations.intersectionOf;
  import org.openrdf.elmo.annotations.oneOf;
  
  /**
   * Tracks recorded roles and maps them to their subject type.
   * 
   * @author James Leigh
   * 
   */
  public class ComplexMapper<URI> {
  	private HierarchicalRoleMapper<URI> roleMapper;
  
  	private RdfTypeFactory<URI> vf;
  
  	private Map<Class<?>, AnnotatedElement> complements;
  
  	private Map<Class<?>, AnnotatedElement> intersections;
  
  	private Map<URI, List<Class<?>>> instances;
  
  	public ComplexMapper(HierarchicalRoleMapper<URI> roleMapper) {
  		this.roleMapper = roleMapper;
  		complements = new ConcurrentHashMap<Class<?>, AnnotatedElement>();
  		intersections = new ConcurrentHashMap<Class<?>, AnnotatedElement>();
  		instances = new ConcurrentHashMap<URI, List<Class<?>>>(256);
  	}
  
  	public void setRdfTypeFactory(RdfTypeFactory<URI> vf) {
  		this.vf = vf;
  		roleMapper.setRdfTypeFactory(vf);
  	}
  
  	public Collection<URI> findSubTypes(Class<?> role, Collection<URI> rdfTypes) {
  		return roleMapper.findSubTypes(role, rdfTypes);
  	}
  
  	public URI findType(Class<?> role) {
  		return roleMapper.findType(role);
  	}
  
  	public Collection<URI> findTypes(Class<?> javaClass, Collection<URI> rdfTypes) {
  		return roleMapper.findTypes(javaClass, rdfTypes);
  	}
  
  	public boolean isTypeRecorded(URI type) {
  		return roleMapper.isTypeRecorded(type);
  	}
  
  	public boolean isIndividualRolesPresent(URI instance) {
  		return !instances.isEmpty() && instances.containsKey(instance);
  	}
  
  	public Collection<Class<?>> findIndividualRoles(URI instance,
  			Collection<Class<?>> classes) {
  		List<Class<?>> list = instances.get(instance);
  		if (list != null) {
  			classes.addAll(list);
  		}
 		return classes;
 	}
 
 	public Class<?>[] findBaseRoles() {
 		return findRoles(null);
 	}
 
 	public Class<?>[] findRoles(URI type) {
 		Class<?>[] classes;
 		if (type == null) {
 			classes = roleMapper.findBaseRoles();
 		} else {
 			classes = roleMapper.findRoles(type);
 		}
 		if (complements.isEmpty())
 			return classes;
 		int size = classes.length + complements.size() + intersections.size();
 		List<Class<?>> result = new ArrayList<Class<?>>(size);
 		result.addAll(Arrays.asList(classes));
 		addIntersectionsAndComplements(result);
 		if (result.size() == classes.length)
 			return classes;
 		return result.toArray(new Class<?>[result.size()]);
 	}
 
 	public Collection<Class<?>> findRoles(Collection<URI> types,
 			Collection<Class<?>> classes) {
 		Collection<Class<?>> roles = roleMapper.findRoles(types, classes);
 		addIntersectionsAndComplements(roles);
 		return roles;
 	}
 
 	public void recordRole(Class<?> role, URI rdfType) {
 		roleMapper.recordRole(role, rdfType);
 	}
 
 	public void recordBaseRole(Class<?> role) {
 		roleMapper.recordBaseRole(role);
 	}
 
 	public synchronized void recordRole(Class<?> role, AnnotatedElement elm) {
 		if (elm.isAnnotationPresent(complementOf.class)) {
 			complements.put(role, elm);
 		}
 		if (elm.isAnnotationPresent(intersectionOf.class)) {
 			intersections.put(role, elm);
 		}
 		if (elm.isAnnotationPresent(oneOf.class)) {
 			oneOf ann = elm.getAnnotation(oneOf.class);
 			for (String instance : ann.value()) {
 				URI uri = vf.createRdfType(instance);
 				List<Class<?>> list = instances.get(uri);
 				if (list == null) {
 					list = new CopyOnWriteArrayList<Class<?>>();
 					instances.put(uri, list);
 				}
 				list.add(role);
 			}
 		}
 	}
 
 	private void addIntersectionsAndComplements(Collection<Class<?>> roles) {
 		for (Map.Entry<Class<?>, AnnotatedElement> e : intersections.entrySet()) {
 			Class<?> inter = e.getKey();
 			AnnotatedElement elm = e.getValue();
 			Class<?>[] of = elm.getAnnotation(intersectionOf.class).value();
 			if (!roles.contains(inter) && intersects(roles, of))
 				roles.add(inter);
 		}
 		boolean complementAdded = false;
 		for (Map.Entry<Class<?>, AnnotatedElement> e : complements.entrySet()) {
 			Class<?> comp = e.getKey();
 			AnnotatedElement elm = e.getValue();
 			Class<?> of = elm.getAnnotation(complementOf.class).value();
 			if (!roles.contains(comp) && !contains(roles, of)) {
 				complementAdded = true;
 				roles.add(comp);
 			}
 		}
 		if (complementAdded) {
 			for (Map.Entry e : intersections.entrySet()) {
 				Class<?> inter = (Class<?>) e.getKey();
 				AnnotatedElement elm = (AnnotatedElement) e.getValue();
 				Class<?>[] of = elm.getAnnotation(intersectionOf.class).value();
 				if (!roles.contains(inter) && intersects(roles, of))
 					roles.add(inter);
 			}
 		}
 	}
 
 	private boolean intersects(Collection<Class<?>> roles, Class<?>[] ofs) {
 		for (Class<?> of : ofs) {
 			if (!contains(roles, of))
 				return false;
 		}
 		return true;
 	}
 
 	private boolean contains(Collection<Class<?>> roles, Class<?> of) {
 		for (Class<?> type : roles) {
 			if (of.isAssignableFrom(type))
 				return true;
 		}
 		return false;
 	}
 }