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;

         }

 }