/*
    * 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.codegen;
  
  import groovy.lang.Binding;
  import groovy.lang.MissingPropertyException;
  import groovy.util.GroovyScriptEngine;
  import groovy.util.ResourceConnector;
  import groovy.util.ResourceException;
  
  import java.io.CharArrayWriter;
  import java.io.IOException;
  import java.io.PrintWriter;
  import java.net.URL;
  import java.net.URLConnection;
  import java.util.HashMap;
  import java.util.Map;
  
  import javax.xml.namespace.QName;
  
  import org.openrdf.concepts.owl.Ontology;
  import org.openrdf.concepts.rdfs.Datatype;
  import org.openrdf.elmo.ElmoModule;
  import org.openrdf.elmo.ElmoQuery;
  import org.openrdf.elmo.sesame.SesameManager;
  import org.openrdf.elmo.sesame.SesameManagerFactory;
  import org.openrdf.elmo.sesame.roles.SesameEntity;
  import org.openrdf.model.URI;
  import org.openrdf.model.vocabulary.OWL;
  import org.openrdf.model.vocabulary.RDF;
  import org.openrdf.model.vocabulary.RDFS;
  import org.openrdf.repository.Repository;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Converts OWL ontologies into JavaBeans. This class can be used to create Elmo
   * concepts or other JavaBean interfaces or classes.
   * 
   * @author James Leigh
   * 
   */
  public class CodeGenerator implements ResourceConnector {
  
  	private static String CONCEPT_TEMPLATE = "org/openrdf/elmo/codegen/templates/concept.groovy";
  
  	private static String DATATYPE_TEMPLATE = "org/openrdf/elmo/codegen/templates/datatype.groovy";
  
  	private static String PACKAGE_TEMPLATE = "org/openrdf/elmo/codegen/templates/package.groovy";
  
  	private static final String CLASS_DEFINED_BY = "PREFIX rdf: <"
  			+ RDF.NAMESPACE
  			+ "> PREFIX rdfs: <"
  			+ RDFS.NAMESPACE
  			+ "> PREFIX owl: <"
  			+ OWL.NAMESPACE
  			+ "> SELECT ?bean WHERE { ?bean rdfs:isDefinedBy ?ont . { ?bean rdf:type owl:Class } UNION {?bean rdf:type rdfs:Datatype } }";
  
  	private final Logger logger = LoggerFactory.getLogger(CodeGenerator.class);
  
  	private SesameManagerFactory factory;
  
  	private GroovyScriptEngine engine;
  
  	private OwlNormalizer normalizer;
  
  	private Map<URI, String> ontologies = new HashMap<URI, String>();
  
  	private boolean propertyNamesPrefixed = true;
  
  	private Class<?>[] baseClasses = new Class<?>[0];
  
  	public Class<?>[] getBaseClasses() {
 		return baseClasses;
 	}
 
 	public void setBaseClasses(Class<?>[] baseClasses) {
 		this.baseClasses = baseClasses;
 	}
 
 	public boolean isPropertyNamesPrefixed() {
 		return propertyNamesPrefixed;
 	}
 
 	public void setPropertyNamesPrefixed(boolean prefixPropertyNames) {
 		this.propertyNamesPrefixed = prefixPropertyNames;
 	}
 
 	public void addOntologyPackage(URI ontology, String pkgName) {
 		ontologies.put(ontology, pkgName);
 	}
 
 	public URLConnection getResourceConnection(String name)
 			throws ResourceException {
 		try {
 			URL url = getClass().getResource("/" + name);
 			if (url != null)
 				return url.openConnection();
 			throw new ResourceException("Resource not found: " + name);
 		} catch (IOException e) {
 			throw new ResourceException(e);
 		}
 	}
 
 	public void setRepository(Repository repository) {
 		this.factory = new SesameManagerFactory(new ElmoModule(), repository);
 	}
 
 	public void setGroovyScriptEngine(GroovyScriptEngine engine) {
 		this.engine = engine;
 	}
 
 	public void init() throws Exception {
 		normalizer = new OwlNormalizer();
 		normalizer.setRepository(factory.getRepository());
 		normalizer.normalize();
 	}
 
 	public void exportSourceCode(SourceCodeHandler handler) throws Exception {
 		SesameManager manager = factory.createElmoManager();
 		try {
 			ElmoQuery query;
 			query = manager.createQuery(CLASS_DEFINED_BY);
 			for (Map.Entry<URI, String> e : ontologies.entrySet()) {
 				query.setParameter("ont", new QName(e.getKey().toString()));
 				try {
 					for (Object o : query.getResultList()) {
 						SesameEntity bean = (SesameEntity) o;
 						try {
 							if (bean.getQName() == null)
 								continue;
 							if (bean instanceof Datatype) {
 								buildDatatype(bean, e.getValue(), manager,
 										handler);
 							} else {
 								buildClass(bean, e.getValue(), manager, handler);
 							}
 						} catch (MissingPropertyException exc) {
 							logger.error("Error processing {}", bean);
 							StringBuilder sb = new StringBuilder();
 							for (Class<?> inter : exc.getType().getInterfaces()) {
 								sb.append(inter.getSimpleName()).append(" ");
 							}
 							String sn = exc.getType().getSimpleName();
 							logger.warn("Class {} implements {}", sn, sb
 									.toString());
 							throw exc;
 						} catch (Exception exc) {
 							logger.error("Error processing {}", bean);
 							throw exc;
 						}
 					}
 				} finally {
 					query.close();
 				}
 			}
 			for (URI ontology : ontologies.keySet()) {
 				if (manager.contains(ontology)) {
 					buildOntology(ontology, manager, handler);
 				}
 			}
 		} finally {
 			manager.close();
 		}
 	}
 
 	private void buildClass(SesameEntity bean, String packageName,
 			SesameManager manager, SourceCodeHandler handler) throws Exception {
 		Binding bindings = createBindings();
 		CharArrayWriter output = new CharArrayWriter();
 		setVariables(bindings, manager, packageName, bean);
 		bindings.setVariable("content", new PrintWriter(output));
 		bindings.setVariable("usePrefix", Boolean.valueOf(propertyNamesPrefixed));
 		bindings.setVariable("baseClasses", baseClasses);
 		engine.run(CONCEPT_TEMPLATE, bindings);
 		String content = output.toString();
 		if (content.length() > 0) {
 			handler.handleSource(content);
 		}
 	}
 
 	private void buildDatatype(SesameEntity bean, String packageName,
 			SesameManager manager, SourceCodeHandler handler) throws Exception {
 		Binding bindings = createBindings();
 		CharArrayWriter output = new CharArrayWriter();
 		setVariables(bindings, manager, packageName, bean);
 		bindings.setVariable("content", new PrintWriter(output));
 		engine.run(DATATYPE_TEMPLATE, bindings);
 		String content = output.toString();
 		if (content.length() > 0) {
 			handler.handleSource(content);
 		}
 	}
 
 	private void buildOntology(URI ontology, SesameManager manager,
 			SourceCodeHandler handler) throws Exception {
 		Binding bindings = createBindings();
 		CharArrayWriter output = new CharArrayWriter();
 		Ontology ont = manager.designate(ontology, Ontology.class);
 		bindings.setVariable("bean", ont);
 		bindings.setVariable("packageName", ontologies.get(ontology));
 		bindings.setVariable("uri", ontology);
 		bindings.setVariable("manager", manager);
 		bindings.setVariable("content", new PrintWriter(output));
 		engine.run(PACKAGE_TEMPLATE, bindings);
 		String content = output.toString();
 		if (content.length() > 0) {
 			handler.handleSource(content);
 		}
 	}
 
 	private Binding createBindings() {
 		Binding bindings = new Binding();
 		bindings.setVariable("packageNames", ontologies);
 		bindings.setVariable("literals", factory.getLiteralManager());
 		bindings.setVariable("roles", factory.getRoleMapper());
 		return bindings;
 	}
 
 	private void setVariables(Binding bindings, SesameManager manager,
 			String packageName, SesameEntity bean) {
 		URI uri = (URI) bean.getSesameResource();
 		uri = normalizer.getOriginal(uri);
 		bindings.setVariable("bean", bean);
 		bindings.setVariable("packageName", packageName);
 		bindings.setVariable("uri", uri);
 		bindings.setVariable("manager", manager);
 	}
 }