package org.apache.torque.engine.database.transform;

 /*

  * 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.BufferedInputStream;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileNotFoundException;

 import java.util.Stack;

 import java.util.Vector;

 import javax.xml.parsers.SAXParser;

 import javax.xml.parsers.SAXParserFactory;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import org.apache.torque.engine.EngineException;

 import org.apache.torque.engine.database.model.Column;

 import org.apache.torque.engine.database.model.Database;

 import org.apache.torque.engine.database.model.Domain;

 import org.apache.torque.engine.database.model.ForeignKey;

 import org.apache.torque.engine.database.model.Index;

 import org.apache.torque.engine.database.model.Table;

 import org.apache.torque.engine.database.model.Unique;

 import org.kuali.core.db.torque.DatabaseParser;

 import org.xml.sax.Attributes;

 import org.xml.sax.InputSource;

 import org.xml.sax.SAXException;

 import org.xml.sax.SAXParseException;

 import org.xml.sax.helpers.DefaultHandler;

 /**

  * A Class that is used to parse an input xml schema file and creates a Database

  * java structure.

  *

  * @author <a href="mailto:leon@opticode.co.za">Leon Messerschmidt</a>

  * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>

  * @author <a href="mailto:mpoeschl@marmot.at">Martin Poeschl</a>

  * @author <a href="mailto:dlr@collab.net">Daniel Rall</a>

  * @author <a href="mailto:fischer@seitenbau.de">Thomas Fischer</a>

  * @author <a href="mailto:monroe@dukece.com>Greg Monroe</a>

  * @version $Id: XmlToAppData.java,v 1.1 2007-10-21 07:57:26 abyrne Exp $

  */

 public class XmlToAppData extends DefaultHandler implements DatabaseParser

 {

     /** Logging class from commons.logging */

     private static Log log = LogFactory.getLog(XmlToAppData.class);

     private Database database;

     private Table currTable;

     private Column currColumn;

     private ForeignKey currFK;

     private Index currIndex;

     private Unique currUnique;

     private boolean firstPass;

     private boolean isExternalSchema;

     private String currentPackage;

     private String currentXmlFile;

     private String defaultPackage;

     private static SAXParserFactory saxFactory;

     /** remember all files we have already parsed to detect looping. */

     private Vector alreadyReadFiles;

     /** this is the stack to store parsing data */

     private Stack parsingStack = new Stack();

     static

     {

         saxFactory = SAXParserFactory.newInstance();

         saxFactory.setValidating(true);

     }

     /**

      * Creates a new instance for the specified database type.

      *

      * @param databaseType The type of database for the application.

      */

     public XmlToAppData(String databaseType)

     {

         database = new Database(databaseType);

         firstPass = true;

     }

     /**

      * Creates a new instance for the specified database type.

      *

      * @param databaseType The type of database for the application.

      * @param defaultPackage the default java package used for the om

      */

     public XmlToAppData(String databaseType, String defaultPackage)

     {

         database = new Database(databaseType);

         this.defaultPackage = defaultPackage;

         firstPass = true;

     }

     /**

      * Parses a XML input file and returns a newly created and

      * populated Database structure.

      *

      * @param xmlFile The input file to parse.

      * @return Database populated by <code>xmlFile</code>.

      */

     public Database parseResource(String xmlFile)

             throws EngineException

     {

         try

         {

             // in case I am missing something, make it obvious

             if (!firstPass)

             {

                 throw new Error("No more double pass");

             }

             // check to see if we alread have parsed the file

             if ((alreadyReadFiles != null)

                     && alreadyReadFiles.contains(xmlFile))

             {

                 return database;

             }

             else if (alreadyReadFiles == null)

             {

                 alreadyReadFiles = new Vector(3, 1);

             }

             // remember the file to avoid looping

             alreadyReadFiles.add(xmlFile);

             currentXmlFile = xmlFile;

             SAXParser parser = saxFactory.newSAXParser();

             FileInputStream fileInputStream = null;

             try

             {

                 fileInputStream = new FileInputStream(xmlFile);

             }

             catch (FileNotFoundException fnfe)

             {

                 throw new FileNotFoundException

                     (new File(xmlFile).getAbsolutePath());

             }

             BufferedInputStream bufferedInputStream

                     = new BufferedInputStream(fileInputStream);

             try

             {

                 log.info("Parsing file: '"

                         + (new File(xmlFile)).getName() + "'");

                 InputSource is = new InputSource(bufferedInputStream);

                 is.setSystemId( new File( xmlFile ).getAbsolutePath() );

                 parser.parse(is, this);

             }

             finally

             {

                 bufferedInputStream.close();

             }

         }

         catch (SAXParseException e)

         {

             throw new EngineException("Sax error on line "

                         + e.getLineNumber()

                         + " column "

                         + e.getColumnNumber()

                         + " : "

                         + e.getMessage(),

                     e);

         }

         catch (Exception e)

         {

             throw new EngineException(e);

         }

         if (!isExternalSchema)

         {

             firstPass = false;

         }

         database.doFinalInitialization();

         return database;

     }

     /**

      * EntityResolver implementation. Called by the XML parser

      *

      * @param publicId The public identifier of the external entity

      * @param systemId The system identifier of the external entity

      * @return an InputSource for the database.dtd file

      * @see DTDResolver#resolveEntity(String, String)

      */

     public InputSource resolveEntity(String publicId, String systemId)

             throws SAXException

     {

         try

         {

             return new DTDResolver().resolveEntity(publicId, systemId);

         }

         catch (Exception e)

         {

             throw new SAXException(e);

         }

     }

     /**

      * Handles opening elements of the xml file.

      *

      * @param uri

      * @param localName The local name (without prefix), or the empty string if

      *         Namespace processing is not being performed.

      * @param rawName The qualified name (with prefix), or the empty string if

      *         qualified names are not available.

      * @param attributes The specified or defaulted attributes

      */

     public void startElement(String uri, String localName, String rawName,

                              Attributes attributes)

             throws SAXException

     {

         try

         {

             if (rawName.equals("database"))

             {

                 if (isExternalSchema)

                 {

                     currentPackage = attributes.getValue("package");

                     if (currentPackage == null)

                     {

                         currentPackage = defaultPackage;

                     }

                 }

                 else

                 {

                     database.loadFromXML(attributes);

                     if (database.getPackage() == null)

                     {

                         database.setPackage(defaultPackage);

                     }

                 }

             }

             else if (rawName.equals("external-schema"))

             {

                 String xmlFile = attributes.getValue("filename");

                 if (xmlFile.charAt(0) != '/')

                 {

                     File f = new File(currentXmlFile);

                     xmlFile = new File(f.getParent(), xmlFile).getPath();

                 }

                 // put current state onto the stack

                 ParseStackElement.pushState(this);

                 isExternalSchema = true;

                 parseResource(xmlFile);

                 // get the last state from the stack

                 ParseStackElement.popState(this);

             }

             else if (rawName.equals("domain"))

             {

                 Domain domain = new Domain();

                 domain.loadFromXML(attributes, database.getPlatform());

                 database.addDomain(domain);

             }

             else if (rawName.equals("table"))

             {

                 currTable = database.addTable(attributes);

                 if (isExternalSchema)

                 {

                     currTable.setForReferenceOnly(true);

                     currTable.setPackage(currentPackage);

                 }

             }

             else if (rawName.equals("column"))

             {

                 currColumn = currTable.addColumn(attributes);

             }

             else if (rawName.equals("inheritance"))

             {

                 currColumn.addInheritance(attributes);

             }

             else if (rawName.equals("foreign-key"))

             {

                 currFK = currTable.addForeignKey(attributes);

             }

             else if (rawName.equals("reference"))

             {

                 currFK.addReference(attributes);

             }

             else if (rawName.equals("index"))

             {

                 currIndex = currTable.addIndex(attributes);

             }

             else if (rawName.equals("index-column"))

             {

                 currIndex.addColumn(attributes);

             }

             else if (rawName.equals("unique"))

             {

                 currUnique = currTable.addUnique(attributes);

             }

             else if (rawName.equals("unique-column"))

             {

                 currUnique.addColumn(attributes);

             }

             else if (rawName.equals("id-method-parameter"))

             {

                 currTable.addIdMethodParameter(attributes);

             }

             else if (rawName.equals("option"))

             {

                 setOption(attributes);

             }

         }

         catch (Exception e)

         {

             throw new SAXException(e);

         }

     }

     /**

      * Handles closing elements of the xml file.

      *

      * @param uri

      * @param localName The local name (without prefix), or the empty string if

      *         Namespace processing is not being performed.

      * @param rawName The qualified name (with prefix), or the empty string if

      *         qualified names are not available.

      */

     public void endElement(String uri, String localName, String rawName)

         throws SAXException

     {

         if (log.isDebugEnabled())

         {

             log.debug("endElement(" + uri + ", " + localName + ", "

                     + rawName + ") called");

         }

         try

         {

             // Reset working objects to null to allow option to know

             // which element it is associated with.

             if (rawName.equals("table"))

             {

                 currTable = null;

             }

             else if (rawName.equals("column"))

             {

                 currColumn = null;

             }

             else if (rawName.equals("foreign-key"))

             {

                 currFK = null;

             }

             else if (rawName.equals("index"))

             {

                 currIndex = null;

             }

             else if (rawName.equals("unique"))

             {

                 currUnique = null;

             }

         }

         catch (Exception e)

         {

             throw new SAXException(e);

         }

     }

     public void setOption(Attributes attributes)

     {

         // Look thru supported model elements in reverse order to

         // find one that this option statement applies to.

         String key = attributes.getValue("key");

         String value = attributes.getValue("value");

         if (currUnique != null)

         {

             currUnique.addOption(key, value);

         }

         else if (currIndex != null)

         {

             currIndex.addOption(key, value);

         }

         else if (currFK != null)

         {

             currFK.addOption(key, value);

         }

         else if (currColumn != null)

         {

             currColumn.addOption(key, value);

         }

         else if (currTable != null)

         {

             currTable.addOption(key, value);

         }

         else

         {                            // Must be a db level option.

             database.addOption(key, value);

         }

     }

     /**

      * Handles exception which occur when the xml file is parsed

      * @param e the exception which occured while parsing

      * @throws SAXException always

      */

     public void error(SAXParseException e) throws SAXException

     {

         log.error("Sax parser threw an Exception", e);

         throw new SAXException(

                 "Error while parsing "

                 + currentXmlFile

                 + " at line "

                 + e.getLineNumber()

                 + " column "

                 + e.getColumnNumber()

                 + " : "

                 + e.getMessage());

     }

     /**

      * When parsing multiple files that use nested <external-schema> tags we

      * need to use a stack to remember some values.

      */

     private static class ParseStackElement

     {

         private boolean isExternalSchema;

         private String currentPackage;

         private String currentXmlFile;

         private boolean firstPass;

         /**

          *

          * @param parser

          */

         public ParseStackElement(XmlToAppData parser)

         {

             // remember current state of parent object

             isExternalSchema = parser.isExternalSchema;

             currentPackage = parser.currentPackage;

             currentXmlFile = parser.currentXmlFile;

             firstPass = parser.firstPass;

             // push the state onto the stack

             parser.parsingStack.push(this);

         }

         /**

          * Removes the top element from the stack and activates the stored state

          *

          * @param parser

          */

         public static void popState(XmlToAppData parser)

         {

             if (!parser.parsingStack.isEmpty())

             {

                 ParseStackElement elem = (ParseStackElement)

                         parser.parsingStack.pop();

                 // activate stored state

                 parser.isExternalSchema = elem.isExternalSchema;

                 parser.currentPackage = elem.currentPackage;

                 parser.currentXmlFile = elem.currentXmlFile;

                 parser.firstPass = elem.firstPass;

             }

         }

         /**

          * Stores the current state on the top of the stack.

          *

          * @param parser

          */

         public static void pushState(XmlToAppData parser)

         {

             new ParseStackElement(parser);

         }

     }

 }