package org.apache.torque.task;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.Hashtable;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.lang.StringUtils;
  import org.apache.tools.ant.BuildException;
  import org.apache.tools.ant.DirectoryScanner;
  import org.apache.tools.ant.types.FileSet;
  import org.apache.torque.engine.EngineException;
  import org.apache.torque.engine.database.model.Database;
  import org.apache.velocity.VelocityContext;
  import org.apache.velocity.context.Context;
  import org.apache.texen.ant.TexenTask;
  import org.kuali.core.db.torque.DatabaseParser;
  import org.kuali.core.db.torque.KualiXmlToAppData;
  
  /**
   * A base torque task that uses either a single XML schema representing a data model, or a <fileset> of XML
   * schemas. We are making the assumption that an XML schema representing a data model contains tables for a
   * <strong>single</strong> database.
   * 
   * @author <a href="mailto:jvanzyl@zenplex.com">Jason van Zyl</a>
   * @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a>
   */
  public class TorqueDataModelTask extends TexenTask {
  	/**
  	 * XML that describes the database model, this is transformed into the application model object.
  	 */
  	protected String xmlFile;
  
  	/** Fileset of XML schemas which represent our data models. */
  	protected List<FileSet> filesets = new ArrayList<FileSet>();
  
  	/** Data models that we collect. One from each XML schema file. */
  	protected List<Database> dataModels = new ArrayList<Database>();
  
  	/** Velocity context which exposes our objects in the templates. */
  	protected Context context;
  
  	/**
  	 * Map of data model name to database name. Should probably stick to the convention of them being the same but I
  	 * know right now in a lot of cases they won't be.
  	 */
  	protected Hashtable<String, String> dataModelDbMap;
  
  	/**
  	 * Hashtable containing the names of all the databases in our collection of schemas.
  	 */
  	protected Hashtable<String, String> databaseNames;
  
  	// !! This is probably a crappy idea having the sql file -> db map
  	// here. I can't remember why I put it here at the moment ...
  	// maybe I was going to map something else. It can probably
  	// move into the SQL task.
  
  	/**
  	 * Name of the properties file that maps an SQL file to a particular database.
  	 */
  	protected String sqldbmap;
  
  	/** The target database(s) we are generating SQL for. */
  	private String targetDatabase;
  
  	/** Target Java package to place the generated files in. */
  	private String targetPackage;
  
  	/**
  	 * Set the sqldbmap.
  	 * 
  	 * @param sqldbmap
  	 *            th db map
  	 */
  	public void setSqlDbMap(String sqldbmap) {
  		// !! Make all these references files not strings.
 		this.sqldbmap = getProject().resolveFile(sqldbmap).toString();
 	}
 
 	/**
 	 * Get the sqldbmap.
 	 * 
 	 * @return String sqldbmap.
 	 */
 	public String getSqlDbMap() {
 		return sqldbmap;
 	}
 
 	/**
 	 * Return the data models that have been processed.
 	 * 
 	 * @return List data models
 	 */
 	public List<Database> getDataModels() {
 		return dataModels;
 	}
 
 	/**
 	 * Return the data model to database name map.
 	 * 
 	 * @return Hashtable data model name to database name map.
 	 */
 	public Hashtable<String, String> getDataModelDbMap() {
 		return dataModelDbMap;
 	}
 
 	/**
 	 * Get the xml schema describing the application model.
 	 * 
 	 * @return String xml schema file.
 	 */
 	public String getXmlFile() {
 		return xmlFile;
 	}
 
 	/**
 	 * Set the xml schema describing the application model.
 	 * 
 	 * @param xmlFile
 	 *            The new XmlFile value
 	 */
 	public void setXmlFile(String xmlFile) {
 		this.xmlFile = xmlFile;
 	}
 
 	/**
 	 * Adds a set of xml schema files (nested fileset attribute).
 	 * 
 	 * @param set
 	 *            a Set of xml schema files
 	 */
 	public void addFileset(FileSet set) {
 		filesets.add(set);
 	}
 
 	/**
 	 * Get the current target database.
 	 * 
 	 * @return String target database(s)
 	 */
 	public String getTargetDatabase() {
 		return targetDatabase;
 	}
 
 	/**
 	 * Set the current target database. (e.g. mysql, oracle, ..)
 	 */
 	public void setTargetDatabase(String targetDatabase) {
 		this.targetDatabase = targetDatabase;
 	}
 
 	/**
 	 * Get the current target package.
 	 * 
 	 * @return return target java package.
 	 */
 	public String getTargetPackage() {
 		return targetPackage;
 	}
 
 	/**
 	 * Set the current target package. This is where generated java classes will live.
 	 */
 	public void setTargetPackage(String targetPackage) {
 		this.targetPackage = targetPackage;
 	}
 
 	/**
 	 * Return a SAX parser that implements the DatabaseParser interface
 	 */
 	protected DatabaseParser getDatabaseParser() {
 		return new KualiXmlToAppData(getTargetDatabase(), getTargetPackage());
 	}
 
 	/**
 	 * Parse a schema XML File into a Database object
 	 */
 	protected Database getDataModel(File file) throws EngineException {
 		// Get a handle to a parser
 		DatabaseParser databaseParser = getDatabaseParser();
 
 		// Parse the file into a database
 		Database database = databaseParser.parseResource(file.toString());
 
 		// Extract the filename
 		database.setFileName(grokName(file.toString()));
 
 		// return the database
 		return database;
 	}
 
 	/**
 	 * Get the list of schema XML files from our filesets
 	 */
 	protected List<File> getDataModelFiles() {
 		// Allocate some storage
 		List<File> dataModelFiles = new ArrayList<File>();
 
 		// Iterate through the filesets
 		for (int i = 0; i < getFilesets().size(); i++) {
 			// Extract a fileset
 			FileSet fs = getFilesets().get(i);
 
 			// Create a directory scanner
 			DirectoryScanner ds = fs.getDirectoryScanner(getProject());
 
 			// Figure out the directory to scan
 			File srcDir = fs.getDir(getProject());
 
 			// Scan the directory
 			String[] dataModelFilesArray = ds.getIncludedFiles();
 
 			// Add each file in the directory to our list
 			for (int j = 0; j < dataModelFilesArray.length; j++) {
 				File file = new File(srcDir, dataModelFilesArray[j]);
 				dataModelFiles.add(file);
 			}
 		}
 
 		// Return the list of schema.xml files
 		return dataModelFiles;
 	}
 
 	/**
 	 * Parse schema XML files into Database objects
 	 */
 	protected List<Database> getPopulatedDataModels() throws EngineException {
 		// Allocate some storage
 		List<Database> databases = new ArrayList<Database>();
 
 		// Only one file to parse
 		if (getXmlFile() != null) {
 			// Parse the file into a database object
 			Database database = getDataModel(new File(getXmlFile()));
 			// Add it to our list
 			databases.add(database);
 			// we are done
 			return databases;
 		}
 
 		// Get the list of schema XML files to parse from our filesets
 		List<File> dataModelFiles = getDataModelFiles();
 		// Iterate through the list, parsing each schema.xml file into a database object
 		for (File dataModelFile : dataModelFiles) {
 			// Parse a schema.xml file into a database object
 			Database database = getDataModel(dataModelFile);
 			// Add the database object to our list
 			databases.add(database);
 		}
 		// Return the list of database objects
 		return databases;
 	}
 
 	/**
 	 * Set up the initial context for generating SQL
 	 * 
 	 * @return the context
 	 * @throws Exception
 	 */
 	public Context initControlContext() throws Exception {
 		if (xmlFile == null && filesets.isEmpty()) {
 			throw new BuildException("You must specify an XML schema or fileset of XML schemas!");
 		}
 
 		try {
 			dataModels = getPopulatedDataModels();
 		} catch (EngineException ee) {
 			throw new BuildException(ee);
 		}
 
 		Iterator<Database> i = dataModels.iterator();
 		databaseNames = new Hashtable<String, String>();
 		dataModelDbMap = new Hashtable<String, String>();
 
 		// Different datamodels may state the same database
 		// names, we just want the unique names of databases.
 		while (i.hasNext()) {
 			Database database = i.next();
 			databaseNames.put(database.getName(), database.getName());
 			dataModelDbMap.put(database.getFileName(), database.getName());
 		}
 
 		context = new VelocityContext();
 
 		// Place our set of data models into the context along
 		// with the names of the databases as a convenience for now.
 		context.put("dataModels", dataModels);
 		context.put("databaseNames", databaseNames);
 		context.put("targetDatabase", targetDatabase);
 		context.put("targetPackage", targetPackage);
 
 		return context;
 	}
 
 	/**
 	 * Change type of "now" to java.util.Date
 	 * 
 	 * @see org.apache.velocity.texen.ant.TexenTask#populateInitialContext(org.apache.velocity.context.Context)
 	 */
 	protected void populateInitialContext(Context context) throws Exception {
 		super.populateInitialContext(context);
 		context.put("now", new Date());
 	}
 
 	/**
 	 * Gets a name to use for the application's data model.
 	 * 
 	 * @param xmlFile
 	 *            The path to the XML file housing the data model.
 	 * @return The name to use for the <code>AppData</code>.
 	 */
 	private String grokName(String xmlFile) {
 		// This can't be set from the file name as it is an unreliable
 		// method of naming the descriptor. Not everyone uses the same
 		// method as I do in the TDK. jvz.
 
 		String name = "data-model";
 		int i = xmlFile.lastIndexOf(System.getProperty("file.separator"));
 		if (i != -1) {
 			// Creep forward to the start of the file name.
 			i++;
 
 			int j = xmlFile.lastIndexOf('.');
 			if (i < j) {
 				name = xmlFile.substring(i, j);
 			} else {
 				// Weirdo
 				name = xmlFile.substring(i);
 			}
 		}
 		return name;
 	}
 
 	/**
 	 * Override Texen's context properties to map the torque.xxx properties (including defaults set by the
 	 * org/apache/torque/defaults.properties) to just xxx.
 	 * 
 	 * <p>
 	 * Also, move xxx.yyy properties to xxxYyy as Velocity doesn't like the xxx.yyy syntax.
 	 * </p>
 	 * 
 	 * @param file
 	 *            the file to read the properties from
 	 */
 	public void setContextProperties(String file) {
 		super.setContextProperties(file);
 
 		// Map the torque.xxx elements from the env to the contextProperties
 		Hashtable<?, ?> env = super.getProject().getProperties();
 		for (Iterator<?> i = env.entrySet().iterator(); i.hasNext();) {
 			Map.Entry<?, ?> entry = (Map.Entry<?, ?>) i.next();
 			String key = (String) entry.getKey();
 			if (key.startsWith("torque.")) {
 				String newKey = key.substring("torque.".length());
 				int j = newKey.indexOf(".");
 				while (j != -1) {
 					newKey = newKey.substring(0, j) + StringUtils.capitalize(newKey.substring(j + 1));
 					j = newKey.indexOf(".");
 				}
 
 				contextProperties.setProperty(newKey, entry.getValue());
 			}
 		}
 	}
 
 	public List<FileSet> getFilesets() {
 		return filesets;
 	}
 
 	public void setFilesets(List<FileSet> filesets) {
 		this.filesets = filesets;
 	}
 }