/*   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;
  
  /***
   *  Utility class to indent queries and insert newlines
   *  usage: create new object with string to format, and
   *  call toString on the object.
   *
   *@author  mdemare
   */
  public class SqlPretty {
  
     // the keywords that should produce a linefeed
     private final static String[] KEYWORD = {"from", "where", "having", "group by",
                                              "order by", "and", "set", "delete", "insert", "select", "or"};
  
     private final static int INDENT_SPACE = 3;
  
     private StringBuffer sb = new StringBuffer();
     private int i = -1;
     private int indent = 0;
     private int keywordIndent = 0;
     private boolean inString = false;
     private boolean escaped = false;
     private boolean skipspace = false;
     private String sql;
  
     private String result;
  
  
     /***
      *Constructor for the SqlPretty object
      *
      *@param  sql query string to format
      */
     public SqlPretty(String sql) {
        this.sql = sql;
        while (++i < sql.length()) {
           char c = sql.charAt(i);
  
           // skip spaces after commas
           if (skipspace) {
              if (c == ' ' || c == '\t') {
                 continue;
              }
              else {
                 skipspace = false;
              }
           }
  
           // previous char was a backspace
           if (escaped) {
              sb.append(c);
              escaped = false;
              continue;
           }
  
           // this char is a backspace
           if (c == '//') {
              escaped = true;
              sb.append(c);
              continue;
           }
  
           // entering or leaving string
           if (c == '\'' || c == '\"') {
              inString = !inString;
              sb.append(c);
              continue;
           }
  
           // within a string
           if (inString) {
              sb.append(c);
              continue;
           }
  
           switch (c) {
              // increase indentation and check for keyword
              case '(':
                 indent++;
                 // check for keyword
              case ' ':
                // keyword() will print the "(" if necessary
                if (!keyword()) {
                   sb.append(c);
                }
                break;
                // decrease indentation
             case ')':
                indent--;
                sb.append(c);
                break;
                // new line and indent
             case ',':
                sb.append(c + "\n");
                indent(keywordIndent + indent * INDENT_SPACE);
                skipspace = true;
                break;
                // else just print the character
             default:
                sb.append(c);
          }
       }
       // store result
       result = sb.toString();
    }
 
 
    /***
     * Compare word that starts after current char with list of keywords.
     * New line and extra indentation if found.
     * We use INDENT_SPACE spaces for each level of parentheses,
     * and KEYWORD.length + 1 for the most recently seen keyword.
     */
    private boolean keyword() {
       for (int j = 0; j < KEYWORD.length; j++) {
          if (i + KEYWORD[j].length() + 1 >= sql.length()) {
             continue;
          }
          if (KEYWORD[j].equalsIgnoreCase(sql.substring(i + 1, i + KEYWORD[j].length() + 1))) {
             sb.append("\n");
             indent(indent * INDENT_SPACE);
             if (sql.charAt(i) == '(') {
                sb.append('(');
             }
             sb.append(KEYWORD[j]);
             i += KEYWORD[j].length();
             keywordIndent = KEYWORD[j].length() + 1;
             return true;
          }
       }
       return false;
    }
 
 
    /***
     *  Description of the Method
     *
     *@return  Description of the Return Value
     */
    public String toString() {
       return result;
    }
 
 
    /***
     *  The main program for the SqlPretty class
     *
     *@param  args The command line arguments
     *@throws  Exception Description of the Exception
     */
    /*
    public static void main(String[] args) throws Exception {
       BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       StringBuffer sb = new StringBuffer(" ");
       while (br.ready()) {
          String s = br.readLine();
          sb.append(strip(s, null).replace('\t', ' '));
          sb.append(" ");
       }
       System.out.println(sb.toString());
       SqlPretty prettifier = new SqlPretty(sb.toString());
       System.out.println(prettifier.toString());
    }
    */
 
 
    /***
     * Repeat a string n times to form a new string.
     *
     *@param  str String to repeat
     *@param  repeat int number of times to repeat
     *@return  String with repeated string
     *@throws  NegativeArraySizeException if repeat < 0
     *@throws  NullPointerException if str is null
     */
    private static String repeat(String str, int repeat) {
       StringBuffer buffer = new StringBuffer(repeat * str.length());
       for (int i = 0; i < repeat; i++) {
          buffer.append(str);
       }
       return buffer.toString();
    }
 
 
    /***
     *  Description of the Method
     *
     *@param  str Description of the Parameter
     *@param  delim Description of the Parameter
     *@return  Description of the Return Value
     */
    private static String strip(String str, String delim) {
       str = stripStart(str, delim);
       return stripEnd(str, delim);
    }
 
 
    /***
     *  Description of the Method
     *
     *@param  str Description of the Parameter
     *@param  strip Description of the Parameter
     *@return  Description of the Return Value
     */
    private static String stripStart(String str, String strip) {
       if (str == null) {
          return null;
       }
       int start = 0;
       int sz = str.length();
 
       if (strip == null) {
          while ((start != sz) && Character.isWhitespace(str.charAt(start))) {
             start++;
          }
       }
       else {
          while ((start != sz) && (strip.indexOf(str.charAt(start)) != -1)) {
             start++;
          }
       }
       return str.substring(start);
    }
 
 
    /***
     *  Description of the Method
     *
     *@param  str Description of the Parameter
     *@param  strip Description of the Parameter
     *@return  Description of the Return Value
     */
    private static String stripEnd(String str, String strip) {
       if (str == null) {
          return null;
       }
       int end = str.length();
       if (strip == null) {
          while ((end != 0) && Character.isWhitespace(str.charAt(end - 1))) {
             end--;
          }
       }
       else {
          while ((end != 0) && (strip.indexOf(str.charAt(end - 1)) != -1)) {
             end--;
          }
       }
       return str.substring(0, end);
    }
 
 
    private void indent(int s) {
       sb.append(repeat(" ", s));
    }
 
 
 }