/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.pirk.utils;

import java.text.ParseException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.util.regex.Pattern;

import org.apache.hadoop.io.MapWritable;
import org.apache.hadoop.io.Text;
import org.apache.pirk.inputformat.hadoop.TextArrayWritable;
import org.apache.pirk.schema.data.DataSchema;
import org.apache.pirk.schema.data.partitioner.IPDataPartitioner;
import org.elasticsearch.hadoop.mr.WritableArrayWritable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Class used for URI query parsing
 * <p>
 * Query of the form @{code ?q=<queryField>:<queryTerm>}
 * <p>
 * TODO: Use Lucene's query parsing?... Make this lots lots better...
 *
 */
public class QueryParserUtils
{
  private static final Logger logger = LoggerFactory.getLogger(QueryParserUtils.class);

  /**
   * Given a URI query string, checks to see if the given document satisfies the query
   * <p>
   * ...Very hacky...
   * <p>
   * NOTE: Assumes that MapWritable keys are Text objects and values are Text or TextArrayWritable objects
   * <p>
   * NOTE: Support for list fields (values) is provided for checkRecord with Map<String, Object> and checkRecord with MapWritable containing
   * WritableArrayWritable types for array values (vs. json string list representation)
   * <p>
   * NOTE: @ symbol represents flag ignore case sensitivity used after field (e.g. user_agent@:*searchparam*)
   * <p>
   * NOTE: Assumes that all AND booleans come before any OR booleans - ADD @ case sensitivity support for range queries
   * 
   */
  public static boolean checkRecord(String uriQuery, MapWritable doc, DataSchema dataSchema)
  {
    boolean satisfiesQuery = true;

    logger.debug("uriQuery = " + uriQuery);
    uriQuery = uriQuery.substring(3); // strip the beginning query tag '?q='
    logger.debug("uriQuery = " + uriQuery);

    if (uriQuery.equals("*"))
    {
      return true;
    }

    String[] queryTokens = uriQuery.split("\\+(?=AND)|\\+(?=OR)|\\+(?=[a-z])"); // booleans of the form +AND+, +OR+, don't split on +T0+
    int index = 0;
    String item;
    while (index < queryTokens.length)
    {
      boolean ignoreCase = false;

      item = queryTokens[index];
      logger.debug("item = " + item);

      String[] itemTokens = item.split(":", 2); // There are two components <field>:<query>
      logger.debug("itemTokens[0] = " + itemTokens[0] + " itemTokens[1] = " + itemTokens[1]);

      // check for ignore case flag
      if (itemTokens[0].endsWith("@"))
      {
        ignoreCase = true;
        logger.debug("ignore case = true");
        itemTokens[0] = itemTokens[0].replaceAll("@", ""); // strip flag
        logger.debug("itemTokens[0]:" + itemTokens[0]);
      }

      Object value = doc.get(new Text(itemTokens[0]));
      if (value != null) // if the field is not present, a null Writable is returned
      {

        if (itemTokens[1].startsWith("[")) // Inclusive range query
        {
          if (value instanceof Text)
          {
            if (!checkRangeQuery(true, itemTokens[0], itemTokens[1], value.toString(), dataSchema))
            {
              logger.debug("checkRangeQuery returned false");
              satisfiesQuery = false;
            }
          }
          else if (value instanceof TextArrayWritable)
          {
            String[] elements = ((TextArrayWritable) value).toStrings();
            boolean oneSatisfied = false;
            for (String element : elements)
            {
              if (checkRangeQuery(true, itemTokens[0], itemTokens[1], element, dataSchema))
              {
                logger.debug("checkRangeQuery returned true");
                oneSatisfied = true;
                break;
              }
            }
            satisfiesQuery = oneSatisfied;
          }
        }
        else if (itemTokens[1].startsWith("{")) // Exclusive range query
        {
          if (value instanceof Text)
          {
            if (!checkRangeQuery(false, itemTokens[0], itemTokens[1], value.toString(), dataSchema))
            {
              logger.debug("checkRangeQuery returned false");
              satisfiesQuery = false;
            }
          }
          else if (value instanceof TextArrayWritable)
          {
            String[] elements = ((TextArrayWritable) value).toStrings();
            boolean oneSatisfied = false;
            for (String element : elements)
            {
              if (checkRangeQuery(false, itemTokens[0], itemTokens[1], element, dataSchema))
              {
                logger.debug("checkRangeQuery returned true");
                oneSatisfied = true;
                break;
              }
            }
            satisfiesQuery = oneSatisfied;
          }
        }
        else
        // Not a range query
        {
          if (value instanceof Text)
          {
            String valueString = value.toString();
            if (ignoreCase)
            { // Case insensitivity
              logger.debug("not a range query; itemstoken1:" + itemTokens[1]);
              itemTokens[1] = itemTokens[1].toLowerCase();
              valueString = valueString.toLowerCase();
              logger.debug("valuestring after:" + valueString);
            }

            if (itemTokens[1].contains("*") || itemTokens[1].contains("?")) // Wildcard match
            {
              logger.debug("itemTokens[1] = " + itemTokens[1] + " contains wildcard");
              if (!Pattern.matches(wildcardToRegex(itemTokens[1]), valueString))
              {
                logger.debug("stringValue = " + valueString + " did not satisfy itemTokens[1] = " + itemTokens[1]);
                satisfiesQuery = false;
              }
              logger.debug("stringValue = " + valueString + " did satisfy itemTokens[1] = " + itemTokens[1]);
            }
            else if (!(valueString).equals(itemTokens[1])) // Single value match
            {
              logger.debug("We do not have a single value match: stringValue " + valueString + " != itemTokens[1] = " + itemTokens[1]);
              satisfiesQuery = false;
            }
          }
          else if (value instanceof TextArrayWritable)
          {
            String[] elements = ((TextArrayWritable) value).toStrings();
            logger.debug("elements.size() = " + elements.length);

            boolean oneSatisfied = false;
            for (String element : elements)
            {
              if (ignoreCase)
              { // Case insensitivity
                itemTokens[1] = itemTokens[1].toLowerCase();
                logger.debug("waw: itemtoken1 after:" + itemTokens[1]);
                element = element.toLowerCase();
                logger.debug("element after:" + element);
              }

              logger.debug("element: " + element);
              if (itemTokens[1].contains("*") || itemTokens[1].contains("?")) // Wildcard match
              {
                logger.debug("itemTokens[1] = " + itemTokens[1] + " contains wildcard");
                if (Pattern.matches(wildcardToRegex(itemTokens[1]), element))
                {
                  logger.debug("stringValue = " + element + " satisfied itemTokens[1] = " + itemTokens[1]);
                  oneSatisfied = true;
                  break;
                }
              }
              else if (element.equals(itemTokens[1])) // Single value match
              {
                logger.debug("We have a single value match: stringValue " + element + " = itemTokens[1] = " + itemTokens[1]);
                oneSatisfied = true;
                break;
              }
            }
            satisfiesQuery = oneSatisfied;
          }
        }
      }
      else
      {
        satisfiesQuery = false; // add fix - account for case if query field does not exist
      }

      ++index; // Try to pick up the boolean operators
      if (index < (queryTokens.length - 1))
      {
        if (queryTokens[index].equals("AND")) // Do nothing and keep going
        {
          if (!satisfiesQuery)
          {
            break;
          }
          ++index;
          item = queryTokens[index];
        }
        else if (queryTokens[index].equals("OR")) // Assume all OR's occur after all AND's
        {
          if (satisfiesQuery) // if we passed the query and it is not the first term
          {
            break;
          }
          else
          {
            ++index;
            item = queryTokens[index];
            satisfiesQuery = true; // reset so that we pick up matches for the next term
          }
        }
        else if (!satisfiesQuery)
        {
          logger.debug("Does not satisfy the query and no boolean ops next...");
          break;
        }
      }
    }

    return satisfiesQuery;
  }

