package org.apache.kafka.streams.state;

public final class VersionedRecord<V> {

    	/**
     * Create a new {@link VersionedRecord} instance. {@code value} cannot be {@code null}.
     *
     * @param value      the value
     * @param timestamp  the timestamp
     * @param validTo  the validTo timestamp
     */
     public VersionedRecord(final V value, final long timestamp,) final{
 long validTo);


    /**
  this.value =  * Returns the {@code validTo} 
     */
Objects.requireNonNull(value);
        this.timestamp = timestamp;
      public long this.validTo = Optional.empty();
}

Optional<Long> validTo();
}

package org.apache.kafka.streams.query;  

/**
 * Interactive query for retrieving a set of records with the same specified key and different timestamps within the specified time range.
 */
@Evolving
public final class MultiVersionedKeyQuery<K, V> implements Query<ValueIterator<VersionedRecord<V>>> {

  private final K key;
  private final Optional<Instant> fromTimestamp;
  private final Optional<Instant> asOfTimestamp;
  private final boolean isAscending;

  private MultiVersionedKeyQuery(
      final K key,
      Optional<Instant> fromTimestamp,
      Optional<Instant> asOfTimestamp,
      boolean isAscending) {
    this.key = Objects.requireNonNull(key);
    this.fromTimestamp = fromTimestamp;
    this.asOfTimestamp = asOfTimestamp;
    this.isAscending = isAscending;
  }

  /**
   * Creates a query that will retrieve the set of records identified by {@code key} if any exists
   * (or {@code null} otherwise).
   * @param key The key to retrieve
   * @throws NullPointerException if @param key is null           
   * @param <K> The type of the key
   * @param <V> The type of the value that will be retrieved
   */
  public static <K, V> MultiVersionedKeyQuery<K, V> withKey(final K key);

  /**
   * Specifies the starting time point for the key query.
   * <pre>
   * The key query returns all the records that are still existing in the time range starting from the timestamp {@code fromTimestamp}. There can be records which have been inserted before the {@code fromTimestamp} 
   * and are valid in the query specified time range (the whole time range or even partially). The key query in fact returns all the records that have NOT became tombstone at or after {@code fromTimestamp}.  
   * </pre>   No ordering is guaranteed for the results, but the results can be sorted by timestamp (in ascending or descending order) by calling the corresponding defined methods.
 *
 *  @param <K> The type of the key.
 *  @param <V> The type of the result returned by this query.
 */

@Evolving
public final class MultiVersionedKeyQuery<K, V> implements Query<VersionedRecordIterator<V>> {

  private final K key;
  private final Optional<Instant> fromTime;
  private final Optional<Instant> toTime;
  private final ResultOrder order;

  private MultiVersionedKeyQuery(
      final K key,
      final Optional<Instant> fromTime,
      final Optional<Instant> toTime,
      final ResultOrder order) {
    this.key = Objects.requireNonNull(key);
    this.fromTime = fromTime;
    this.toTime = toTime;
    this.order = order;
  }     


  /**
   * Creates a query that will retrieve the set of records identified by {@code key} if any exists
   * (or {@code null} otherwise).
   *
   * <p>
   * While the query by default returns the all the record versions of the specified {@code key}, setting
   * the {@code fromTimestamp} (by calling the {@link #fromTime(Instant)} method), and the {@code toTimestamp}
   * (by calling the {@link #toTime(Instant)} method) makes the query to return the record versions associated 
   * to the specified time range.
   *
   * @param key The specified key by the query
   * @param <K> The type of the key
   * @param fromTimestamp<V> The startingtype time pointof the value that will be retrieved
   * @throws NullPointerException if @param fromTimestampkey is null  
   */   

  public static <K, V> MultiVersionedKeyQuery<K, V> fromwithKey(Instantfinal K fromTimestampkey);

  /**
   * Specifies the endingstarting time point for the key query.
   * <p>
   * The key query returns all the records that haveare timestampstill <=existing {@code asOfTimestamp}.
   * @param asOfTimestamp The ending time pointin the time range starting from the timestamp {@code fromTime}. There can
   * @throwsbe NullPointerExceptionrecords ifwhich @paramhave asOfTimestampbeen isinserted nullbefore the 
{@code fromTime} and */
are still publicvalid MultiVersionedKeyQuery<K,in V>the asOf(Instant asOfTimestamp);

  /**query specified time range (the whole time range
   * Specifies the order of the returned records by the query as descending by timestamp. or even partially). The key query in fact returns all the records that have NOT become tombstone at or after {@code fromTime}.  
   */
  public MultiVersionedKeyQuery<K, V> withDescendingTimestamps();

  /** * @param fromTime The starting time point
   * TheIf key{@code thatfromTime} wasis specifiednull, forwill thisbe query.
considered as negative */
  public K key();

  /**infinity, ie, no lower bound
   */
   * The starting time point of the query, if specified
   */
  public Optional<Instant> fromTimestamp(public MultiVersionedKeyQuery<K, V> fromTime(final Instant fromTime);

  /**
   * Specifies Thethe ending time point offor the key query, if specified.
   */
 The publickey query Optional<Instant> asOfTimestamp();

  /**returns all the records that have timestamp <= toTime.
   * 
   * @return@param truetoTime ifThe theending querytime returnspoint
 records in ascending* orderIf of@param timestamps
toTime is null, */
will be publicconsidered booleanas isAscending ();
}

positive infinity, ie, no upper bound
   */
  public MultiVersionedKeyQuery<K, V> toTime(final Instant toTime);

  /**
   * Specifies the order of the returned records by the query as descending by timestamp.
   */
  public MultiVersionedKeyQuery<K, V> withDescendingTimestamps();

  /**
   * Specifies the order of the returned records by the query as ascending by timestamp.
   */
  public MultiVersionedKeyQuery<K, V> withAscendingTimestamps();

   /**
   * The key that was specified for this query.
   * The specified {@code key} of the query.
   */
  public K key();

  /**
   * The starting time point of the query, if specified
   * @return The specified {@code fromTime} of the query. 
   */
  public Optional<Instant> fromTime();

  /**
   * The ending time point of the query, if specified
   * @return The specified {@code toTime} of the query. 
   */
  public Optional<Instant> toTime();      

 /**
  * The order of the returned records by timestamp.
  * @return UNORDERED, ASCENDING, or DESCENDING if the query returns records in an unordered, ascending, or descending order of timestamps.
  */
  public ResultOrder resultOrder(); 
}