/**
    * The contents of this file are subject to the Mozilla Public License Version 1.1
    * (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.mozilla.org/MPL/
    * Software distributed under the License is distributed on an "AS IS" basis,
    * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the
    * specific language governing rights and limitations under the License.
    *
    * The Original Code is "MessageQuery.java".  Description:
   * "Queries messages in an SQL-like style.  "
   *
   * The Initial Developer of the Original Code is University Health Network. Copyright (C)
   * 2005.  All Rights Reserved.
   *
   * Contributor(s): ______________________________________.
   *
   * Alternatively, the contents of this file may be used under the terms of the
   * GNU General Public License (the  “GPL”), in which case the provisions of the GPL are
   * applicable instead of those above.  If you wish to allow use of your version of this
   * file only under the terms of the GPL and not to allow others to use your version
   * of this file under the MPL, indicate your decision by deleting  the provisions above
   * and replace  them with the notice and other provisions required by the GPL License.
   * If you do not delete the provisions above, a recipient may use your version of
   * this file under either the MPL or the GPL.
   *
   */
  package ca.uhn.hl7v2.util;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Properties;
  import java.util.StringTokenizer;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import ca.uhn.hl7v2.HL7Exception;
  import ca.uhn.hl7v2.model.Message;
  
  /**
   * Queries messages in an SQL-like style.  We get repeated row-like 
   * structures by looping over repetitions of groups, segments, or fields. 
   * 
   * This is a very advanced class ... maybe too advanced even for you.  If you 
   * find it confusing, please note that there are simpler ways to get data 
   * from a message (like calling its getters or using Terser).   
   * 
   * LOOPING:    
   * You specify the loop points as part of the query.  For example you could 
   * specify loop point x like this: <code>x = /.MSH-18(*)</code>.  The * 
   * is replaced by numbers 0, 1, 2, etc. as you loop through the results, 
   * so this example would loop through repetitions of MSH-18.  If 
   * there are multiple loop points, the loops are nested so that each possible 
   * combination is returned.  Looping stops when none of the fields under a 
   * loop point are valued.  The name of the loop point ('x' in the example 
   * above) is arbitrary.        
   * 
   * SELECTING FIELDS: 
   * The syntax is similar to SQL, except that Terser paths are used in place
   * of table.field.  You can use the "as" keyword to give a field a name, like 
   * this: <code>select /.MSH-7 as msg_date</code>.  If your field is under 
   * a loop point, replace the path up to the loop point with a loop point 
   * reference, like this: <code>select {foo}-1 loop foo = /.PID-3(*)</code>
   * 
   * SELECTING ROWS:
   * A "row" is a combination of all selected fields at one iteration.  You 
   * can filter which rows are returned using a where clause similar to that
   * in SQL.  Use exact values or regular expressions, for example: 
   * <code>where {1} like '.*blood.*'</code> or <code>where {1}/PID-3-1 = '111'</code>
   * Multiple filters can be separated with commas (which mean 'and').  Future
   * versions may support 'or', negation, brackets, etc., but this version doesn't.  
   * 
   * FULL EXAMPLE: 
   * select {pat-id}-1 as id loop pat-id = ./PID-3(*) where {pat-id}-2 = 'mrn'
   * 
   * SUBTLETIES OF LOOPING: 
   * A loop point can be under another loop point.  For example consider the message:   
   * 
   * MSH|etc.|etc.
   * Z01|one~two|a
   * Z01|three~four|b
   * 
   * The query, "select {a}-2, {b} loop a = /Z01(*), b = {a}-1(*)" would return: 
   * a one
   * a two 
   * b three
   * b four
   * 
   * While the query "select {a}-2, {b} loop a = /Z01(*), b = /Z01(1)-1(*)" would return:
   * a one
   * a two 
   * b one
   * b two
   * 
   * In the first case, one loop point refers to another.  In the second case the loops 
   * are treated as independent, just as if they referred to different branches of the 
   * message.  
   * 
   * TODO: could support distinct easily by keeping record of rows and comparing each 
  * one to previous rows 
  * 
  * @author <a href="mailto:bryan.tripp@uhn.on.ca">Bryan Tripp</a>
  * @version $Revision: 1.3 $ updated on $Date: 2005/02/22 16:06:36 $ by $Author: bryan_tripp $
  */
 public class MessageQuery {
 
     /**
      * @param theMessage an HL7 message from which data are to be queried 
      * @param theQuery the query (see class docs for syntax)
      * @return data from the message that are selected by the query 
      */
     public static Result query(Message theMessage, String theQuery) {
         Properties clauses = getClauses(theQuery);
         
         //parse select clause
         StringTokenizer select = new StringTokenizer(clauses.getProperty("select"), ", ", false);
         ArrayList fieldPaths = new ArrayList(10);
         HashMap names = new HashMap(10);
         while (select.hasMoreTokens()) {
             String token = select.nextToken();
             if (token.equals("as")) {
                 if (!select.hasMoreTokens()) {
                     throw new IllegalArgumentException("Keyword 'as' must be followed by a field label");
                 }
                 names.put(select.nextToken(), new Integer(fieldPaths.size()-1));
             } else {
                 fieldPaths.add(token);  
             }
         }
         
         //parse loop clause 
         StringTokenizer loop = new StringTokenizer(clauses.getProperty("loop", ""), ",", false);
         ArrayList loopPoints = new ArrayList(10);
         HashMap loopPointNames = new HashMap(10);
         while (loop.hasMoreTokens()) {
             String pointDecl = loop.nextToken();
             StringTokenizer tok = new StringTokenizer(pointDecl, "=", false);
             String name = tok.nextToken().trim();
             String path = tok.nextToken().trim();
             loopPoints.add(path);
             loopPointNames.put(name, new Integer(loopPoints.size()-1));
         }
                 
         //parse where clause 
         //TODO: this will do for now but it should really be evaluated like an expression 
         //rather than a list  
         StringTokenizer where = new StringTokenizer(clauses.getProperty("where", ""), ",", false);
         ArrayList filters = new ArrayList();
         while (where.hasMoreTokens()) {
             filters.add(where.nextToken());
         }
         String[] filterPaths = new String[filters.size()];
         String[] filterPatterns = new String[filters.size()];
         boolean[] exactFlags = new boolean[filters.size()];
         
         for (int i = 0; i < filters.size(); i++) {
             exactFlags[i] = true;
             String filter = (String) filters.get(i);
             String[] parts = splitFromEnd(filter, "=");
             if (parts[1] != null) {                
                 parts[1] = parts[1].substring(1);
             } else {
                 exactFlags[i] = false;
                 parts = splitFromEnd(filter, "like");
                 parts[1] = parts[1].substring(4);
             }
             filterPaths[i] = parts[0].trim();
             parts[1] = parts[1].trim();
             filterPatterns[i] = parts[1].substring(1, parts[1].length()-1);
         }        
         
         return new ResultImpl(theMessage, 
                 (String[]) loopPoints.toArray(new String[0]), 
                 loopPointNames, 
                 (String[]) fieldPaths.toArray(new String[0]), 
                 names,
                 filterPaths, 
                 filterPatterns, 
                 exactFlags);
     }
     
     
     private static Properties getClauses(String theQuery) {
         Properties clauses = new Properties();
         
         String[] split = splitFromEnd(theQuery, "where ");
         setClause(clauses, "where", split[1]);
                 
         split = splitFromEnd(split[0], "loop ");
         setClause(clauses, "loop", split[1]);
         setClause(clauses, "select", split[0]);
         
         if (clauses.getProperty("where", "").indexOf("loop ") >= 0) {
             throw new IllegalArgumentException("The loop clause must precede the where clause");            
         }
         if (clauses.getProperty("select") == null) {
             throw new IllegalArgumentException("The query must begin with a select clause");                        
         }
         return clauses;
     }
     
     private static void setClause(Properties theClauses, String theName, String theClause) {
         if (theClause != null) {
             theClauses.setProperty(theName, theClause.substring(theName.length()).trim());
         }
     }
     
     private static String[] splitFromEnd(String theString, String theMarker) {
         String[] result = new String[2];
         int begin = theString.indexOf(theMarker);
         if (begin >= 0) {
             result[0] = theString.substring(0, begin);
             result[1] = theString.substring(begin);
         } else {
             result[0] = theString;
         }        
         return result;
     }
     
     /**
      * A result set for a message query.    
      * 
      * @author <a href="mailto:bryan.tripp@uhn.on.ca">Bryan Tripp</a>
      * @version $Revision: 1.3 $ updated on $Date: 2005/02/22 16:06:36 $ by $Author: bryan_tripp $
      */
     public static interface Result {
         
         /**
          * @param theFieldNumber numbered from zero in the order they are specified in the 
          *      query
          * @return the corresponding value in the current row 
          */
         public String get(int theFieldNumber);
         
         /**
          * @param theFieldName a field name as specified in the query with the keyword "as" 
          * @return the corresponding value in the current row 
          */
         public String get(String theFieldName);
         
         /**
          * @return a list of named fields as defined with 'as' in the query
          */
         public String[] getNamedFields();
         
         /**
          * Advances to the next "row" of data if one is available. 
          * @return true if another row is available  
          * @throws HL7Exception
          */
         public boolean next() throws HL7Exception;
 
     }
     
     private static class ResultImpl implements Result {
 
         private Terser myTerser;
         private String[] myValues;
         private String[] myLoopPoints;
         private Map myLoopPointNames;
         private String[] myFieldPaths;
         private Map myFieldNames;
         private int[] myIndices;
         private int[] myNumEmpty; //number of empty sub-loops since last non-empty one
         private int[] myMaxNumEmpty;
         private boolean myNonLoopingQuery = false;
         private String[] myWherePaths;
         private String[] myWhereValues;
         private String[] myWherePatterns;
         private boolean[] myExactMatchFlags;
         
         public ResultImpl(Message theMessage, 
                 String[] theLoopPoints,  
                 Map theLoopPointNames, 
                 String[] theFieldPaths, 
                 Map theFieldNames, 
                 String[] theWherePaths, 
                 String[] theWherePatterns, 
                 boolean[] theExactMatchFlags) {
             
             myTerser = new Terser(theMessage);
             myLoopPoints = theLoopPoints;
             myIndices = new int[theLoopPoints.length];
             myNumEmpty = new int[theLoopPoints.length];
             myMaxNumEmpty = getMaxNumEmpty(theLoopPoints);
             myLoopPointNames = theLoopPointNames;
             myFieldPaths = theFieldPaths;
             myValues = new String[theFieldPaths.length];
             myFieldNames = theFieldNames;
             myWherePaths = theWherePaths;
             myWherePatterns = theWherePatterns;
             myExactMatchFlags = theExactMatchFlags;
                         
             if (theLoopPoints.length == 0) {
                 myNonLoopingQuery = true; //if no loops, give ourselves 1 iteration
             } else {
                 myIndices[myIndices.length - 1] = -1; //start before 1st iteration
             }
             
         }
         
         //extracts max number of empty iterations for each loop point (this is communicated 
         //as an optional integer after the *, e.g. blah(*3) ... default is 0).  
         private int[] getMaxNumEmpty(String[] theLoopPoints) {
             int[] retVal = new int[theLoopPoints.length];
             for (int i = 0; i < theLoopPoints.length; i++) {
                 retVal[i] = getMaxNumEmpty(theLoopPoints[i]);
             }
             return retVal;
         }
         
         private int getMaxNumEmpty(String theLoopPoint) {
             int retVal = 0; //default
             
             Matcher m = Pattern.compile("\\*(\\d+)").matcher(theLoopPoint);
             if (m.find()) {
                 String num = m.group(1);
                 retVal = Integer.parseInt(num);
             }
             
             return retVal;
         }
         
         //returns true if some field under the given loop point has a value at the present 
         //iteration
         private boolean currentRowValued(int theLoopPoint) {
             for (int i = 0; i < myFieldPaths.length; i++) {
                 if (referencesLoop(myFieldPaths[i], theLoopPoint)) {
                     String value = (String) myValues[i];
                     if (value != null && value.length() > 0) {
                         return true;
                     }                    
                 }
             }
             return false;
         }
         
         //returns true if the current row matches the where clause filters
         private boolean currentRowMatchesFilter() {
             for (int i = 0; i < myWhereValues.length; i++) {
                 if (myExactMatchFlags[i]) {
                     if (!myWherePatterns[i].equals(myWhereValues[i])) {
                         return false;
                     }                    
                 } else {
                     if (!Pattern.matches(myWherePatterns[i], myWhereValues[i])) {
                         return false;
                     }
                 }
             }
             return true;
         }
         
         //true if the given path references the given loop point (directly 
         //or indirectly)
         private boolean referencesLoop(String theFieldPath, int theLoopPoint) {
             String path = theFieldPath;
             int lp;
             while ((lp = getLoopPointReference(path)) >= 0) {
                 if (lp == theLoopPoint) {
                     return true;
                 } else {
                     path = myLoopPoints[lp];
                 }                
             }
             return false;
         }
         
         //expands a set of paths to their current loop point iterations, and gets 
         //current values from our message
         private String[] getCurrentValues(String[] thePaths) throws HL7Exception {
             String[] paths = composePaths(thePaths);
             String[] values = new String[paths.length]; 
             for (int i = 0; i < paths.length; i++) {
                 values[i] = myTerser.get(paths[i]);
                 if (values[i] == null) {
                     values[i] = "";
                 }
             }
             return values;
         }               
         
         //creates full Terser paths from current location, loop points, and given paths 
         //with loop point references 
         private String[] composePaths(String[] thePaths) {
             String[] currentLoopPoints = composeLoopPoints();
             String[] result = new String[thePaths.length];
             for (int i = 0; i < thePaths.length; i++) {
                 result[i] = thePaths[i];
                 int ref = getLoopPointReference(thePaths[i]);
                 if (ref >= 0) {
                     result[i] = expandLoopPointReference(result[i], currentLoopPoints[ref]);
                 }                
             }
             return result;
         }
         
         //parameterizes loop points with present location (i.e. replaces * with current
         //indices)
         private String[] composeLoopPoints() {
             String[] result = new String[myLoopPoints.length];
             for (int i = 0; i < myLoopPoints.length; i++) {
                 result[i] = myLoopPoints[i].replaceAll("\\*\\d*", String.valueOf(myIndices[i]));
 
                 int ref = getLoopPointReference(myLoopPoints[i]);
                 if (ref >= i) {
                     throw new IllegalStateException("Loop point must be defined after the " +
                             "one it references: " + myLoopPoints[i]);
                 } else if (ref >= 0) {
                     result[i] = expandLoopPointReference(result[i], result[ref]);
                 }
             }
             return result;
         }
         
         //extracts LP# of label between first '{' and first '}', or -1 if there isn't one
         private int getLoopPointReference(String thePath) {
             StringTokenizer tok = new StringTokenizer(thePath, "{}", false);
             if (thePath.indexOf('{') >= 0 && tok.hasMoreTokens()) {
                 String ref = tok.nextToken();
                 return ((Integer) myLoopPointNames.get(ref)).intValue();
             } else {
                 return -1;
             }
         }
         
         private String expandLoopPointReference(String thePath, String theLoopPoint) {
             return thePath.replaceAll("\\{.*\\}", theLoopPoint);
         }
                 
         /**
          * @see ca.uhn.hl7v2.util.MessageQuery.Result#get(int)
          */
         public String get(int theFieldNumber) {
             if (theFieldNumber < 0 || theFieldNumber >= myValues.length) {
                 throw new IllegalArgumentException("Field number must be between 0 and " 
                         + (myValues.length - 1));
             }
             return (String) myValues[theFieldNumber];
         }
 
         /**
          * @see ca.uhn.hl7v2.util.MessageQuery.Result#get(java.lang.String)
          */
         public String get(String theFieldName) {
             Integer fieldNum = (Integer) myFieldNames.get(theFieldName);
             if (fieldNum == null) {
                 throw new IllegalArgumentException("Field name not recognized: " + theFieldName);
             }
             return get(fieldNum.intValue());
         }
 
         /** 
          * @throws HL7Exception
          * @see ca.uhn.hl7v2.util.MessageQuery.Result#next()
          */
         public boolean next() throws HL7Exception {
             if (myNonLoopingQuery) {
                 myNonLoopingQuery = false;
                 myValues = getCurrentValues(myFieldPaths);
                 myWhereValues = getCurrentValues(myWherePaths);
                 return currentRowMatchesFilter();
             }
             
             boolean hasNext = false;
             findNext : for (int i = myIndices.length - 1; i >= 0; i--) {    
                 boolean gotMatch = false;
                 while (!gotMatch && myNumEmpty[i] <= myMaxNumEmpty[i]) {
                     myIndices[i]++;
                     myValues = getCurrentValues(myFieldPaths);
                     myWhereValues = getCurrentValues(myWherePaths);
                     
                     if (!currentRowValued(i)) {
                         myNumEmpty[i]++;
                     } else {
                         myNumEmpty[i] = 0;
                     }
                     if (currentRowMatchesFilter()) {
                         gotMatch = true;
                     }
                 }
                 
                 hasNext = myNumEmpty[i] <= myMaxNumEmpty[i];// && currentRowMatchesFilter();
                 if (hasNext) {
                     break findNext;
                 }                                 
                 
                 myIndices[i] = 0;
                 myNumEmpty[i] = 0;
                 
                 //TODO: if we aren't allowing empties in this loop, and have no value, we want to 
                 //return the null in the super-loop.  However, we don't know which loop point, if 
                 //any, is the super-loop.  If it was the next one we could do this ... 
                 //if (i > 0 && myMaxNumEmpty[i] == 0 && myMaxNumEmpty[i-1] > 0 && myIndices[i-1] == 0) {
                 //    myIndices[i-1] = -1;
                 //} ... but it may not be, so we'll ignore this problem for now.  
             }
             return hasNext;
         }
 
         /**
          * @see ca.uhn.hl7v2.util.MessageQuery.Result#getNamedFields()
          */
         public String[] getNamedFields() {
             return (String[]) myFieldNames.keySet().toArray(new String[0]);
         }
         
     }
 
 }