package org.apache.kafka.streams.query;


/**
 * Interactive query for retrieving a set of records with keys within a specified key range and time
 * range.
 */

@Evolving
public final class VersionedRangeQuery<KMultiVersionedRangeQuery<K, V> implements
    Query<KeyValueIterator<K, VersionedRecord<V>>> {

  private final Optional<K> lower;
  private final Optional<K> upper;
  private final Optional<Instant> fromTimestampfromTime;

  private final Optional<Instant> asOfTimestamptoTime;

  private finalMultiVersionedRangeQuery(
  boolean isKeyAscending;
  private final booleanOptional<K> isTimeAscending;lower,
  private  final boolean isOrderedByKey;

  private VersionedRangeQuery(
      final Optional<K> lowerupper,
      final Optional<K>Optional<Instant> upperfromTime,
      final Optional<Instant> fromTimestamp,toTime) {
    this.lower  final Optional<Instant> asOfTimestamp,= lower;
    this.upper  final boolean isOrderedByKey,= upper;
    this.fromTime = finalfromTime;
 boolean isKeyAscending,
  this.toTime = toTime;
  }

 final boolean isTimeAscending)/** {
    this.lower = lower;
    this.upper = upper;
    this.fromTimestamp = fromTimestamp;
    this.asOfTimestamp = asOfTimestamp;
    this.isOrderedByKey = isOrderedByKey;
    this.isKeyAscending = isKeyAscending;
    this.isTimeAscending = isTimeAscending;
  }

  /**
   * Interactive range query using a lower and upper bound to filter the keys returned. * For each
   * key the records valid within the specified time range are returned. * In case the time range is
   * not specified just the latest record for each key is returned.* Interactive range query using a lower and upper bound to filter the keys returned. * For each 
   * key the records valid within the specified time range are returned. * In case the time range is 
   * not specified just the latest record for each key is returned. 
   * @param lower The key that specifies the lower bound of the range 
   * @param upper The key that specifies the upper bound of the range 
   * @param <K> The key type 
   * @param lower<V> The keyvalue thattype specifies
 the lower bound of the range */ 
   *public @param upper The key that specifies the upper bound of the rangestatic <K, V> MultiVersionedRangeQuery<K, V> withKeyRange(final K lower, final K upper);


   /**
   * @paramInteractive <K>range query using Thea keylower type
bound to filter *the @paramkeys <V>returned. * For Theeach valuekey typethe
   */
  public static <K, V> VersionedRangeQuery<K, V> withRange(final K lower, final K upper);

  /** records valid within the specified time range are returned. * In case the time range is not
   * Interactivespecified rangejust querythe usinglatest arecord lowerfor boundeach tokey filteris thereturned.
 keys returned. * @param Forlower eachThe key the
that specifies the *lower recordsbound valid withinof the specified time range
 are returned. * In@param case<K> the time rangeThe iskey nottype
   * specified@param just<V> the latest recordThe forvalue eachtype
 key is returned.*/
  public *static @param<K, lowerV> TheMultiVersionedRangeQuery<K, keyV> that specifies thewithLowerKeyBound(final K lower);

 bound of the range /**
   * @paramInteractive <K>range query using Thea keylower type
bound to filter *the @paramkeys <V>returned. * For Theeach valuekey typethe
   */
 records publicvalid staticwithin <K,the V>specified VersionedRangeQuery<K,time V>range withLowerBound(final K lower);

  /**
   * Interactive range query using a lower bound to filter the keys returned. * Forare returned. * In case the time range is not
   * specified just the latest record for each key theis returned.
   * records valid within @param upper The key that specifies the specified timelower bound of the range
 are returned. * In@param case<K> the time rangeThe iskey nottype
   * specified@param just<V> the latest recordThe forvalue eachtype
 key is returned.*/
  public *static @param<K, upperV> TheMultiVersionedRangeQuery<K, keyV> thatwithUpperKeyBound(final specifies the lower bound of the range
   * @param <K>   The key type
   * @param <V>   The value typeK upper);

  /**
   * Interactive scan query that returns all records in the store. * For each key the records valid
   */
 within publicthe staticspecified <K,time V>range VersionedRangeQuery<K,are V> withUpperBound(final K upper);

  /**
   * Interactive scan query that returns all records in the store. * Forreturned. * In case the time range is not specified just
   * the latest record for each key the records validis returned.
   * @param within<K> theThe specifiedkey timetype
 range are returned. * In@param case<V> theThe time range is not specified justvalue type
   */
  public *static the<K, latestV> recordMultiVersionedRangeQuery<K, for each key is returned.V> allKeys();

  /**
   * @paramSpecifies <K>the Thestarting keytime type
point for the *key @paramquery. <V>The Therange valuequery type
returns all the */records
  public static* <K,that V>are VersionedRangeQuery<K,valid V> withNoBounds();

  /**
   * Specifiesin the time range starting from the startingtimestamp time point for the key query.{@code fromTime}.
   * @param fromTime The rangestarting querytime returnspoint
 all the records*/
  public *MultiVersionedRangeQuery<K, thatV> are valid in the time range starting from the timestamp {@code fromTimestampfromTime(Instant fromTime);

  /**
   * Specifies the ending time point for the key query. The range query returns all the records that
   * have timestamp <= {@code toTime}.
   * @param fromTimestamptoTime The startingending time point
   */
  public VersionedRangeQuery<KMultiVersionedRangeQuery<K, V> fromtoTime(Instant fromTimestamptoTime);

  /**
   * SpecifiesThe thelower endingbound timeof pointthe forquery, theif keyspecified.
 query. The range*/
 query returnspublic all the records thatOptional<K> lowerKeyBound();

  /**
   * have timestamp <= {@code asOfTimestamp}.The upper bound of the query, if specified
   * @param asOfTimestamp/
  public Optional<K> upperKeyBound();

  /**
   * The endingstarting time point of the query, if specified
   */
  public VersionedRangeQuery<K, V> asOf(Instant asOfTimestampOptional<Instant> fromTime();

  /**
   * SpecifiesThe theending startingtime andpoint ending points of the range query, as MIN and MAX respectively.if specified
   */
 Therefore, thepublic query returns all the existing records in the state store with keys within the
   * specified key range.
   * @throws RuntimeException if {@code fromTimestamp} or {@code asOfTimestamp} have been already
   *       Optional<Instant> toTime();

}

// example 1: MultiVersionedRangeQuery without specifying any time bound will be interpreted as all versions
final MultiVersionedRangeQuery<Integer, Integer> query1 =
        MultiVersionedRangeQuery.withKeyRange(1, 2);
final StateQueryRequest<KeyValueIterator<Integer, VersionedRecord<Integer>>> request1 =
        inStore("my_store").withQuery(query1);
 
final StateQueryResult<KeyValueIterator<Integer, VersionedRecord<Integer>>> versionedRangeResult1 = kafkaStreams.query(request1);
 
// Get the results from all partitions.
final Map<Integer, QueryResult<KeyValueIterator<Integer, VersionedRecord<Integer>>>> partitionResults = versionedRangeResult.getPartitionResults();
for (final Entry<Integer, QueryResult<KeyValueIterator<Integer, VersionedRecord<Integer>>>> entry : partitionResults.entrySet()) {
    try (final KeyValueIterator<Integer, VersionedRecord<Integer>> iterator = entry.getValue().getResult()) {
        while (iterator.hasNext()) {
          final KeyValue<Integer, VersionedRecord<Integer>> record = iterator.next();
          Integer key = record.key;
      specified.
   */
   publicInteger VersionedRangeQuery<K,value V> allVersions= record.value.value();

  /**
   * Specifies the overall order ofLong returnedtimestamp records by timestamp
   */
  public VersionedRangeQuery<K, V> orderByTimestamp= record.value.timestamp();
		  Long validTo = record.value.validTo();

	   /**
   * Specifies the order of keys as descending.
   */
  public VersionedRangeQuery<K, V> withDescendingKeys();

  /**    
   * Specifies the order of the timestamps as descending.
   */
  public VersionedRangeQuery<K, V> withDescendingTimestamps();

  /**
   * The lower bound of the query, if specified.
   */
  public Optional<K> getLowerKeyBound();

  /**
   * The upper bound of the query, if specified
   */
  public Optional<K> getUpperKeyBound();

  /**
   * The starting time point of the query, if specified
   */
  public Optional<Instant> getFromTimestamp();

  /**
   * The ending time point of the query, if specified
   */
  public Optional<Instant> getAsOfTimestamp();

  /**
   * @return true if the query orders the returned records by key 
   */
  public boolean isOrderedByKey();

  /**
   * @return true if the query returns records in ascending order of keys
   */
  public boolean isKeyAscending();

  /**
   * @return true if the query returns records in ascending order of timestamps
   */
  public boolean isRangeAscending();

}