/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
 * or http://forgerock.org/license/CDDLv1.0.html.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at legal-notices/CDDLv1_0.txt.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information:
 *      Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 *
 *      Copyright 2009 Sun Microsystems, Inc.
 *      Portions Copyright 2011-2014 ForgeRock AS
 */
package org.opends.server.schema;

import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.GregorianCalendar;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.TimeZone;

import org.forgerock.i18n.LocalizableMessage;
import org.forgerock.i18n.slf4j.LocalizedLogger;
import org.forgerock.opendj.config.server.ConfigException;
import org.forgerock.opendj.ldap.Assertion;
import org.forgerock.opendj.ldap.ByteSequence;
import org.forgerock.opendj.ldap.ByteString;
import org.forgerock.opendj.ldap.ByteStringBuilder;
import org.forgerock.opendj.ldap.ConditionResult;
import org.forgerock.opendj.ldap.DecodeException;
import org.forgerock.opendj.ldap.schema.Schema;
import org.forgerock.opendj.ldap.spi.IndexQueryFactory;
import org.forgerock.opendj.ldap.spi.IndexingOptions;
import org.opends.server.admin.std.server.MatchingRuleCfg;
import org.opends.server.api.AbstractMatchingRule;
import org.opends.server.api.ExtensibleIndexer;
import org.opends.server.api.ExtensibleMatchingRule;
import org.opends.server.api.MatchingRule;
import org.opends.server.api.MatchingRuleFactory;
import org.opends.server.api.OrderingMatchingRule;
import org.opends.server.core.DirectoryServer;
import org.opends.server.types.DirectoryException;
import org.opends.server.types.InitializationException;
import org.opends.server.util.StaticUtils;

import static org.opends.messages.SchemaMessages.*;
import static org.opends.server.schema.GeneralizedTimeSyntax.*;
import static org.opends.server.schema.SchemaConstants.*;
import static org.opends.server.util.ServerConstants.*;
import static org.opends.server.util.StaticUtils.*;
import static org.opends.server.util.TimeThread.*;

/**
 * This class acts as a factory for time-based matching rules.
 */
