/*   Copyright (C) 2004 Finalist IT Group
    *
    *   This file is part of JAG - the Java J2EE Application Generator
    *
    *   JAG is free software; you can redistribute it and/or modify
    *   it under the terms of the GNU General Public License as published by
    *   the Free Software Foundation; either version 2 of the License, or
    *   (at your option) any later version.
    *   JAG is distributed in the hope that it will be useful,
   *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *   GNU General Public License for more details.
   *   You should have received a copy of the GNU General Public License
   *   along with JAG; if not, write to the Free Software
   *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  package com.finalist.tools.database;
  
  import java.util.*;
  
  /***
   * Class that models a Query.
   *
   * @author  P.S.D.Reitsma, Finalist IT Group
   * @version 1.0
   */
  public class Query {
     String qName;    //name of the query
     String qString;  // the query's definition
     String oriqString; //the query's original definition
  
     ArrayList BindIdentifiers; //no encapsulation
  
     int argCount;    // the number of arguments to be bound
     boolean givesResultSet; // determines "SELECT" or DML
     boolean performsOrderBy; //determines whether a sort takes place
     boolean isUpdate;
     boolean isInsert;
     boolean isDelete;
     boolean isCallable;
     boolean malformed = false;
  
  
     private String replace(String text1, String text2, int pPosition) {
        String repString = "<P" + pPosition + ">";
  
        int pos = text1.indexOf(repString);
        if (pos == -1) {
           return text1;
        }
        StringBuffer labelBuf = new StringBuffer(text1);
        labelBuf.replace(pos, pos + repString.length(), text2);
        return replace(labelBuf.toString(), text2, pPosition);
     }
  
  
     /*
      * Method replaces the occurence of <P1> by String pReplacement
      * and reparses the query definition.
      *
      * @param String pReplacement. The string that is to be substituted for <P1>.
      */
     public void fillInPlaceholder(Hashtable pReplacements) {
        Enumeration E = pReplacements.keys();
        String replacer;
        Integer pos;
  
        //start with the original query definition
        String qStr = oriqString;
  
        String workString = oriqString;
  
        while (E.hasMoreElements()) {
           pos = (Integer) E.nextElement();
           replacer = (String) pReplacements.get(pos);
           qStr = replace(workString, replacer, pos.intValue());
           workString = qStr;
        }
  
        parse(qStr);
     }
  
  
     /***
      * Constructor.
      * Initializes the Query object by parsing the Query definition qStr.
      *
      * @param  qNm   defines the name of the query
      * @param  qStr  defines the query's definition
      */
     public Query(String qNm, String qStr) {
  
        oriqString = qStr;
  
        qName = qNm;
  
        parse(qStr);
  
    }
 
 
    /***
     * Constructor
     * Initializes the Query object by parsing the Query definition
     *
     * @param definition the definition of the query in SQL
     */
    public Query(String definition) {
       oriqString = definition;
       parse(definition);
    }
 
 
    void parse(String qStr) {
 
       BindIdentifiers = new ArrayList();
 
       try {
          String BindIdentifyer = null;
          StringBuffer q = new StringBuffer(qStr);
          int startBI = qStr.indexOf("{{"); //determine startposition
          int endBI = qStr.lastIndexOf("}}") + 2; //and endposition
          if ((startBI != -1) && (endBI != -1)) { //a BindIdentifier is found.
             BindIdentifyer = q.substring(startBI, endBI);
             qString = q.delete(startBI, endBI).toString();
             qString.toUpperCase();
             qString.trim();
             BindIdentifyer = BindIdentifyer.replace('{', ' ');
             BindIdentifyer = BindIdentifyer.replace('}', ' ');
             BindIdentifyer = BindIdentifyer.trim();
 
             StringTokenizer st = new StringTokenizer(BindIdentifyer, ",");
             while (st.hasMoreTokens()) {
                BindIdentifiers.add(st.nextToken().trim());
             }
 
          }
          else {
             qString = qStr.trim();
 
             char[] querychars = qString.toCharArray();
             Vector startpositions = new Vector();
             //loop over the chars that make up the query.
             for (int i = 1; i != querychars.length; i++) { //start with 1 !
                //check if the colon is not part of a dateformat 'HH24:MI' e.g.
                if ((querychars[i] == ':') && //look for ':'
                   (
                   (querychars[i - 1] == ' ') || //that is preceded by a blank
                   (querychars[i - 1] == ',') || //or a ','
                   (querychars[i - 1] == '=') || //or a '='
                   (querychars[i - 1] == '(') || //or a '('
                   (querychars[i - 1] == '-') || //or a '-'
                   (querychars[i - 1] == '+') || //or a '+'
                   (querychars[i - 1] == '{') || //or a '{'
                   (querychars[i - 1] == '<') || //or a '<'
                   (querychars[i - 1] == '>') || //or a '>'
                   (querychars[i - 1] == '|') || //or a '|'
                   (querychars[i - 1] == 13)//or a CR
                   ) &&
                   (
                   (querychars[i + 1] != '=')//do not process ':='
                   )
                ) { //or a '+'
                   //if such ':' is found loop over the trailing characters
                   //until a non-letter character is found ((int)char<49).
                   int j = i + 1;
                   StringBuffer bindelement = new StringBuffer();
                   while (
                      (j < querychars.length)
                      && (
                      (querychars[j] >= 48) && (querychars[j] <= 57)  // 0..9
                      || (querychars[j] >= 65) && (querychars[j] <= 90)  // A..Z
                      || (querychars[j] >= 97) && (querychars[j] <= 122) // a..z
                      || (querychars[j] == 95)// _
                      )
                      ) {
                      //build up the bind identifyer element.
                      bindelement.append(querychars[j]);
                      startpositions.addElement(new Integer(i));
                      j++;
                   }
                   //add it to the vector.
                   BindIdentifiers.add(bindelement.toString().trim());
                }
             }
             StringBuffer sb;
             Iterator E = BindIdentifiers.iterator();
             while (E.hasNext()) {
                String bindElement = ":" + (String) E.next();
                sb = new StringBuffer(qString);
                for (int i = 0; i < qString.length(); i++) {
                   if (qString.startsWith(bindElement, i)) {
                      sb.replace(i, i + bindElement.length(), "?");
                      //exit if one replacement has been made.
                      break;
                   }
                }
                qString = sb.toString();
             }
          }
          givesResultSet = qString.toUpperCase().startsWith("SELECT");
          performsOrderBy = (qString.toUpperCase().indexOf("ORDER BY") != -1);
          isUpdate = qString.toUpperCase().startsWith("UPDATE");
          isInsert = qString.toUpperCase().startsWith("INSERT");
          isDelete = qString.toUpperCase().startsWith("DELETE");
          isCallable = (
             qString.toUpperCase().startsWith("BEGIN")
             || qString.toUpperCase().startsWith("{")
             );
          argCount = 0;
          for (int i = 0; i < qStr.length(); i++) {
             if (qStr.charAt(i) == '?') {
                argCount++;
             }
          }
          if (BindIdentifyer != null) {
             if (BindIdentifiers.size() < argCount) {
                System.out.println("Query(): " + qName + " has not enough bind identifiers.");
             }
             if (BindIdentifiers.size() > argCount) {
                System.out.println("Query(): " + qName + " has too many bind identifiers.");
             }
          }
       }
       catch (Exception E) {
          malformed = true;
          System.out.println("Query(): Exception ocurred during initialisation of query " + qName);
          E.printStackTrace();
       }
    }
 
 
    /*** Getter for property BindIdentifiers.
     *
     * @return Value of property BindIdentifiers.
     */
    public ArrayList getBindIdentifiers() {
       return BindIdentifiers;
    }
 
 
    /*** Setter for property BindIdentifiers.
     * @param BindIdentifiers New value of property BindIdentifiers.
     */
    public void setBindIdentifiers(ArrayList BindIdentifiers) {
       this.BindIdentifiers = BindIdentifiers;
    }
 
 
    /*** Getter for property oriqString.
     * @return Value of property oriqString.
     */
    public java.lang.String getOriqString() {
       return oriqString;
    }
 
 
    /*** Setter for property oriqString.
     * @param oriqString New value of property oriqString.
     */
    public void setOriqString(java.lang.String oriqString) {
       this.oriqString = oriqString;
    }
 
 }