/**
    * 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.List;
  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.1 $ updated on $Date: 2007-02-19 02:24:27 $ by $Author:
   *          jamesagnew $
   * @deprecated
   */
  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);
 		List<String> fieldPaths = new ArrayList<>(10);
 		Map<String, Integer> 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(), fieldPaths.size() - 1);
 			} else {
 				fieldPaths.add(token);
 			}
 		}
 
 		// parse loop clause
 		StringTokenizer loop = new StringTokenizer(clauses.getProperty("loop",
 				""), ",", false);
 		List<String> loopPoints = new ArrayList<>(10);
 		Map<String, Integer> 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, 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);
 		List<String> 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 = 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,
 				loopPoints.toArray(new String[0]), loopPointNames,
 				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", "").contains("loop ")) {
 			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.1 $ updated on $Date: 2007-02-19 02:24:27 $ by
 	 *          $Author: jamesagnew $
 	 */
 	public interface Result {
 
 		/**
 		 * @param theFieldNumber
 		 *            numbered from zero in the order they are specified in the
 		 *            query
 		 * @return the corresponding value in the current row
 		 */
         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
 		 */
         String get(String theFieldName);
 
 		/**
 		 * @return a list of named fields as defined with 'as' in the query
 		 */
         String[] getNamedFields();
 
 		/**
 		 * Advances to the next "row" of data if one is available.
 		 * 
 		 * @return true if another row is available
 		 * @throws HL7Exception
 		 */
         boolean next() throws HL7Exception;
 
 	}
 
 	private static class ResultImpl implements Result {
 
 		private final Terser myTerser;
 		private String[] myValues;
 		private final String[] myLoopPoints;
 		private final Map<String, Integer> myLoopPointNames;
 		private final String[] myFieldPaths;
 		private final Map<String, Integer> myFieldNames;
 		private final int[] myIndices;
 		private final int[] myNumEmpty; // number of empty sub-loops since last
 									// non-empty one
 		private final int[] myMaxNumEmpty;
 		private boolean myNonLoopingQuery = false;
 		private final String[] myWherePaths;
 		private String[] myWhereValues;
 		private final String[] myWherePatterns;
 		private final boolean[] myExactMatchFlags;
 
 		public ResultImpl(Message theMessage, String[] theLoopPoints,
 				Map<String, Integer> theLoopPointNames, String[] theFieldPaths,
 				Map<String, Integer> 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 = 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 myLoopPointNames.get(ref);
 			} 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 myValues[theFieldNumber];
 		}
 
 		/**
 		 * @see ca.uhn.hl7v2.util.MessageQuery.Result#get(java.lang.String)
 		 */
 		public String get(String theFieldName) {
 			Integer fieldNum = myFieldNames.get(theFieldName);
 			if (fieldNum == null) {
 				throw new IllegalArgumentException(
 						"Field name not recognized: " + theFieldName);
 			}
 			return get(fieldNum);
 		}
 
 		/**
 		 * @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;
 			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;
 				}
 
 				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 myFieldNames.keySet().toArray(new String[0]);
 		}
 
 	}
 
 }