public final class TimeBasedMatchingRuleFactory
        extends MatchingRuleFactory<MatchingRuleCfg>
{

  private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass();

  /** Greater-than RelativeTimeMatchingRule. */
  private MatchingRule greaterThanRTMRule;

  /** Less-than RelativeTimeMatchingRule. */
  private MatchingRule lessThanRTMRule;

  /** PartialDayAndTimeMatchingRule. */
  private MatchingRule partialDTMatchingRule;

  /** A Collection of matching rules managed by this factory. */
  private Set<MatchingRule> matchingRules;

  private static final TimeZone TIME_ZONE_UTC_OBJ =
      TimeZone.getTimeZone(TIME_ZONE_UTC);


  /** Constants for generating keys. */
  private static final char SECOND = 's';
  private static final char MINUTE = 'm';
  private static final char HOUR = 'h';
  private static final char MONTH = 'M';
  private static final char DATE = 'D';
  private static final char YEAR = 'Y';


  /** {@inheritDoc} */
  @Override
  public void initializeMatchingRule(MatchingRuleCfg configuration)
          throws ConfigException, InitializationException
  {
    matchingRules = new HashSet<MatchingRule>();
    greaterThanRTMRule = new RelativeTimeGTOrderingMatchingRule();
    matchingRules.add(greaterThanRTMRule);
    lessThanRTMRule = new RelativeTimeLTOrderingMatchingRule();
    matchingRules.add(lessThanRTMRule);
    partialDTMatchingRule = new PartialDateAndTimeMatchingRule();
    matchingRules.add(partialDTMatchingRule);
  }



  /** {@inheritDoc} */
  @Override
  public Collection<MatchingRule> getMatchingRules()
  {
    return Collections.unmodifiableCollection(matchingRules);
  }



  /**
   * This class defines a matching rule which is used for time-based searches.
   */
  private  abstract class TimeBasedMatchingRule extends AbstractMatchingRule
          implements ExtensibleMatchingRule
  {
    /** {@inheritDoc} */
    @Override
    public String getDescription()
    {
      //There is no standard definition.
      return null;
    }



    /** {@inheritDoc} */
    @Override
    public String getSyntaxOID()
    {
       return SYNTAX_GENERALIZED_TIME_OID;
    }



    /** {@inheritDoc} */
    @Override
    public ByteString normalizeAttributeValue(ByteSequence value)
            throws DecodeException
    {
      try
      {
        long timestamp = decodeGeneralizedTimeValue(value);
        return ByteString.valueOf(timestamp);
      }
      catch (DirectoryException de)
      {
        switch (DirectoryServer.getSyntaxEnforcementPolicy())
        {
          case REJECT:
            throw DecodeException.error(de.getMessageObject(), de);

          case WARN:
            logger.error(de.getMessageObject());
            break;
        }
        return value.toByteString();
      }
    }
  }



 /**
  * This class defines a matching rule which matches  the relative time for
  * time-based searches.
  */
  private abstract class RelativeTimeOrderingMatchingRule
          extends TimeBasedMatchingRule
          implements OrderingMatchingRule
  {
    /**
     * The serial version identifier required to satisfy the compiler because
     * this class implements the <CODE>java.io.Serializable</CODE> interface.
     * This value was generated using the <CODE>serialver</CODE> command-line
     * utility included with the Java SDK.
     */
    private static final long serialVersionUID = -3501812894473163490L;



    /**
     * Indexer associated with this instance.
     */
    protected ExtensibleIndexer indexer;


    /** {@inheritDoc} */
    @Override
    public ByteString normalizeAssertionValue(ByteSequence value)
        throws DecodeException
    {
      /**
      An assertion value may contain one of the following:
      s = second
      m = minute
      h = hour
      d = day
      w = week

      An example assertion is OID:=(-)1d, where a '-' means that the user
      intends to search only the expired events. In this example we are
      searching for an event expired 1 day back.

      Use this method to parse, validate and normalize the assertion value
      into a format to be recognized by the valuesMatch routine. This method
      takes the assertion value, adds/substracts it to/from the current time
      and calculates a time which will be used as a relative time by inherited
       rules.
      */

      int index = 0;
      boolean signed = false;
      byte firstByte = value.byteAt(0);

      if(firstByte == '-')
      {
        //Turn the sign on to go back in past.
        signed = true;
        index = 1;
      }
      else if(firstByte == '+')
      {
        //'+" is not required but we won't reject it either.
        index = 1;
      }

      long second = 0;
      long minute = 0;
      long hour = 0;
      long day = 0;
      long week = 0;

      boolean containsTimeUnit = false;
      int number = 0;

      for(; index<value.length(); index++)
      {
        byte b = value.byteAt(index);
        if(isDigit((char)b))
        {
          number = multiplyByTenThenAddUnits(number, b);
        }
        else
        {
          LocalizableMessage message = null;
          if(containsTimeUnit)
          {
            //We already have time unit found by now.
            message = WARN_ATTR_CONFLICTING_ASSERTION_FORMAT.get(value);
          }
          else
          {
            switch(b)
            {
              case 's':
                second = number;
                break;
              case 'm':
                minute = number;
                break;
              case 'h':
                hour = number;
                break;
              case 'd':
                day = number;
                break;
              case 'w':
                week = number;
                break;
              default:
                message = WARN_ATTR_INVALID_RELATIVE_TIME_ASSERTION_FORMAT.get(value, (char) b);
            }
          }
          if(message !=null)
          {
            //Log the message and throw an exception.
            logger.error(message);
            throw DecodeException.error(message);
          }
          containsTimeUnit = true;
          number = 0;
        }
      }

      if(!containsTimeUnit)
      {
        //There was no time unit so assume it is seconds.
        second = number;
      }

      long delta = (second + minute*60 +  hour*3600 + day*24*3600 +
              week*7*24*3600)*1000 ;
      long now = getTime();
      return ByteString.valueOf(signed ? now - delta : now + delta);
    }



    /** {@inheritDoc} */
    @Override
    public int compareValues(ByteSequence value1, ByteSequence value2)
    {
      return value1.compareTo(value2);
    }



    /** {@inheritDoc} */
    @Override
    public int compare(byte[] arg0, byte[] arg1)
    {
      return StaticUtils.compare(arg0, arg1);
    }



    /** {@inheritDoc} */
    @Override
    public Collection<ExtensibleIndexer> getIndexers()
    {
      if(indexer == null)
      {
        indexer = new RelativeTimeExtensibleIndexer(this);
      }
      return Collections.singletonList(indexer);
    }
  }



 /**
  * This class defines a matching rule which calculates the "greater-than"
  * relative time for time-based searches.
  */
  private final class RelativeTimeGTOrderingMatchingRule
          extends RelativeTimeOrderingMatchingRule
  {
    /** All the names for this matching rule. */
    private final List<String> names;



    /**
     * The serial version identifier required to satisfy the compiler because
     * this class implements the <CODE>java.io.Serializable</CODE> interface.
     * This value was generated using the <CODE>serialver</CODE> command-line
     * utility included with the Java SDK.
     */
     private static final long serialVersionUID = 7247241496402474136L;


    RelativeTimeGTOrderingMatchingRule()
    {
      names = new ArrayList<String>();
      names.add(EXT_OMR_RELATIVE_TIME_GT_NAME);
      names.add(EXT_OMR_RELATIVE_TIME_GT_ALT_NAME);
    }


    /** {@inheritDoc} */
    @Override
    public Collection<String> getNames()
    {
      return Collections.unmodifiableList(names);
    }



    /** {@inheritDoc} */
    @Override
    public String getOID()
    {
      return EXT_OMR_RELATIVE_TIME_GT_OID;
    }



    /** {@inheritDoc} */
    @Override
    public ConditionResult valuesMatch(ByteSequence attributeValue,
        ByteSequence assertionValue)
    {
      int ret = compareValues(attributeValue, assertionValue);
      return ConditionResult.valueOf(ret > 0);
    }

    /** {@inheritDoc} */
    @Override
    public Assertion getAssertion(final ByteSequence value)
        throws DecodeException
    {
      final ByteString assertionValue = normalizeAssertionValue(value);
      return new Assertion()
      {
        @Override
        public ConditionResult matches(ByteSequence attributeValue)
        {
          return valuesMatch(attributeValue, assertionValue);
        }

        @Override
        public <T> T createIndexQuery(IndexQueryFactory<T> factory)
            throws DecodeException
        {
          return factory.createRangeMatchQuery(indexer.getExtensibleIndexID(),
              assertionValue, ByteString.empty(), false, false);
        }
      };
    }


    /** {@inheritDoc} */
    @Override
    public <T> T createIndexQuery(ByteSequence assertionValue,
        IndexQueryFactory<T> factory) throws DecodeException
    {
      return getAssertion(assertionValue).createIndexQuery(factory);
    }
  }



  /**
  * This class defines a matching rule which calculates the "less-than"
  * relative time for time-based searches.
  */
  private final class RelativeTimeLTOrderingMatchingRule
          extends RelativeTimeOrderingMatchingRule
  {
    /** All the names for this matching rule. */
    private final List<String> names;



    /**
     * The serial version identifier required to satisfy the compiler because
     * this class implements the <CODE>java.io.Serializable</CODE> interface.
     * This value was generated using the <CODE>serialver</CODE> command-line
     * utility included with the Java SDK.
     */
   private static final long serialVersionUID = -5122459830973558441L;



    RelativeTimeLTOrderingMatchingRule()
    {
      names = new ArrayList<String>();
      names.add(EXT_OMR_RELATIVE_TIME_LT_NAME);
      names.add(EXT_OMR_RELATIVE_TIME_LT_ALT_NAME);
    }


    /** {@inheritDoc} */
    @Override
    public Collection<String> getNames()
    {
      return Collections.unmodifiableList(names);
    }



    /** {@inheritDoc} */
    @Override
    public String getOID()
    {
      return EXT_OMR_RELATIVE_TIME_LT_OID;
    }



    /** {@inheritDoc} */
    @Override
    public ConditionResult valuesMatch(ByteSequence attributeValue,
        ByteSequence assertionValue)
    {
      int ret = compareValues(attributeValue, assertionValue);
      return ConditionResult.valueOf(ret < 0);
    }

    /** {@inheritDoc} */
    @Override
    public Assertion getAssertion(final ByteSequence value)
        throws DecodeException
    {
      final ByteString assertionValue = normalizeAssertionValue(value);
      return new Assertion()
      {
        @Override
        public ConditionResult matches(ByteSequence attributeValue)
        {
          return valuesMatch(attributeValue, assertionValue);
        }

        @Override
        public <T> T createIndexQuery(IndexQueryFactory<T> factory)
            throws DecodeException
        {
          return factory.createRangeMatchQuery(indexer.getExtensibleIndexID(),
              ByteString.empty(), assertionValue, false, false);
        }
      };
    }

    /** {@inheritDoc} */
    @Override
    public <T> T createIndexQuery(ByteSequence assertionValue,
        IndexQueryFactory<T> factory) throws DecodeException
    {
      return getAssertion(assertionValue).createIndexQuery(factory);
    }
  }



  /**
   * Extensible Indexer class for Relative Time Matching rules which share
   * the same index. This Indexer is shared by both greater than and less than
   * Relative Time Matching Rules.
   */
  private final class RelativeTimeExtensibleIndexer extends
      ExtensibleIndexer
  {

    /**
     * The Extensible Matching Rule.
     */
    private final RelativeTimeOrderingMatchingRule matchingRule;



    /**
     * Creates a new instance of RelativeTimeExtensibleIndexer.
     *
     * @param matchingRule The relative time Matching Rule.
     */
    private RelativeTimeExtensibleIndexer(
        RelativeTimeOrderingMatchingRule matchingRule)
    {
      this.matchingRule = matchingRule;
    }



    /** {@inheritDoc} */
    @Override
    public String getExtensibleIndexID()
    {
      return EXTENSIBLE_INDEXER_ID_DEFAULT;
    }



    /** {@inheritDoc} */
    @Override
    public final void createKeys(Schema schema, ByteSequence value2,
        IndexingOptions options, Collection<ByteString> keys)
        throws DecodeException
    {
      keys.add(matchingRule.normalizeAttributeValue(value2));
    }

    /** {@inheritDoc} */
    @Override
    public String getIndexID()
    {
      return RELATIVE_TIME_INDEX_NAME + "." + getExtensibleIndexID();
    }
  }



  /**
   * This class performs the partial date and time matching capabilities.
   */
  private final class PartialDateAndTimeMatchingRule
          extends TimeBasedMatchingRule
  {
    /**
     * Indexer associated with this instance.
     */
    private ExtensibleIndexer indexer;



    /** {@inheritDoc} */
    @Override
    public String getOID()
    {
      return EXT_PARTIAL_DATE_TIME_OID;
    }



    /** {@inheritDoc} */
    @Override
    public Collection<String> getNames()
    {
      return Collections.singleton(EXT_PARTIAL_DATE_TIME_NAME);
    }



    /** {@inheritDoc} */
    @Override
    public ByteString normalizeAssertionValue(ByteSequence value)
        throws DecodeException
    {
     /**
      An assertion value may contain one or all of the following:
      D = day
      M = month
      Y = year
      h = hour
      m = month
      s = second

      An example assertion is OID:=04M. In this example we are
      searching for entries corresponding to month of april.

      Use this method to parse, validate and normalize the assertion value
      into a format to be recognized by the compare routine. The normalized
      value is actually the format of : smhDMY.
      */
      final int initDate = 0;
      final int initVal = -1;
      int second = initVal;
      int minute = initVal;
      int hour = initVal;
      int date = initDate;
      int month = initVal;
      int year = initDate;
      int number = 0;

      int length = value.length();
      for(int index=0; index<length; index++)
      {
        byte b = value.byteAt(index);
        if(isDigit((char)b))
        {
          number = multiplyByTenThenAddUnits(number, b);
        }
        else
        {
          LocalizableMessage message = null;
          switch(b)
          {
            case 's':
              if (second != initVal)
              {
                 message = WARN_ATTR_DUPLICATE_SECOND_ASSERTION_FORMAT.get(value, date);
              }
              else
              {
                second = number;
              }
              break;
            case 'm':
              if (minute != initVal)
              {
                 message = WARN_ATTR_DUPLICATE_MINUTE_ASSERTION_FORMAT.get(value, date);
              }
              else
              {
                minute = number;
              }
              break;
            case 'h':
              if (hour != initVal)
              {
                 message = WARN_ATTR_DUPLICATE_HOUR_ASSERTION_FORMAT.get(value, date);
              }
              else
              {
                hour = number;
              }
              break;
            case 'D':
              if(number == 0)
              {
                message = WARN_ATTR_INVALID_DATE_ASSERTION_FORMAT.get(value, number);
              }
            else if (date != initDate)
              {
                message = WARN_ATTR_DUPLICATE_DATE_ASSERTION_FORMAT.get(value, date);
              }
              else
              {
                date = number;
              }
              break;
            case 'M':
              if (number == 0)
              {
                message = WARN_ATTR_INVALID_MONTH_ASSERTION_FORMAT.get(value, number);
              }
              else if (month != initVal)
              {
                message = WARN_ATTR_DUPLICATE_MONTH_ASSERTION_FORMAT.get(value, month);
              }
              else
              {
                month = number;
              }
              break;
            case 'Y':
              if(number == 0)
              {
                message = WARN_ATTR_INVALID_YEAR_ASSERTION_FORMAT.get(value, number);
              }
              else if (year != initDate)
              {
                message = WARN_ATTR_DUPLICATE_YEAR_ASSERTION_FORMAT.get(value, year);
              }
              else
              {
                year = number;
              }
              break;
            default:
              message = WARN_ATTR_INVALID_PARTIAL_TIME_ASSERTION_FORMAT.get(value, (char) b);
          }
          if(message !=null)
          {
            logger.error(message);
            throw DecodeException.error(message);
          }
          number = 0;
        }
      }

      month = toCalendarMonth(month, value);

      //Validate year, month , date , hour, minute and second in that order.
      // -1 values are allowed when these values have not been provided
      if (year < 0)
      {
        //A future date is allowed.
        logAndThrow(WARN_ATTR_INVALID_YEAR_ASSERTION_FORMAT.get(value, year));
      }
      if (isDateInvalid(date, month, year))
      {
        logAndThrow(WARN_ATTR_INVALID_DATE_ASSERTION_FORMAT.get(value, date));
      }
      if (hour < initVal || hour > 23)
      {
        logAndThrow(WARN_ATTR_INVALID_HOUR_ASSERTION_FORMAT.get(value, hour));
      }
      if (minute < initVal || minute > 59)
      {
        logAndThrow(WARN_ATTR_INVALID_MINUTE_ASSERTION_FORMAT.get(value, minute));
      }
      if (second < initVal || second > 60) // Consider leap seconds.
      {
        logAndThrow(WARN_ATTR_INVALID_SECOND_ASSERTION_FORMAT.get(value, second));
      }

      // Since we reached here we have a valid assertion value.
      // Construct a normalized value in the order: SECOND MINUTE HOUR  DATE MONTH YEAR.
      ByteBuffer bb = ByteBuffer.allocate(6*4);
      bb.putInt(second);
      bb.putInt(minute);
      bb.putInt(hour);
      bb.putInt(date);
      bb.putInt(month);
      bb.putInt(year);
      return ByteString.wrap(bb.array());
    }

    private void logAndThrow(LocalizableMessage message) throws DecodeException
    {
      logger.warn(message);
      throw DecodeException.error(message);
    }

    private boolean isDateInvalid(int date, int month, int year)
    {
      switch (date)
      {
      case 29:
        return month == Calendar.FEBRUARY && !isLeapYear(year);
      case 30:
        return month == Calendar.FEBRUARY;
      case 31:
        return month != -1 && month != Calendar.JANUARY
            && month != Calendar.MARCH && month != Calendar.MAY
            && month != Calendar.JULY && month != Calendar.AUGUST
            && month != Calendar.OCTOBER && month != Calendar.DECEMBER;
      default:
        return date < 0 || date > 31;
      }
    }

    private boolean isLeapYear(int year)
    {
      if (year % 400 == 0)
      {
        return true;
      }
      if (year % 100 == 0)
      {
        return false;
      }
      return year % 4 == 0;
    }

    private int toCalendarMonth(int month, ByteSequence value) throws DecodeException
    {
      switch (month)
      {
      case -1:
        // just allow this.
        return -1;
      case 1:
        return Calendar.JANUARY;
      case 2:
        return Calendar.FEBRUARY;
      case 3:
        return Calendar.MARCH;
      case 4:
        return Calendar.APRIL;
      case 5:
        return Calendar.MAY;
      case 6:
        return Calendar.JUNE;
      case 7:
        return Calendar.JULY;
      case 8:
        return Calendar.AUGUST;
      case 9:
        return Calendar.SEPTEMBER;
      case 10:
        return Calendar.OCTOBER;
      case 11:
        return Calendar.NOVEMBER;
      case 12:
        return Calendar.DECEMBER;
      default:
        LocalizableMessage message = WARN_ATTR_INVALID_MONTH_ASSERTION_FORMAT.get(value, month);
        logger.warn(message);
        throw DecodeException.error(message);
      }
    }

    /** {@inheritDoc} */
    @Override
    public ConditionResult valuesMatch(ByteSequence attributeValue,
        ByteSequence assertionValue)
    {
      // Build the information from the attribute value.
      GregorianCalendar cal = new GregorianCalendar(TIME_ZONE_UTC_OBJ);
      cal.setLenient(false);
      cal.setTimeInMillis(((ByteString) attributeValue).toLong());
      int second = cal.get(Calendar.SECOND);
      int minute = cal.get(Calendar.MINUTE);
      int hour = cal.get(Calendar.HOUR_OF_DAY);
      int date = cal.get(Calendar.DATE);
      int month = cal.get(Calendar.MONTH);
      int year = cal.get(Calendar.YEAR);

      //Build the information from the assertion value.
      ByteBuffer bb = ByteBuffer.wrap(assertionValue.toByteArray());
      int assertSecond = bb.getInt(0);
      int assertMinute = bb.getInt(4);
      int assertHour = bb.getInt(8);
      int assertDate = bb.getInt(12);
      int assertMonth = bb.getInt(16);
      int assertYear = bb.getInt(20);

      // All the non-zero and non -1 values should match.
      if ((assertSecond != -1 && assertSecond != second)
          || (assertMinute != -1 && assertMinute != minute)
          || (assertHour != -1 && assertHour != hour)
          || (assertDate != 0 && assertDate != date)
          || (assertMonth != -1 && assertMonth != month)
          || (assertYear != 0 && assertYear != year))
      {
        return ConditionResult.FALSE;
      }
     return ConditionResult.TRUE;
    }



    /** {@inheritDoc} */
    @Override
    public Collection<ExtensibleIndexer> getIndexers()
    {
      if(indexer == null)
      {
        indexer = new PartialDateAndTimeExtensibleIndexer(this);
      }
      return Collections.singletonList(indexer);
    }



    /** {@inheritDoc} */
    @Override
    public <T> T createIndexQuery(ByteSequence assertionValue,
            IndexQueryFactory<T> factory) throws DecodeException
    {
      //Build the information from the assertion value.
      byte[] arr = normalizeAssertionValue(assertionValue).toByteArray();
      ByteBuffer bb = ByteBuffer.wrap(arr);

      int assertSecond = bb.getInt(0);
      int assertMinute = bb.getInt(4);
      int assertHour = bb.getInt(8);
      int assertDate = bb.getInt(12);
      int assertMonth = bb.getInt(16);
      int assertYear = bb.getInt(20);

      List<T> queries = new ArrayList<T>();
      if(assertSecond >= 0)
      {
        queries.add(createExactMatchQuery(factory, assertSecond, SECOND));
      }
      if(assertMinute >=0)
      {
        queries.add(createExactMatchQuery(factory, assertMinute, MINUTE));
      }
      if(assertHour >=0)
      {
        queries.add(createExactMatchQuery(factory, assertHour, HOUR));
      }
      if(assertDate >0)
      {
        queries.add(createExactMatchQuery(factory, assertDate, DATE));
      }
      if(assertMonth >=0)
      {
        queries.add(createExactMatchQuery(factory, assertMonth, MONTH));
      }
      if(assertYear > 0)
      {
        queries.add(createExactMatchQuery(factory, assertYear, YEAR));
      }
      return factory.createIntersectionQuery(queries);
    }

    private <T> T createExactMatchQuery(IndexQueryFactory<T> factory,
        int assertionValue, char type)
    {
      return factory.createExactMatchQuery(
          indexer.getExtensibleIndexID(), getKey(assertionValue, type));
    }


    /**
     * Decomposes an attribute value into a set of partial date and time index
     * keys.
     *
     * @param attValue
     *          The normalized attribute value
     * @param set
     *          A set into which the keys will be inserted.
     */
    private void timeKeys(ByteSequence attributeValue, Collection<ByteString> keys)
    {
      long timeInMS = 0L;
      try
      {
        timeInMS = decodeGeneralizedTimeValue(attributeValue);
      }
      catch(DirectoryException de)
      {
        //If the schema check is on this should never reach here. If not then we
        //would return from here.
        return;
      }
      //Build the information from the attribute value.
      GregorianCalendar cal = new GregorianCalendar(TIME_ZONE_UTC_OBJ);
      cal.setTimeInMillis(timeInMS);
      addKeyIfNotZero(keys, cal, Calendar.SECOND, SECOND);
      addKeyIfNotZero(keys, cal, Calendar.MINUTE, MINUTE);
      addKeyIfNotZero(keys, cal, Calendar.HOUR_OF_DAY, HOUR);
      addKeyIfNotZero(keys, cal, Calendar.DATE, DATE);
      addKeyIfNotZero(keys, cal, Calendar.MONTH, MONTH);
      addKeyIfNotZero(keys, cal, Calendar.YEAR, YEAR);
    }

    private void addKeyIfNotZero(Collection<ByteString> keys,
        GregorianCalendar cal, int calField, char type)
    {
      int value = cal.get(calField);
      if (value >= 0)
      {
        keys.add(getKey(value, type));
      }
    }

    private ByteString getKey(int value, char type)
    {
      ByteStringBuilder builder = new ByteStringBuilder();
      builder.append(type);
      builder.append(value);
      return builder.toByteString();
    }
  }

  private int multiplyByTenThenAddUnits(int number, byte b)
  {
    switch (b)
    {
    case '0':
      return number * 10;
    case '1':
      return number * 10 + 1;
    case '2':
      return number * 10 + 2;
    case '3':
      return number * 10 + 3;
    case '4':
      return number * 10 + 4;
    case '5':
      return number * 10 + 5;
    case '6':
      return number * 10 + 6;
    case '7':
      return number * 10 + 7;
    case '8':
      return number * 10 + 8;
    case '9':
      return number * 10 + 9;
    }
    return number;
  }


   /**
   * Extensible Indexer class for Partial Date and Time Matching rules.
   */
  private final class PartialDateAndTimeExtensibleIndexer extends
      ExtensibleIndexer
  {
    /** The partial date and Time matching Rule. */
    private final PartialDateAndTimeMatchingRule matchingRule;



    /**
     * Creates a new instance of PartialDateAndTimeExtensibleIndexer.
     *
     * @param matchingRule
     *          The PartialDateAndTime Rule.
     */
    private PartialDateAndTimeExtensibleIndexer(
        PartialDateAndTimeMatchingRule matchingRule)
    {
      this.matchingRule = matchingRule;
    }



    /** {@inheritDoc} */
    @Override
    public void createKeys(Schema schema, ByteSequence value,
        IndexingOptions options, Collection<ByteString> keys)
    {
      matchingRule.timeKeys(value, keys);
    }

    /** {@inheritDoc} */
    @Override
    public String getIndexID()
    {
      return PARTIAL_DATE_TIME_INDEX_NAME + "." + getExtensibleIndexID();
    }



    /** {@inheritDoc} */
    @Override
    public String getExtensibleIndexID()
    {
      return EXTENSIBLE_INDEXER_ID_DEFAULT;
    }
  }
}