/*
    * 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;
  
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import javax.xml.namespace.QName;
  
  /**
   * Defines the Scope of an ElmoManager and its factory. This includes roles,
   * literals, factories, datasets, and contexts.
   * 
   * @author James Leigh
   * 
   */
  public class ElmoModule {
  	public static class Association {
  		private Class<?> javaClass;
  
  		private String rdfType;
  
  		public Association(Class<?> javaClass, String rdfType) {
  			this.javaClass = javaClass;
  			this.rdfType = rdfType;
  		}
  
  		public Class<?> getJavaClass() {
  			return javaClass;
  		}
  
  		public String getRdfType() {
  			return rdfType;
  		}
  	}
  
  	private ClassLoader cl;
  
  	private List<Association> literals = new ArrayList<Association>();
  
  	private List<Association> roles = new ArrayList<Association>();
  
  	private List<Association> factories = new ArrayList<Association>();
  
  	private QName context;
  
  	private List<QName> includedContexts = new ArrayList<QName>();
  
  	private Map<URL, String> datasets = new HashMap<URL, String>();
  
  	private List<String> resources = new ArrayList<String>();
  
  	public ElmoModule() {
  		super();
  		cl = Thread.currentThread().getContextClassLoader();
  		if (cl == null) {
  			cl = getClass().getClassLoader();
  		}
  	}
  
  	public ElmoModule(ClassLoader cl) {
  		super();
  		this.cl = cl;
  	}
  
  	public ClassLoader getClassLoader() {
  		return cl;
 	}
 
 	public QName getContext() {
 		return context;
 	}
 
 	/**
 	 * Sets the primary context of this module. This limits the readable scope
 	 * to this and other included contexts and causes any add operations to be
 	 * saved in this context.
 	 * 
 	 * @param context
 	 * @return this
 	 */
 	public ElmoModule setContext(QName context) {
 		this.context = context;
 		return this;
 	}
 
 	/**
 	 * Include all the information from the given module in this module. 
 	 * @param module to be included
 	 * @return this
 	 */
 	public ElmoModule includeModule(ElmoModule module) {
 		literals.addAll(module.literals);
 		roles.addAll(module.roles);
 		factories.addAll(module.factories);
 		includedContexts.add(module.context);
 		includedContexts.addAll(module.includedContexts);
 		datasets.putAll(module.datasets);
 		resources.addAll(module.resources);
 		return this;
 	}
 
 	public List<QName> getContexts() {
 		return Collections.unmodifiableList(includedContexts);
 	}
 
 	public List<Association> getLiterals() {
 		return Collections.unmodifiableList(literals);
 	}
 
 	/**
 	 * Associates this literal type with the given datatype within this factory.
 	 * 
 	 * @param type
 	 *            serializable class
 	 * @param datatype
 	 *            URI
 	 */
 	public ElmoModule addLiteral(Class<?> type, String datatype) {
 		literals.add(new Association(type, datatype));
 		return this;
 	}
 
 	public List<Association> getRoles() {
 		return Collections.unmodifiableList(roles);
 	}
 
 	/**
 	 * Associates this role with its default subject type.
 	 * 
 	 * @param role
 	 *            concept or behaviour
 	 */
 	public ElmoModule addRole(Class<?> role) {
 		roles.add(new Association(role, null));
 		return this;
 	}
 
 	/**
 	 * Associates this role with the given subject type.
 	 * 
 	 * @param role
 	 *            concept or behaviour
 	 * @param type
 	 *            URI
 	 */
 	public ElmoModule addRole(Class<?> role, String type) {
 		roles.add(new Association(role, type));
 		return this;
 	}
 
 	public List<Association> getFactories() {
 		return Collections.unmodifiableList(factories);
 	}
 
 	/**
 	 * Associates this factory with its default subject type.
 	 * 
 	 * @param role
 	 *            concept or behaviour
 	 */
 	public ElmoModule addFactory(Class<?> role) {
 		factories.add(new Association(role, null));
 		return this;
 	}
 
 	/**
 	 * Associates this factory with the given subject type.
 	 * 
 	 * @param role
 	 *            concept or behaviour
 	 * @param type
 	 *            URI
 	 */
 	public ElmoModule addFactory(Class<?> role, String type) {
 		factories.add(new Association(role, type));
 		return this;
 	}
 
 	public Map<URL, String> getDatasets() {
 		return datasets;
 	}
 
 	/**
 	 * Marks this dataset to be loaded into the repository under a context of the same URL.
 	 * @param dataset
 	 * @return this
 	 */
 	public ElmoModule addDataset(URL dataset) {
 		return addDataset(dataset, dataset.toExternalForm());
 	}
 
 	/**
 	 * Marks this dataset to be loaded and replace any data in the given context.
 	 * @param dataset
 	 * @param context
 	 * @return this
 	 */
 	public ElmoModule addDataset(URL dataset, String context) {
 		datasets.put(dataset, context);
 		return this;
 	}
 
 	public List<String> getResources() {
 		return resources;
 	}
 
 	/**
 	 * Load a dataset or a resource listing dataset - optionally assigned to a context
 	 * @param path
 	 * @return
 	 */
 	public ElmoModule addResources(String path) {
 		resources.add(path);
 		return this;
 	}
 
 	@Override
 	public int hashCode() {
 		final int PRIME = 31;
 		int result = 1;
 		result = PRIME * result + factories.hashCode();
 		result = PRIME * result + literals.hashCode();
 		result = PRIME * result + roles.hashCode();
 		result = PRIME * result + includedContexts.hashCode();
 		result = PRIME * result + datasets.hashCode();
 		result = PRIME * result + resources.hashCode();
 		return result;
 	}
 
 	@Override
 	public boolean equals(Object obj) {
 		if (this == obj)
 			return true;
 		if (obj == null)
 			return false;
 		if (getClass() != obj.getClass())
 			return false;
 		final ElmoModule other = (ElmoModule) obj;
 		if (!factories.equals(other.factories))
 			return false;
 		if (!literals.equals(other.literals))
 			return false;
 		if (!roles.equals(other.roles))
 			return false;
 		if (!includedContexts.equals(other.includedContexts))
 			return false;
 		if (!datasets.equals(other.datasets))
 			return false;
 		if (!resources.equals(other.resources))
 			return false;
 		return true;
 	}
 
 	@Override
 	public String toString() {
 		if (context != null)
 			return context.toString();
 		Set<Package> pkg = new LinkedHashSet<Package>();
 		for (Association role : roles) {
 			pkg.add(role.getJavaClass().getPackage());
 		}
 		return pkg.toString();
 	}
 }