  @SuppressWarnings("unchecked")
  public static boolean checkRecord(String uriQuery, Map<String,Object> doc, DataSchema dataSchema)
  {
    boolean satisfiesQuery = true;

    logger.debug("uriQuery = " + uriQuery);
    uriQuery = uriQuery.substring(3); // strip the beginning query tag '?q='
    logger.debug("uriQuery = " + uriQuery);

    if (uriQuery.equals("*"))
    {
      return true;
    }

    String[] queryTokens = uriQuery.split("\\+(?=AND)|\\+(?=OR)|\\+(?=[a-z])"); // booleans of the form +AND+, +OR+, don't split on +T0+
    int index = 0;
    String item;
    while (index < queryTokens.length)
    {
      item = queryTokens[index];
      logger.debug("item = " + item);

      String[] itemTokens = item.split(":", 2); // There are two components <field>:<query>
      logger.debug("itemTokens[0] = " + itemTokens[0] + " itemTokens[1] = " + itemTokens[1]);

      boolean ignoreCase = false;

      // check for ignore case flag
      if (itemTokens[0].endsWith("@"))
      {
        ignoreCase = true;
        itemTokens[0] = itemTokens[0].replaceAll("@", ""); // strip case flag
        logger.debug("ignore case: itemTokens[0] = " + itemTokens[0] + " itemTokens[1] = " + itemTokens[1]);
      }

      Object value = doc.get(itemTokens[0]); // handle array answers
      if (value != null) // if the field is not present, a null Writable is returned
      {
        if (itemTokens[1].startsWith("[")) // Inclusive range query
        {
          if (value instanceof String)
          {
            if (ignoreCase)
            { // case insensitivity
              itemTokens[1] = itemTokens[1].toLowerCase();
              value = value.toString().toLowerCase();
            }

            if (!checkRangeQuery(true, itemTokens[0], itemTokens[1], (String) value, dataSchema))
            {
              logger.debug("checkRangeQuery returned false");
              satisfiesQuery = false;
            }
          }
          else if (value instanceof ArrayList)
          {
            boolean oneSatisfied = false;
            for (String element : (ArrayList<String>) value)
            {
              if (checkRangeQuery(true, itemTokens[0], itemTokens[1], element, dataSchema))
              {
                logger.debug("checkRangeQuery returned true");
                oneSatisfied = true;
                break;
              }
            }
            satisfiesQuery = oneSatisfied;
          }
        }
        else if (itemTokens[1].startsWith("{")) // Exclusive range query
        {
          if (value instanceof String)
          {
            if (!checkRangeQuery(false, itemTokens[0], itemTokens[1], (String) value, dataSchema))
            {
              logger.debug("checkRangeQuery returned false");
              satisfiesQuery = false;
            }
          }
          else if (value instanceof ArrayList)
          {

            boolean oneSatisfied = false;
            for (String element : (ArrayList<String>) value)
            {
              if (ignoreCase)
              {
                itemTokens[1] = itemTokens[1].toLowerCase();
                element = element.toLowerCase();
              }
              if (checkRangeQuery(false, itemTokens[0], itemTokens[1], element, dataSchema))
              {
                logger.debug("checkRangeQuery returned true");
                oneSatisfied = true;
                break;
              }
            }
            satisfiesQuery = oneSatisfied;
          }
        }
        else
        // Not a range query
        {
          if (value instanceof String)
          {
            if (ignoreCase)
            {
              itemTokens[1] = itemTokens[1].toLowerCase();
              value = value.toString().toLowerCase();
            }

            if (itemTokens[1].contains("*") || itemTokens[1].contains("?")) // Wildcard match
            {
              logger.debug("itemTokens[1] = " + itemTokens[1] + " contains wildcard");
              if (!Pattern.matches(wildcardToRegex(itemTokens[1]), (String) value))
              {
                logger.debug("stringValue = " + value + " did not satisfy itemTokens[1] = " + itemTokens[1]);
                satisfiesQuery = false;
              }
              logger.debug("stringValue = " + value + " did satisfy itemTokens[1] = " + itemTokens[1]);
            }
            else if (!(value).equals(itemTokens[1])) // Single value match
            {
              logger.debug("We do not have a single value match: stringValue " + value + " != itemTokens[1] = " + itemTokens[1]);
              satisfiesQuery = false;
            }
          }
          else if (value instanceof ArrayList)
          {
            boolean oneSatisfied = false;
            for (String element : (ArrayList<String>) value)
            {
              logger.debug("element = " + element);
              if (ignoreCase)
              { // case insensitivity
                itemTokens[1] = itemTokens[1].toLowerCase();
                element = element.toLowerCase();
              }

              if (itemTokens[1].contains("*") || itemTokens[1].contains("?")) // Wildcard match
              {
                logger.debug("itemTokens[1] = " + itemTokens[1] + " contains wildcard");
                if (Pattern.matches(wildcardToRegex(itemTokens[1]), element))
                {
                  logger.debug("stringValue = " + element + " satisfied itemTokens[1] = " + itemTokens[1]);
                  oneSatisfied = true;
                  break;
                }
              }
              else if (element.equals(itemTokens[1])) // Single value match
              {
                logger.debug("We have a single value match: stringValue " + element + " = itemTokens[1] = " + itemTokens[1]);
                oneSatisfied = true;
                break;
              }
            }
            satisfiesQuery = oneSatisfied;
          }
        }
      }
      else
      { // added fix: If the value is null (the requested field did not appear in the data)
        satisfiesQuery = false;
      }
      ++index; // Try to pick up the boolean operators
      if (index < (queryTokens.length - 1))
      {
        if (queryTokens[index].equals("AND")) // Do nothing and keep going
        {
          if (!satisfiesQuery)
          {
            break;
          }
          ++index;
          item = queryTokens[index];
        }
        else if (queryTokens[index].equals("OR")) // Assume all OR's occur after all AND's
        {
          if (satisfiesQuery && (index != 1)) // if we passed the query and it is not the first term
          {
            break;
          }
          else
          {
            ++index;
            item = queryTokens[index];
            satisfiesQuery = true; // reset so that we pick up matches for the next term
          }
        }
        else if (!satisfiesQuery)
        {
          logger.debug("Does not satisfy the query and no boolean ops next...");
          break;
        }
      }
    }

    return satisfiesQuery;
  }

