/*
    * 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.dynabean.helpers;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.ConcurrentMap;
  
  import org.apache.commons.beanutils.DynaProperty;
  import org.openrdf.model.URI;
  
  /**
   * Backing class for a SesameDynaBean to store common properties shared between
   * beans.
   * 
   * @author James Leigh
   * 
   */
  public class DynaClassInfo implements OntologyDigester {
  
  	private Collection<URI> rdfTypes;
  
  	private ConcurrentMap<String, URI> predicates = new ConcurrentHashMap<String, URI>();
  
  	private ConcurrentMap<String, Boolean> functional = new ConcurrentHashMap<String, Boolean>();
  
  	private ConcurrentMap<String, List<URI>> predicateRdfTypes = new ConcurrentHashMap<String, List<URI>>();
  
  	private ConcurrentMap<String, DynaProperty> properties = new ConcurrentHashMap<String, DynaProperty>();
  
  	public DynaClassInfo(Collection<URI> rdfTypes) {
  		this.rdfTypes = rdfTypes;
  	}
  
  	public String getName() {
  		return toString();
  	}
  
  	public Collection<URI> getRdfTypes() {
  		return rdfTypes;
  	}
  
  	public Collection<URI> getPredicates() {
  		return predicates.values();
  	}
  
  	public void addPredicate(URI pred) {
  		predicates.put(pred.getLocalName(), pred);
  	}
  
  	public void setFunctional(URI pred, boolean functional) {
  		if (functional)
  			this.functional.put(pred.getLocalName(), Boolean.TRUE);
  	}
  
  	public List<URI> getRdfTypes(URI pred) {
  		return predicateRdfTypes.get(pred.getLocalName());
  	}
  
  	public void setRdfTypes(URI pred, List<URI> rdfTypes) {
  		predicateRdfTypes.put(pred.getLocalName(), rdfTypes);
  	}
  
  	public void addRdfType(URI pred, URI rdfType) {
  		String key = pred.getLocalName();
  		List<URI> rdfTypes = new ArrayList<URI>();
  		List<URI> o = predicateRdfTypes.putIfAbsent(key, rdfTypes);
  		if (o != null) {
 			rdfTypes = o;
 		}
 		rdfTypes.add(rdfType);
 	}
 
 	public void setIndexed(URI pred) {
 		if (isFunctional(pred.getLocalName())) {
 			DynaProperty dp = new DynaProperty(pred.getLocalName(), List.class);
 			properties.put(pred.getLocalName(), dp);
 		}
 	}
 
 	public void setMapped(URI pred) {
 		if (isFunctional(pred.getLocalName())) {
 			DynaProperty dp = new DynaProperty(pred.getLocalName(), Map.class);
 			properties.put(pred.getLocalName(), dp);
 		}
 	}
 
 	public void end() {
 		for (String property : predicates.keySet()) {
 			if (!properties.containsKey(property)) {
 				DynaProperty dp;
 				if (isFunctional(property))
 					dp = new DynaProperty(property);
 				else
 					dp = new DynaProperty(property, Set.class);
 				properties.put(property, dp);
 			}
 		}
 	}
 
 	public DynaProperty getDynaProperty(String property) {
 		if (properties.containsKey(property))
 			return properties.get(property);
 		throw new IllegalArgumentException("Invalid property: " + property
 				+ ".  Valid properties are "
 				+ new ArrayList<String>(properties.keySet()).toString());
 	}
 
 	public DynaProperty[] getDynaProperties() {
 		return properties.values().toArray(new DynaProperty[properties.size()]);
 	}
 
 	public URI getPredicate(String property) {
 		if (predicates.containsKey(property))
 			return predicates.get(property);
 		throw new IllegalArgumentException("Invalid property: " + property
 				+ ".  Valid properties are "
 				+ new ArrayList<String>(properties.keySet()).toString());
 	}
 
 	public boolean isFunctional(String property) {
 		return functional.containsKey(property);
 	}
 
 	public Collection<URI> getRdfTypes(String property) {
 		return predicateRdfTypes.get(property);
 	}
 
 	@Override
 	public boolean equals(Object obj) {
 		if (this == obj)
 			return true;
 		if (!(obj instanceof DynaClassInfo))
 			return false;
 		DynaClassInfo o = (DynaClassInfo) obj;
 		return rdfTypes.equals(o.rdfTypes);
 	}
 
 	@Override
 	public int hashCode() {
 		return rdfTypes.hashCode();
 	}
 
 	@Override
 	public String toString() {
 		Iterator<URI> i = rdfTypes.iterator();
 		if (rdfTypes.size() == 1)
 			return i.next().toString();
 		StringBuilder buf = new StringBuilder();
 		boolean hasNext = i.hasNext();
 		while (hasNext) {
 			String o = i.next().toString();
 			buf.append(String.valueOf(o));
 			hasNext = i.hasNext();
 			if (hasNext)
 				buf.append(";");
 		}
 		return buf.toString();
 	}
 
 }