package org.apache.ojb.broker.util.dbhandling;
   
   /* Copyright 2004-2005 The Apache Software Foundation
    *
    * Licensed 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.*;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.StringTokenizer;
  import java.util.zip.GZIPInputStream;
  import java.util.zip.GZIPOutputStream;
  
  import org.apache.ojb.broker.metadata.JdbcConnectionDescriptor;
  import org.apache.ojb.broker.platforms.PlatformException;
  import org.apache.ojb.broker.util.logging.LoggerFactory;
  import org.apache.tools.ant.Project;
  import org.apache.tools.ant.taskdefs.SQLExec;
  import org.apache.tools.ant.types.FileSet;
  import org.apache.torque.task.TorqueDataModelTask;
  import org.apache.torque.task.TorqueSQLExec;
  import org.apache.torque.task.TorqueSQLTask;
  
  /**
   * Provides basic database handling (drop, create, init) via torque.
   * 
   * @author Thomas Dudziak
   */
  public class TorqueDBHandling implements DBHandling
  {
      /** Torque db platforms */
      protected static final String TORQUE_PLATFORM_DB2        = "db2";
      protected static final String TORQUE_PLATFORM_HYPERSONIC = "hypersonic";
      protected static final String TORQUE_PLATFORM_INTERBASE  = "interbase";
      protected static final String TORQUE_PLATFORM_MSSQL      = "mssql";
      protected static final String TORQUE_PLATFORM_MYSQL      = "mysql";
      protected static final String TORQUE_PLATFORM_ORACLE     = "oracle";
      protected static final String TORQUE_PLATFORM_POSTGRESQL = "postgresql";
      protected static final String TORQUE_PLATFORM_SAPDB      = "sapdb";
      protected static final String TORQUE_PLATFORM_SYBASE     = "sybase";
  
      /** The name of the db-creation script */
      private static final String CREATION_SCRIPT_NAME = "create-db.sql";
      /** The name of the torque database mapping file */
      private static final String SQL_DB_MAP_NAME      = "sqldb.map";
  
      /** Mapping from ojb dbms to torque database setting */
      private static HashMap _dbmsToTorqueDb = new HashMap();
      
      static
      {
          _dbmsToTorqueDb.put("db2",         TORQUE_PLATFORM_DB2);
          _dbmsToTorqueDb.put("hsqldb",      TORQUE_PLATFORM_HYPERSONIC);
          _dbmsToTorqueDb.put("firebird",    TORQUE_PLATFORM_INTERBASE);
          _dbmsToTorqueDb.put("mssqlserver", TORQUE_PLATFORM_MSSQL);
          _dbmsToTorqueDb.put("mysql",       TORQUE_PLATFORM_MYSQL);
          _dbmsToTorqueDb.put("oracle",      TORQUE_PLATFORM_ORACLE);
          _dbmsToTorqueDb.put("oracle9i",    TORQUE_PLATFORM_ORACLE);
          _dbmsToTorqueDb.put("postgresql",  TORQUE_PLATFORM_POSTGRESQL);
          _dbmsToTorqueDb.put("sapdb",       TORQUE_PLATFORM_SAPDB);
          _dbmsToTorqueDb.put("sybaseasa",   TORQUE_PLATFORM_SYBASE);
          _dbmsToTorqueDb.put("sybasease",   TORQUE_PLATFORM_SYBASE);
          _dbmsToTorqueDb.put("sybase",      TORQUE_PLATFORM_SYBASE);
      }
      
      /** The jdbc connection for communicating with the db */
      private JdbcConnectionDescriptor _jcd;
      /** The target database */
      private String _targetDatabase;
      /** The directory where we work in */
      private File _workDir;
      /** The compressed contents of the torque schemata */
      private HashMap _torqueSchemata = new HashMap();
      /** The compressed content of the creation script */
      private byte[] _creationScript;
      /** The compressed contents of the db initialization scripts */
      private HashMap _initScripts = new HashMap();
  
      /**
       * Creates a new handling object.
       */
      public TorqueDBHandling()
      {}
  
      /**
       * Sets the jdbc connection to use.
       * 
       * @param jcd The connection to use
      * @throws PlatformException If the target database cannot be handled with torque
      */
     public void setConnection(JdbcConnectionDescriptor jcd) throws PlatformException
     {
         _jcd = jcd;
 
         String targetDatabase = (String)_dbmsToTorqueDb.get(_jcd.getDbms().toLowerCase());
 
         if (targetDatabase == null)
         {
             throw new PlatformException("Database "+_jcd.getDbms()+" is not supported by torque");
         }
         if (!targetDatabase.equals(_targetDatabase))
         {
             _targetDatabase = targetDatabase;
             _creationScript = null;
             _initScripts.clear();
         }
     }
 
     /**
      * Returns the connection descriptor used by this handling object.
      * 
      * @return The connection descriptor
      */
     public JdbcConnectionDescriptor getConnection()
     {
         return _jcd;
     }
 
     /**
      * Returns the torque database platform used.
      * 
      * @return The target db platform
      */
     public String getTargetTorquePlatform()
     {
         return _targetDatabase;
     }
 
     /**
      * Adds the input files (in our case torque schema files) to use.
      * 
      * @param srcDir          The directory containing the files
      * @param listOfFilenames The filenames in a comma-separated list
      */
     public void addDBDefinitionFiles(String srcDir, String listOfFilenames) throws IOException
     {
         StringTokenizer tokenizer = new StringTokenizer(listOfFilenames, ",");
         File            dir       = new File(srcDir);
         String          filename;
         
         while (tokenizer.hasMoreTokens())
         {
             filename = tokenizer.nextToken().trim();
             if (filename.length() > 0)
             {    
                  _torqueSchemata.put("schema"+_torqueSchemata.size()+".xml",
                                      readTextCompressed(new File(dir, filename)));
             }
         }
     }
 
     /**
      * Adds an input stream of a db definition (in our case of a torque schema file).
      * 
      * @param schemaStream The input stream
      */
     public void addDBDefinitionFile(InputStream schemaStream) throws IOException
     {
         _torqueSchemata.put("schema"+_torqueSchemata.size()+".xml",
                             readStreamCompressed(schemaStream));
     }
 
     /**
      * Writes the torque schemata to files in the given directory and returns
      * a comma-separated list of the filenames.
      * 
      * @param dir The directory to write the files to
      * @return The list of filenames
      * @throws IOException If an error occurred
      */
     private String writeSchemata(File dir) throws IOException
     {
         writeCompressedTexts(dir, _torqueSchemata);
 
         StringBuffer includes = new StringBuffer();
 
         for (Iterator it = _torqueSchemata.keySet().iterator(); it.hasNext();)
         {
             includes.append((String)it.next());
             if (it.hasNext())
             {
                 includes.append(",");
             }
         }
         return includes.toString();
     }
     
     /**
      * Creates the db-creation sql script (but does not perform it).
      * 
      * @throws PlatformException If some error occurred
      */
     public void createCreationScript() throws PlatformException
     {
         Project             project    = new Project();
         TorqueDataModelTask modelTask  = new TorqueDataModelTask();
         File                tmpDir     = null;
         File                scriptFile = null;
         
         _creationScript = null;
         try
         {
             tmpDir = new File(getWorkDir(), "schemas");
             tmpDir.mkdir();
 
             String includes = writeSchemata(tmpDir);
             
             scriptFile = new File(tmpDir, CREATION_SCRIPT_NAME);
 
             project.setBasedir(tmpDir.getAbsolutePath());
 
             // populating with defaults
             modelTask.setProject(project);
             modelTask.setUseClasspath(true);
             modelTask.setControlTemplate("sql/db-init/Control.vm");
             modelTask.setOutputDirectory(tmpDir);
             modelTask.setOutputFile(CREATION_SCRIPT_NAME);
             modelTask.setTargetDatabase(_targetDatabase);
 
             FileSet files = new FileSet();
 
             files.setDir(tmpDir);
             files.setIncludes(includes);
             modelTask.addFileset(files);
             modelTask.execute();
 
             _creationScript = readTextCompressed(scriptFile);
 
             deleteDir(tmpDir);
         }
         catch (Exception ex)
         {
             // clean-up
             if ((tmpDir != null) && tmpDir.exists())
             {
                 deleteDir(tmpDir);
             }
             throw new PlatformException(ex);
         }
     }
     
     /**
      * Creates the database.
      * 
      * @throws PlatformException If some error occurred
      */
     public void createDB() throws PlatformException
     {
         if (_creationScript == null)
         {
             createCreationScript();
         }
 
         Project             project    = new Project();
         TorqueDataModelTask modelTask  = new TorqueDataModelTask();
         File                tmpDir     = null;
         File                scriptFile = null;
         
         try
         {
             tmpDir = new File(getWorkDir(), "schemas");
             tmpDir.mkdir();
 
             scriptFile = new File(tmpDir, CREATION_SCRIPT_NAME);
 
             writeCompressedText(scriptFile, _creationScript);
 
             project.setBasedir(tmpDir.getAbsolutePath());
 
             // we use the ant task 'sql' to perform the creation script
 	        SQLExec         sqlTask = new SQLExec();
 	        SQLExec.OnError onError = new SQLExec.OnError();
 	
 	        onError.setValue("continue");
 	        sqlTask.setProject(project);
 	        sqlTask.setAutocommit(true);
 	        sqlTask.setDriver(_jcd.getDriver());
 	        sqlTask.setOnerror(onError);
 	        sqlTask.setUserid(_jcd.getUserName());
 	        sqlTask.setPassword(_jcd.getPassWord() == null ? "" : _jcd.getPassWord());
 	        sqlTask.setUrl(getDBCreationUrl());
 	        sqlTask.setSrc(scriptFile);
 	        sqlTask.execute();
 
 	        deleteDir(tmpDir);
         }
         catch (Exception ex)
         {
             // clean-up
             if ((tmpDir != null) && tmpDir.exists())
             {
                 try
                 {
                     scriptFile.delete();
                 }
                 catch (NullPointerException e) 
                 {
                     LoggerFactory.getLogger(this.getClass()).error("NPE While deleting scriptFile [" + scriptFile.getName() + "]", e);
                 }
             }
             throw new PlatformException(ex);
         }
     }
 
     /**
      * Creates the initialization scripts (creation of tables etc.) but does
      * not perform them.
      * 
      * @throws PlatformException If some error occurred
      */
     public void createInitScripts() throws PlatformException
     {
         Project       project   = new Project();
         TorqueSQLTask sqlTask   = new TorqueSQLTask(); 
         File          schemaDir = null;
         File          sqlDir    = null;
         
         _initScripts.clear();
         try
         {
             File tmpDir = getWorkDir();
 
             schemaDir = new File(tmpDir, "schemas");
             sqlDir    = new File(tmpDir, "sql");
             schemaDir.mkdir();
             sqlDir.mkdir();
 
             String includes     = writeSchemata(schemaDir);
             File   sqlDbMapFile = new File(sqlDir, SQL_DB_MAP_NAME);
 
             sqlDbMapFile.createNewFile();
             project.setBasedir(sqlDir.getAbsolutePath());
             
             // populating with defaults
             sqlTask.setProject(project);
             sqlTask.setUseClasspath(true);
             sqlTask.setBasePathToDbProps("sql/base/");
             sqlTask.setControlTemplate("sql/base/Control.vm");
             sqlTask.setOutputDirectory(sqlDir);
             // we put the report in the parent directory as we don't want
             // to read it in later on
             sqlTask.setOutputFile("../report.sql.generation");
             sqlTask.setSqlDbMap(SQL_DB_MAP_NAME);
             sqlTask.setTargetDatabase(_targetDatabase);
 
             FileSet files = new FileSet();
             
             files.setDir(schemaDir);
             files.setIncludes(includes);
             sqlTask.addFileset(files);
             sqlTask.execute();
 
             readTextsCompressed(sqlDir, _initScripts);
             deleteDir(schemaDir);
             deleteDir(sqlDir);
         }
         catch (Exception ex)
         {
             // clean-up
             if ((schemaDir != null) && schemaDir.exists())
             {
                 deleteDir(schemaDir);
             }
             if ((sqlDir != null) && sqlDir.exists())
             {
                 deleteDir(sqlDir);
             }
             throw new PlatformException(ex);
         }
     }
 
     /**
      * Creates the tables according to the schema files.
      * 
      * @throws PlatformException If some error occurred
      */
     public void initDB() throws PlatformException
     {
         if (_initScripts.isEmpty())
         {
             createInitScripts();
         }
 
         Project       project   = new Project();
         TorqueSQLTask sqlTask   = new TorqueSQLTask(); 
         File          outputDir = null;
         
         try
         {
             outputDir = new File(getWorkDir(), "sql");
 
             outputDir.mkdir();
             writeCompressedTexts(outputDir, _initScripts);
 
             project.setBasedir(outputDir.getAbsolutePath());
 
             // executing the generated sql, but this time with a torque task 
             TorqueSQLExec         sqlExec = new TorqueSQLExec();
             TorqueSQLExec.OnError onError = new TorqueSQLExec.OnError();
 
             sqlExec.setProject(project);
             onError.setValue("continue");
             sqlExec.setAutocommit(true);
             sqlExec.setDriver(_jcd.getDriver());
             sqlExec.setOnerror(onError);
             sqlExec.setUserid(_jcd.getUserName());
             sqlExec.setPassword(_jcd.getPassWord() == null ? "" : _jcd.getPassWord());
             sqlExec.setUrl(getDBManipulationUrl());
             sqlExec.setSrcDir(outputDir.getAbsolutePath());
             sqlExec.setSqlDbMap(SQL_DB_MAP_NAME);
             sqlExec.execute();
             
             deleteDir(outputDir);
         }
         catch (Exception ex)
         {
             // clean-up
             if (outputDir != null)
             {
                 deleteDir(outputDir);
             }
             throw new PlatformException(ex);
         }
     }
 
     /**
      * Template-and-Hook method for generating the url required by the jdbc driver
      * to allow for creating a database (as opposed to accessing an already-existing
      * database).
      *
      */
     protected String getDBCreationUrl()
     {
         JdbcConnectionDescriptor jcd = getConnection();
 
         // currently I only know about specifics for mysql
         if (TORQUE_PLATFORM_MYSQL.equals(getTargetTorquePlatform()))
         {
             // we have to remove the db name as the jdbc driver would try to connect to
             // a non-existing db
             // the db-alias has this form: [host&port]/[dbname]?[options]
             String dbAliasPrefix = jcd.getDbAlias();
             String dbAliasSuffix = "";
             int    questionPos   = dbAliasPrefix.indexOf('?');
 
             if (questionPos > 0)
             {
                 dbAliasSuffix = dbAliasPrefix.substring(questionPos);
                 dbAliasPrefix = dbAliasPrefix.substring(0, questionPos);
             }
 
             int slashPos = dbAliasPrefix.lastIndexOf('/');
 
             if (slashPos > 0)
             {
                 // it is important that the slash at the end is present
                 dbAliasPrefix = dbAliasPrefix.substring(0, slashPos + 1);
             }
             return jcd.getProtocol()+":"+jcd.getSubProtocol()+":"+dbAliasPrefix+dbAliasSuffix;
         }
         else if (TORQUE_PLATFORM_POSTGRESQL.equals(getTargetTorquePlatform()))
         {
             // we have to replace the db name with 'template1'
             // the db-alias has this form: [host&port]/[dbname]?[options]
             String dbAliasPrefix = jcd.getDbAlias();
             String dbAliasSuffix = "";
             int    questionPos   = dbAliasPrefix.indexOf('?');
 
             if (questionPos > 0)
             {
                 dbAliasSuffix = dbAliasPrefix.substring(questionPos);
                 dbAliasPrefix = dbAliasPrefix.substring(0, questionPos);
             }
 
             int slashPos = dbAliasPrefix.lastIndexOf('/');
 
             if (slashPos > 0)
             {
                 // it is important that the slash at the end is present
                 dbAliasPrefix = dbAliasPrefix.substring(0, slashPos + 1);
             }
             else
             {
                 dbAliasPrefix += "/";
             }
             dbAliasPrefix += "template1";
             if (dbAliasSuffix.length() > 0)
             {
                 dbAliasPrefix += "/";
             }
             return jcd.getProtocol()+":"+jcd.getSubProtocol()+":"+dbAliasPrefix+dbAliasSuffix;
             
         }
         else
         {
             return jcd.getProtocol()+":"+jcd.getSubProtocol()+":"+jcd.getDbAlias();
         }
     }
 
     /**
      * Template-and-Hook method for generating the url required by the jdbc driver
      * to allow for modifying an existing database.
      *
      */
     protected String getDBManipulationUrl()
     {
         JdbcConnectionDescriptor jcd = getConnection();
 
         return jcd.getProtocol()+":"+jcd.getSubProtocol()+":"+jcd.getDbAlias();
     }
 
     /**
      * Reads the given text file and compressed its content.
      * 
      * @param file The file
      * @return A byte array containing the GZIP-compressed content of the file
      * @throws IOException If an error ocurred
      */
     private byte[] readTextCompressed(File file) throws IOException
     {
         return readStreamCompressed(new FileInputStream(file));
     }
 
     /**
      * Reads the given text stream and compressed its content.
      * 
      * @param stream The input stream
      * @return A byte array containing the GZIP-compressed content of the stream
      * @throws IOException If an error ocurred
      */
     private byte[] readStreamCompressed(InputStream stream) throws IOException
     {
         ByteArrayOutputStream bao    = new ByteArrayOutputStream();
         GZIPOutputStream      gos    = new GZIPOutputStream(bao);
         OutputStreamWriter    output = new OutputStreamWriter(gos);
         BufferedReader        input  = new BufferedReader(new InputStreamReader(stream));
         String                line;
 
         while ((line = input.readLine()) != null)
         {
             output.write(line);
             output.write('\n');
         }
         input.close();
         stream.close();
         output.close();
         gos.close();
         bao.close();
         return bao.toByteArray();
     }
 
     /**
      * Reads the text files in the given directory and puts their content
      * in the given map after compressing it. Note that this method does not
      * traverse recursivly into sub-directories.
      * 
      * @param dir     The directory to process
      * @param results Map that will receive the contents (indexed by the relative filenames)
      * @throws IOException If an error ocurred
      */
     private void readTextsCompressed(File dir, HashMap results) throws IOException
     {
         if (dir.exists() && dir.isDirectory())
         {
             File[] files = dir.listFiles();
 
             for (int idx = 0; idx < files.length; idx++)
             {
                 if (files[idx].isDirectory())
                 {
                     continue;
                 }
                 results.put(files[idx].getName(), readTextCompressed(files[idx]));
             }
         }
     }
 
     /**
      * Uncompresses the given textual content and writes it to the given file.
      * 
      * @param file              The file to write to
      * @param compressedContent The content
      * @throws IOException If an error occurred
      */
     private void writeCompressedText(File file, byte[] compressedContent) throws IOException
     {
         ByteArrayInputStream bais   = new ByteArrayInputStream(compressedContent);
         GZIPInputStream      gis    = new GZIPInputStream(bais);
         BufferedReader       input  = new BufferedReader(new InputStreamReader(gis));
         BufferedWriter       output = new BufferedWriter(new FileWriter(file));
         String               line;
 
         while ((line = input.readLine()) != null)
         {
             output.write(line);
             output.write('\n');
         }
         input.close();
         gis.close();
         bais.close();
         output.close();
     }
     
     /**
      * Uncompresses the textual contents in the given map and and writes them to the files
      * denoted by the keys of the map.
      * 
      * @param dir      The base directory into which the files will be written 
      * @param contents The map containing the contents indexed by the filename
      * @throws IOException If an error occurred
      */
     private void writeCompressedTexts(File dir, HashMap contents) throws IOException
     {
         String filename;
 
         for (Iterator nameIt = contents.keySet().iterator(); nameIt.hasNext();)
         {
             filename = (String)nameIt.next();
             writeCompressedText(new File(dir, filename), (byte[])contents.get(filename));
         }
     }
     
     /**
      * Sets the working directory.
      * 
      * @param dir The directory
      * @throws IOException If the directory does not exist or cannot be written/read
      */
     public void setWorkDir(String dir) throws IOException
     {
         File workDir = new File(dir);
 
         if (!workDir.exists() || !workDir.canWrite() || !workDir.canRead())
         {
             throw new IOException("Cannot access directory "+dir);
         }
         _workDir = workDir;
     }
 
     /**
      * Returns the temporary directory used by java.
      * 
      * @return The temporary directory
      * @throws IOException If an io error occurred
      */
     private File getWorkDir() throws IOException
     {
         if (_workDir == null)
         {    
             File   dummy   = File.createTempFile("dummy", ".log");
             String workDir = dummy.getPath().substring(0, dummy.getPath().lastIndexOf(File.separatorChar));
     
             if ((workDir == null) || (workDir.length() == 0))
             {
                 workDir = ".";
             }
             dummy.delete();
             _workDir = new File(workDir);
         }
         return _workDir;
     }
 
     /**
      * Little helper function that recursivly deletes a directory.
      * 
      * @param dir The directory
      */
     private void deleteDir(File dir)
     {
         if (dir.exists() && dir.isDirectory())
         {
             File[] files = dir.listFiles();
 
             for (int idx = 0; idx < files.length; idx++)
             {
                 if (!files[idx].exists())
                 {
                     continue;
                 }
                 if (files[idx].isDirectory())
                 {
                     deleteDir(files[idx]);
                 }
                 else
                 {
                     files[idx].delete();
                 }
             }
             dir.delete();
         }
     }
 }