package net.sf.sapjcosupport;

 import org.apache.log4j.Logger;

 import org.apache.oro.text.regex.*;

 import java.util.*;

 /**

  * @author Niki Driessen

  * @since Apr 21, 2006 - 10:47:03 AM

  */

 public class SapQuery {

     private String searchHelpName, selectionMethod;

     private int maximumResults;

     private Class persistentObject;

     private List javaFields = new ArrayList(2);

     private List sapFields = new ArrayList(2);

     private List criteria = new ArrayList(1);

     protected final Logger log = Logger.getLogger(getClass());

     private static Map optionMap;

     private static final String operatorRegex = "(like|not like|==|=|<>|!=|<=|>=|<|>)";

     static {

         optionMap = new TreeMap();

         optionMap.put("like", SearchCriterion.CONTAINS_PATTERN);

         optionMap.put("not like", SearchCriterion.CONTAINS_NOT_PATTERN);

         optionMap.put("==", SearchCriterion.EQUAL);

         optionMap.put("=", SearchCriterion.EQUAL);

         optionMap.put("<>", SearchCriterion.NOT_EQUAL);

         optionMap.put("!=", SearchCriterion.NOT_EQUAL);

         optionMap.put("<=", SearchCriterion.LESS_OR_EQUAL);

         optionMap.put(">=", SearchCriterion.GREATER_OR_EQUAL);

         optionMap.put("<", SearchCriterion.LESS);

         optionMap.put(">", SearchCriterion.GREATER);

 //        optionMap.put("between", SearchCriterion.BETWEEN);

 //        optionMap.put("not between",SearchCriterion.NOT_BETWEEN);

     }

     private static final String WHERE = "where";

     private static final String FROM = "from";

     private static final String SELECT = "select";

     /**

      * "partNumber = MATNR_EXT where MATNR_EXT like '?%' AND SPRAS = 'E'"

      * "partNumber = MATNR_EXT, alternateDescription = MAKTG where MAKTG like '%?%' AND SPRAS = 'E'"

      *

      * @param query

      */

     public SapQuery(String query, Class persistentObject, int maximumResults) {

         this.persistentObject = persistentObject;

         this.maximumResults = maximumResults;

         parseQuery(query);

     }

     public class QueryParseException extends RuntimeException {

         public QueryParseException(String queryPart, String expected, int offset) {

             super("Syntax error near: " + queryPart + ", at position: " + offset + ", expected: " + expected);

         }

     }

     private class WhereClauseSplitter extends StringSplitter {

         private Collection delims;

         public WhereClauseSplitter(String string) {

             super(string, "(and|or)", false);

         }

         public WhereClauseSplitter(String string, String regex) {

             super(string, regex, false);

         }

         protected void split() {

             try {

                 PatternCompiler compiler = new Perl5Compiler();

                 Pattern pattern;

                 if (caseSensitive) {

                     pattern = compiler.compile(delim);

                 } else {

                     pattern = compiler.compile(delim, Perl5Compiler.CASE_INSENSITIVE_MASK);

                 }

                 PatternMatcher partsMatcher = new Perl5Matcher();

                 parts = new ArrayList(5);

                 delims = new ArrayList(5);

                 int prev = 0;

                 PatternMatcherInput input = new PatternMatcherInput(string);

                 while (partsMatcher.contains(input, pattern)) {

                     MatchResult result = partsMatcher.getMatch();

                     parts.add(string.substring(prev, result.beginOffset(1)));

                     delims.add(result.group(1));

                     prev = result.endOffset(1) + 1;

                     input.setBeginOffset(prev);

                 }

                 parts.add(string.substring(prev));

             } catch (Exception e) {

                 e.printStackTrace();

                 throw new QueryParseException(string, "valid condition expression", 0);

             }

         }

         public Iterator iterator() {

             return new WhereClauseIterator(parts.iterator(), delims.iterator());

         }

         public class WhereClauseIterator implements Iterator {

             private String matchedDelim;

             private Iterator internal;

             private Iterator delims;

             public WhereClauseIterator(Iterator parts, Iterator delims) {

                 this.internal = parts;

                 this.delims = delims;

             }

             public void remove() {

                 delims.remove();

                 internal.remove();

             }

             public boolean hasNext() {

                 return internal.hasNext();

             }

             public Object next() {

                 if (delims.hasNext()) {

                     matchedDelim = (String) delims.next();

                 }

                 return internal.next();

             }

             public String getMatchedDelim() {

                 return matchedDelim;

             }

         }

     }

     private class StringSplitter {

         protected Collection parts;

         protected String string;

         protected String delim;

         protected boolean caseSensitive;

         /**

          * Splits a string by delim.

          *

          * @param string

          * @param delim

          */

         public StringSplitter(String string, String delim, boolean caseSensitive) {

             this.string = string;

             this.delim = delim;

             this.caseSensitive = caseSensitive;

             split();

         }

         protected void split() {

             String source = this.string;

             if (!caseSensitive) {

                 source = string.toLowerCase();

                 delim = delim.toLowerCase();

             }

             parts = new ArrayList();

             int prev = 0;

             int index = source.indexOf(delim);

             while (index > 0) {

                 String part = string.substring(prev, index);

                 parts.add(part.trim());

                 prev = index + delim.length() + 1;

                 index = source.indexOf(delim, prev);

             }

             //last part...

             parts.add(string.substring(prev).trim());

         }

         public Iterator iterator() {

             return parts.iterator();

         }

         public int countParts() {

             return parts.size();

         }

     }

     public void parseQuery(String query) {

         //parse the query

         StringSplitter whereSplitter = new StringSplitter(query, WHERE, false);

         if (whereSplitter.countParts() != 2) {

             throw new QueryParseException(query, WHERE, query.length());

         }

         Iterator mainParts = whereSplitter.iterator();

         String temp = (String) mainParts.next();

         StringSplitter selectFromSplitter = new StringSplitter(temp, FROM, false);

         if (selectFromSplitter.countParts() != 2) {

             throw new QueryParseException(temp, FROM, query.length());

         }

         Iterator selectFromParts = selectFromSplitter.iterator();

         String selectClause = (String) selectFromParts.next();

         selectClause = replaceFirst(selectClause, SELECT, "");

         String fromClause = (String) selectFromParts.next();

         String whereClause = (String) mainParts.next();

         StringTokenizer fieldSelectionTokenizer = new StringTokenizer(selectClause, ",");

         while (fieldSelectionTokenizer.hasMoreTokens()) {

             String part = fieldSelectionTokenizer.nextToken().trim();

             parseFieldSelection(part, query.indexOf(part));

         }

         StringTokenizer fromTokenizer = new StringTokenizer(fromClause, ".");

         if (fromTokenizer.countTokens() != 2) {

             throw new QueryParseException(fromClause, "from SEARCHHELP.SELECTION_METHOD", fromClause.length());

         }

         searchHelpName = fromTokenizer.nextToken();

         selectionMethod = fromTokenizer.nextToken();

         WhereClauseSplitter.WhereClauseIterator whereParts = (WhereClauseSplitter.WhereClauseIterator)

                 new WhereClauseSplitter(whereClause).iterator();

         while (whereParts.hasNext()) {

             String part = (String) whereParts.next();

             String delim = whereParts.getMatchedDelim();

             parseCriteria(part);

         }

     }

     private String replaceFirst(String haystack, String needle, String replacement) {

         int pos = haystack.indexOf(needle);

         if (pos >= 0) {

             return (pos > 0 ? haystack.substring(0, pos - 1) : "") +

                     replacement +

                     (((pos + needle.length()) < haystack.length()) ?

                             haystack.substring(pos + needle.length()) : "");

         }

         return haystack;

     }

     /**

      * Parses expression of the form 'javaField = SAP_FIELD'.

      * spaces are optional (can be none or more between the parts of the expression)

      *

      * @param queryPart the part of the query to interprete as a field selection

      */

     private void parseFieldSelection(String queryPart, int offset) {

         StringTokenizer tokenizer = new StringTokenizer(queryPart, "=");

         if (tokenizer.countTokens() != 2) {

             throw new QueryParseException(queryPart, "=", offset);

         }

         String javaField = tokenizer.nextToken().trim();

         String sapField = tokenizer.nextToken().trim();

         javaFields.add(javaField);

         sapFields.add(sapField);

     }

     private void parseCriteria(String queryPart) {

         WhereClauseSplitter splitter = new WhereClauseSplitter(queryPart, operatorRegex);

         WhereClauseSplitter.WhereClauseIterator clauseParts = (WhereClauseSplitter.WhereClauseIterator) splitter.iterator();

         if (splitter.countParts() != 2) {

             throw new QueryParseException(queryPart, "'field [operator] value'", 0);

         } else {

             String field = ((String) clauseParts.next()).trim();

             String option = (String) optionMap.get(clauseParts.getMatchedDelim());

             String lowLimit = ((String) clauseParts.next()).trim();

             if (field.length() == 0) {

                 throw new QueryParseException(queryPart, "valid field name before operator", 0);

             }

             if (option == null) {

                 throw new QueryParseException(queryPart, "valid operator", 0);

             }

             if (lowLimit.length() == 0) {

                 throw new QueryParseException(queryPart, "valid expression after operator", 0);

             }

             if (lowLimit.charAt(0) == '\'') {

                 lowLimit = lowLimit.substring(1);

             }

             if (lowLimit.charAt(lowLimit.length() - 1) == '\'') {

                 lowLimit = lowLimit.substring(0, lowLimit.length() - 1);

             }

             lowLimit = lowLimit.replace('%', '*');

             SearchCriterion criterion = new SearchCriterion();

             criterion.setField(field);

             //criterion.setHighLimit();

             criterion.setLowLimit(lowLimit);

             criterion.setIncluded(true);

             criterion.setOption(option);

             criteria.add(criterion);

         }

     }

     public void setParameter(String parameter) {

         setParameter(0, parameter);

     }

     public void setParameter(int position, String parameter) {

         SearchCriterion criterion = (SearchCriterion) criteria.get(position);

         if (criterion != null) {

             String lowLimit = criterion.getLowLimit();

             lowLimit = replaceFirst(lowLimit, "?", parameter);

             criterion.setLowLimit(lowLimit);

         } else {

             throw new IndexOutOfBoundsException("No parameter at position " + position);

         }

     }

     public void setParameters(String[] params) {

         for (int i = 0; i < params.length; i++) {

             String param = params[i];

             setParameter(i, param);

         }

     }

     public List executeQuery(SapSearchHelp searchHelper) {

         return searchHelper.search(searchHelpName, selectionMethod, maximumResults, criteria, persistentObject, javaFields, sapFields);

     }

 }