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.texen.ant.TexenTask;
  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.torque.engine.database.model.Table;
  import org.apache.velocity.VelocityContext;
  import org.apache.velocity.context.Context;
  import org.kuali.core.db.torque.DatabaseParser;
  import org.kuali.core.db.torque.KualiXmlToAppData;
  import org.kuali.core.db.torque.StringFilter;
  import org.kuali.core.db.torque.pojo.KualiDatabase;
  import org.kuali.core.db.torque.pojo.Sequence;
  import org.kuali.core.db.torque.pojo.View;
  
  /**
   * 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 {
      List<String> tblIncludes;
      List<String> tblExcludes;
      List<String> vIncludes;
      List<String> sIncludes;
      List<String> vExcludes;
      List<String> sExcludes;
  
      /**
       * 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());
 
         KualiDatabase kdb = (KualiDatabase) database;
 
         // Filter out tables as needed
         filterTables(database);
 
         // Filter out views as needed
         filterViews(kdb);
 
         // Filter out sequences as needed
         filterSequences(kdb);
 
         // Extract the filename
         database.setFileName(grokName(file.toString()));
 
         // return the database
         return database;
     }
 
     protected List<Table> getTables(Database database) {
         List<Table> tables = new ArrayList<Table>();
         for (Object object : database.getTables()) {
             Table table = (Table) object;
             tables.add(table);
         }
         return tables;
     }
 
     protected void filterSequences(KualiDatabase database) {
         StringFilter filter = new StringFilter(sIncludes, sExcludes);
         Iterator<Sequence> itr = database.getSequences().iterator();
         while (itr.hasNext()) {
             Sequence sequence = itr.next();
             String name = sequence.getName();
             boolean remove = !filter.isInclude(name) || filter.isExclude(name);
             if (remove) {
                 System.out.println("[INFO] Filtering out sequence " + name);
                 itr.remove();
             }
         }
     }
 
     protected void filterViews(KualiDatabase database) {
         StringFilter filter = new StringFilter(vIncludes, vExcludes);
         Iterator<View> itr = database.getViews().iterator();
         while (itr.hasNext()) {
             View view = itr.next();
             String name = view.getName();
             boolean remove = !filter.isInclude(name) || filter.isExclude(name);
             if (remove) {
                 System.out.println("[INFO] Filtering out view " + name);
                 itr.remove();
             }
         }
     }
 
     protected void filterTables(Database database) {
         StringFilter filter = new StringFilter(tblIncludes, tblExcludes);
         List<Table> tables = getTables(database);
         for (Table table : tables) {
             String name = table.getName();
             boolean remove = !filter.isInclude(name) || filter.isExclude(name);
             if (remove) {
                 System.out.println("[INFO] Filtering out table " + name);
                 database.removeTable(table);
             }
         }
     }
 
     /**
      * 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
      */
     @Override
     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)
      */
     @Override
     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
      */
     @Override
     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;
     }
 
     public List<String> getTblIncludes() {
         return tblIncludes;
     }
 
     public void setTblIncludes(List<String> includes) {
         this.tblIncludes = includes;
     }
 
     public List<String> getTblExcludes() {
         return tblExcludes;
     }
 
     public void setTblExcludes(List<String> excludes) {
         this.tblExcludes = excludes;
     }
 
     public List<String> getvIncludes() {
         return vIncludes;
     }
 
     public void setvIncludes(List<String> vIncludes) {
         this.vIncludes = vIncludes;
     }
 
     public List<String> getsIncludes() {
         return sIncludes;
     }
 
     public void setsIncludes(List<String> sIncludes) {
         this.sIncludes = sIncludes;
     }
 
     public List<String> getvExcludes() {
         return vExcludes;
     }
 
     public void setvExcludes(List<String> vExcludes) {
         this.vExcludes = vExcludes;
     }
 
     public List<String> getsExcludes() {
         return sExcludes;
     }
 
     public void setsExcludes(List<String> sExcludes) {
         this.sExcludes = sExcludes;
     }
 }