  @SuppressWarnings("unchecked")
  public static boolean checkRecordWritableArrayWritable(String uriQuery, MapWritable doc, DataSchema dataSchema)
  {
    boolean satisfiesQuery = true;

    logger.debug("uriQuery = " + uriQuery);
    uriQuery = uriQuery.substring(3); // strip the beginning query tag '?q='
    logger.debug("uriQuery = " + uriQuery);

    if (uriQuery.equals("*"))
    {
      return true;
    }

    String[] queryTokens = uriQuery.split("\\+(?=AND)|\\+(?=OR)|\\+(?=[a-z])"); // booleans of the form +AND+, +OR+, don't split on +T0+
    int index = 0;
    String item;
    while (index < queryTokens.length)
    {
      boolean ignoreCase = false;

      item = queryTokens[index];
      logger.debug("item = " + item);

      String[] itemTokens = item.split(":", 2); // There are two components <field>:<query>
      logger.debug("itemTokens[0] = " + itemTokens[0] + " itemTokens[1] = " + itemTokens[1]);

      // check for ignore case flag
      if (itemTokens[0].endsWith("@"))
      {
        ignoreCase = true;
        logger.debug("ignore case = true");
        itemTokens[0] = itemTokens[0].replaceAll("@", ""); // strip flag
        logger.debug("itemTokens[0]:" + itemTokens[0]);
      }

      Object value = doc.get(new Text(itemTokens[0]));
      if (value != null) // if the field is not present, a null Writable is returned
      {

        if (itemTokens[1].startsWith("[")) // Inclusive range query
        {
          if (value instanceof Text)
          {
            if (!checkRangeQuery(true, itemTokens[0], itemTokens[1], value.toString(), dataSchema))
            {
              logger.debug("checkRangeQuery returned false");
              satisfiesQuery = false;
            }
          }
          else if (value instanceof WritableArrayWritable)
          {
            String[] elements = ((WritableArrayWritable) value).toStrings();
            boolean oneSatisfied = false;
            for (String element : elements)
            {
              if (checkRangeQuery(true, itemTokens[0], itemTokens[1], element, dataSchema))
              {
                logger.debug("checkRangeQuery returned true");
                oneSatisfied = true;
                break;
              }
            }
            satisfiesQuery = oneSatisfied;
          }
        }
        else if (itemTokens[1].startsWith("{")) // Exclusive range query
        {
          if (value instanceof Text)
          {
            if (!checkRangeQuery(false, itemTokens[0], itemTokens[1], value.toString(), dataSchema))
            {
              logger.debug("checkRangeQuery returned false");
              satisfiesQuery = false;
            }
          }
          else if (value instanceof WritableArrayWritable)
          {
            String[] elements = ((WritableArrayWritable) value).toStrings();
            boolean oneSatisfied = false;
            for (String element : elements)
            {
              if (checkRangeQuery(false, itemTokens[0], itemTokens[1], element, dataSchema))
              {
                logger.debug("checkRangeQuery returned true");
                oneSatisfied = true;
                break;
              }
            }
            satisfiesQuery = oneSatisfied;
          }
        }
        else
        // Not a range query
        {
          if (value instanceof Text)
          {
            String valueString = value.toString();
            if (ignoreCase)
            { // Case insensitivity
              logger.debug("not a range query; itemstoken1:" + itemTokens[1]);
              itemTokens[1] = itemTokens[1].toLowerCase();
              valueString = valueString.toLowerCase();
              logger.debug("valuestring after:" + valueString);
            }

            if (itemTokens[1].contains("*") || itemTokens[1].contains("?")) // Wildcard match
            {
              logger.debug("itemTokens[1] = " + itemTokens[1] + " contains wildcard");
              if (!Pattern.matches(wildcardToRegex(itemTokens[1]), valueString))
              {
                logger.debug("stringValue = " + valueString + " did not satisfy itemTokens[1] = " + itemTokens[1]);
                satisfiesQuery = false;
              }
              logger.debug("stringValue = " + valueString + " did satisfy itemTokens[1] = " + itemTokens[1]);
            }
            else if (!(valueString).equals(itemTokens[1])) // Single value match
            {
              logger.debug("We do not have a single value match: stringValue " + valueString + " != itemTokens[1] = " + itemTokens[1]);
              satisfiesQuery = false;
            }
          }
          else if (value instanceof WritableArrayWritable)
          {
            String[] elements = ((WritableArrayWritable) value).toStrings();
            logger.debug("elements.size() = " + elements.length);

            boolean oneSatisfied = false;
            for (String element : elements)
            {
              if (ignoreCase)
              { // Case insensitivity
                itemTokens[1] = itemTokens[1].toLowerCase();
                logger.debug("waw: itemtoken1 after:" + itemTokens[1]);
                element = element.toLowerCase();
                logger.debug("element after:" + element);
              }

              logger.debug("element: " + element);
              if (itemTokens[1].contains("*") || itemTokens[1].contains("?")) // Wildcard match
              {
                logger.debug("itemTokens[1] = " + itemTokens[1] + " contains wildcard");
                if (Pattern.matches(wildcardToRegex(itemTokens[1]), element))
                {
                  logger.debug("stringValue = " + element + " satisfied itemTokens[1] = " + itemTokens[1]);
                  oneSatisfied = true;
                  break;
                }
              }
              else if (element.equals(itemTokens[1])) // Single value match
              {
                logger.debug("We have a single value match: stringValue " + element + " = itemTokens[1] = " + itemTokens[1]);
                oneSatisfied = true;
                break;
              }
            }
            satisfiesQuery = oneSatisfied;
          }
        }
      }
      else
      {
        satisfiesQuery = false; // add fix - account for case if query field does not exist
      }

      ++index; // Try to pick up the boolean operators
      if (index < (queryTokens.length - 1))
      {
        if (queryTokens[index].equals("AND")) // Do nothing and keep going
        {
          if (!satisfiesQuery)
          {
            break;
          }
          ++index;
          item = queryTokens[index];
        }
        else if (queryTokens[index].equals("OR")) // Assume all OR's occur after all AND's
        {
          if (satisfiesQuery) // if we passed the query and it is not the first term
          {
            break;
          }
          else
          {
            ++index;
            item = queryTokens[index];
            satisfiesQuery = true; // reset so that we pick up matches for the next term
          }
        }
        else if (!satisfiesQuery)
        {
          logger.debug("Does not satisfy the query and no boolean ops next...");
          break;
        }
      }
    }

    return satisfiesQuery;
  }

  /**
   * Method to handle ranges queries
   * 
   */
  public static boolean checkRangeQuery(boolean inclusive, String field, String query, String value, DataSchema dataSchema)
  {
    boolean matches = true;

    logger.info("inclusive = " + inclusive + " field = " + field + " query = " + query + " value = " + value);

    // Strip the brackets or braces to obtain query form <lower>+TO+<upper>
    if (inclusive)
    {
      query = query.replaceFirst("\\[", "");
      query = query.replaceFirst("\\]", "");
    }
    else
    {
      query = query.replaceFirst("\\{", "");
      query = query.replaceFirst("\\}", "");
    }
    logger.debug("query = " + query);

    // Special case for IPs
    if (dataSchema.getPartitionerTypeName(field).equals(IPDataPartitioner.class.getName())) // Doesn't handle arrays of IPs in the value right now...
    {
      logger.debug("Have IP Field");

      String[] ranges = query.split("\\+TO\\+");
      logger.info("ranges[0] = " + ranges[0] + " ranges[1] = " + ranges[1]);

      if ((!inclusive) && (value.equals(ranges[0]) || value.equals(ranges[1])))
      {
        logger.debug("inclusive = false and either value.equals(ranges[0]) or value.equals(ranges[1])");
        matches = false;
      }
      else
      {
        String[] blocksLower = ranges[0].split("\\.");
        String[] blocksUpper = ranges[1].split("\\.");
        String[] ipValue = value.split("\\.");
        int ipBlock = 0;
        while (ipBlock < 4)
        {
          logger.info("ipBlock = " + ipBlock + " ipValue[ipBlock] = " + ipValue[ipBlock] + " blocksLower[ipBlock] = " + blocksLower[ipBlock]
              + " blocksUpper[ipBlock] = " + blocksUpper[ipBlock]);

          if (blocksLower[ipBlock].equals(blocksUpper[ipBlock]))
          {
            logger.info("blocksLower[ipBlock].equals(blocksUpper[ipBlock])");
            if (!ipValue[ipBlock].equals(blocksLower[ipBlock]))
            {
              logger.info("!ipValue[ipBlock].equals(blocksLower[ipBlock]");
              matches = false;
            }
          }
          else
          {
            if (!((Integer.parseInt(blocksLower[ipBlock]) <= Integer.parseInt(ipValue[ipBlock]))
                && (Integer.parseInt(ipValue[ipBlock]) <= Integer.parseInt(blocksUpper[ipBlock]))))
            {
              logger.info("IP block not within given range");
              matches = false;
            }
          }
          ++ipBlock;
        }
      }
    }
    else if (field.equals("date"))// Special case for ISO8601 dates & Epoch Dates
    {
      String[] ranges = query.split("\\+TO\\+");
      logger.info("query:" + query);
      logger.info("value:" + value);
      logger.info("ranges[0] = " + ranges[0] + " ranges[1] = " + ranges[1]);

      // code to parse epoch time: VacantArmy
      if ((EpochDateParser.isEpochDateFormat(ranges[0]) || EpochDateParser.isEpochDateSearchFormat(ranges[0]))
          && (EpochDateParser.isEpochDateFormat(ranges[1]) || EpochDateParser.isEpochDateSearchFormat(ranges[1])))
      {
        double fromDate = 0;
        double toDate = 0;
        double valueDate = 0;

        long fromSeconds = 0;
        long fromMilli = 0;
        long toSeconds = 0;
        long toMilli = 0;

        try
        {

          fromDate = EpochDateParser.convertSearchDate(ranges[0]);
          toDate = EpochDateParser.convertSearchDate(ranges[1]);
          valueDate = Double.parseDouble(value);

          logger.debug("fromDate:" + fromDate);
          logger.debug("toDate:" + toDate);
          logger.debug("valueDate:" + valueDate);

          // split up seconds & milliseconds...keep? needed??
          String[] fromDateArr = ranges[0].split("\\.");
          fromSeconds = Integer.parseInt(fromDateArr[0]);
          fromMilli = Integer.parseInt(fromDateArr[1]);

          String[] toDateArr = ranges[1].split("\\.");
          toSeconds = Integer.parseInt(toDateArr[0]);
          toMilli = Integer.parseInt(toDateArr[1]);
        } catch (Exception e)
        {
          logger.info(Arrays.toString(e.getStackTrace()));
        }

        if ((!inclusive) && (fromDate == valueDate || toDate == valueDate))
        {
          logger.debug("(inclusive == false) && (fromDate == valueDate || toDate == valueDate))");
          matches = false;
        }
        else
        {
          if (!((fromDate <= valueDate) && (valueDate <= toDate)))
          {
            logger.debug("valueDate = " + valueDate + " out of range: <" + fromDate + "," + toDate + ">");
            matches = false;
          }
        }
      }
      else
      { // Special case for ISO8061 dates
        long lower = 0;
        long upper = 0;
        long valueDate = 0;
        try
        {
          lower = ISO8601DateParser.getLongDate(ranges[0]);
          upper = ISO8601DateParser.getLongDate(ranges[1]);
          valueDate = ISO8601DateParser.getLongDate(value);
        } catch (ParseException e)
        {
          e.printStackTrace();
        }
        if ((!inclusive) && (lower == valueDate || upper == valueDate))
        {
          logger.debug("(inclusive == false) && (lower == valueDate || upper == valueDate))");
          matches = false;
        }
        else
        {
          if (!((lower <= valueDate) && (valueDate <= upper)))
          {
            logger.debug("valueDate = " + valueDate + " out of range: <" + lower + "," + upper + ">");
            matches = false;
          }
        }
        logger.debug("valueDate  = " + valueDate + " in range: <" + lower + "," + upper + ">");

      }
    }
    else
    // Int
    {

      String[] ranges = query.split("\\+TO\\+");

      // check for ints
      // if (ranges[0].matches("\\d+") && ranges[1].matches("\\d+")){ //int range
      int lower = Integer.parseInt(ranges[0]);
      int upper = Integer.parseInt(ranges[1]);
      int valueInt = Integer.parseInt(value);
      logger.debug("valueInt = " + valueInt + " lower = " + lower + " upper = " + upper);

      if ((!inclusive) && (lower == valueInt || upper == valueInt))
      {
        logger.debug("(inclusive == false) && (lower == valueInt || upper == valueInt))");
        matches = false;
      }
      else
      {
        if (!((lower <= valueInt) && (valueInt <= upper)))
        {
          logger.debug("valueInt = " + valueInt + " out of range: <" + lower + "," + upper + ">");
          matches = false;
        }
      }
      logger.debug("valueInt = " + valueInt + " in range: <" + lower + "," + upper + ">");
    }

    return matches;
  }

  /**
   * Method to convert a URI wildcard query into a java regex
   * 
   */
  public static String wildcardToRegex(String wildcard)
  {
    StringBuilder s = new StringBuilder(wildcard.length());
    for (int i = 0, is = wildcard.length(); i < is; i++)
    {
      char c = wildcard.charAt(i);
      switch (c)
      {
        case '*':
          s.append(".*");
          break;
        case '?':
          s.append(".");
          break;
        // escape special regexp-characters
        case '(':
        case ')':
        case '[':
        case ']':
        case '$':
        case '^':
        case '.':
        case '{':
        case '}':
        case '|':
        case '\\':
          s.append("\\");
          s.append(c);
          break;
        default:
          s.append(c);
          break;
      }
    }
    logger.debug("regex = " + s.toString());

    return (s.toString());
  }
}