/**
 * 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.
 */

/**
 * Cassandra client interface
 */
@namespace("org.apache.cassandra.avro")

protocol Cassandra {
    record ColumnPath {
        string column_family;
        union { bytes, null } super_column;
        union { bytes, null } column;
    }

    record ColumnParent {
        string column_family;
        union { bytes, null } super_column;
    }

    record Column {
        bytes name;
        bytes value;
        long timestamp;
        union { int, null } ttl;
    }

    record SuperColumn {
        bytes name;
        array<Column> columns;
    }

    record ColumnOrSuperColumn {
        union { Column, null } column;
        union { SuperColumn, null } super_column;
    }

    record SliceRange {
        bytes start;
        bytes finish;
        boolean reversed;
        int count;
        union { array<bytes>, null } bitmasks;
    }

    record SlicePredicate {
        union { array<bytes>, null } column_names;
        union { SliceRange, null } slice_range;
    }

	record TokenRange {
		string start_token;
		string end_token;
		array<string> endpoints;
	}

    enum IndexOperator {
        EQ, GTE, GT, LTE, LT
    }

    record IndexExpression {
        bytes column_name;
        IndexOperator op;
        bytes value;
    }

    record IndexClause {
        array<IndexExpression> expressions;
        bytes start_key;
        int count;
    }

    /**
     * The semantics of start keys and tokens are slightly different.
     * Keys are start-inclusive; tokens are start-exclusive.  Token
     * ranges may also wrap -- that is, the end token may be less
     * than the start one.  Thus, a range from keyX to keyX is a
     * one-element range, but a range from tokenY to tokenY is the
     * full ring.
     */
    record KeyRange {
        union { bytes, null } start_key;
        union { bytes, null } end_key;
        union { string, null } start_token;
        union { string, null } end_token;
        int count;
    }

    record KeySlice {
        bytes key;
        array<ColumnOrSuperColumn> columns;
    }

    record Deletion {
        long timestamp;
        union { bytes, null } super_column;
        union { SlicePredicate, null } predicate;
    }

    record Mutation {
        union { ColumnOrSuperColumn, null } column_or_supercolumn;
        union { Deletion, null } deletion;
    }

    @aliases(["org.apache.cassandra.config.avro.IndexType"])
    enum IndexType {
        KEYS
    }

    /* describes a column in a column family. */
    @aliases(["org.apache.cassandra.config.avro.ColumnDef"])
    record ColumnDef {
        bytes name;
        string validation_class;
        union { IndexType, null } index_type;
        union { string, null } index_name;
    }

    /**
     * describes a keyspace:
     * NB: the id field is ignored during column family creation: the server will choose an appropriate value.
     */
    @aliases(["org.apache.cassandra.config.avro.CfDef"])
    record CfDef {
        string keyspace;
        string name;
        union { string, null } column_type;
        union { string, null } comparator_type;
        union { string, null } subcomparator_type;
        union { string, null } comment;
        union { double, null } row_cache_size;
        union { double, null } key_cache_size;
        union { double, null } read_repair_chance;
        union { int, null } gc_grace_seconds;
        union { null, string } default_validation_class = null;
        union { null, int } min_compaction_threshold = null;
        union { null, int } max_compaction_threshold = null;
        union { int, null } row_cache_save_period_in_seconds = 0;
        union { int, null } key_cache_save_period_in_seconds = 3600;
        union { int, null } memtable_flush_after_mins = 60;
        union { null, int } memtable_throughput_in_mb = null;
        union { null, double} memtable_operations_in_millions = null;
        union { int, null } id;
        union { array<ColumnDef>, null } column_metadata;
    }

    /* describes a keyspace. */
    @aliases(["org.apache.cassandra.config.avro.KsDef"])
    record KsDef {
        string name;
        string strategy_class;
        union{ map<string>, null } strategy_options;
        int replication_factor;
        array<CfDef> cf_defs;
    }
    
    record StreamingMutation {
        bytes key;
        Mutation mutation;
    }

    record MutationsMapEntry {
        bytes key;
        map<array<Mutation>> mutations;
    }

    record CoscsMapEntry {
         bytes key;
         array<ColumnOrSuperColumn> columns;
    }

    record KeyCountMapEntry {
        bytes key;
        int count;
    }
    
    record AuthenticationRequest {
         map<string> credentials;
    }

    enum ConsistencyLevel {
        ONE, QUORUM, LOCAL_QUORUM, EACH_QUORUM, ALL
    }

    error InvalidRequestException {
        union { string, null } why;
    }

    error NotFoundException {
        union { string, null } why;
    }

    error UnavailableException {
        union { string, null } why;
    }

    error TimedOutException {
        union { string, null } why;
    }

    error AuthenticationException {
        union { string, null } why;
    }

    error AuthorizationException {
        union { string, null } why;
    }

    void login (AuthenticationRequest auth_request)
    throws AuthenticationException, AuthorizationException;

    void set_keyspace(string keyspace) throws InvalidRequestException;

    ColumnOrSuperColumn get(bytes key,
                            ColumnPath column_path,
                            ConsistencyLevel consistency_level)
    throws InvalidRequestException, NotFoundException, UnavailableException,
           TimedOutException;
    
    /**
     * Get the group of columns contained by a column_parent (either a
     * ColumnFamily name or a ColumnFamily/SuperColumn name pair) specified
     * by the given SlicePredicate. If no matching values are found, an empty
     * list is returned.
     */
    array<ColumnOrSuperColumn> get_slice(bytes key,
                                         ColumnParent column_parent,
                                         SlicePredicate predicate,
                                         ConsistencyLevel consistency_level)
    throws InvalidRequestException, UnavailableException, TimedOutException;

    /**
     * Performs a get_slice for column_parent and predicate against the given
     * set of keys in parallel.
     */
    array<CoscsMapEntry> multiget_slice(array<bytes> keys,
                                        ColumnParent column_parent,
                                        SlicePredicate predicate,
                                        ConsistencyLevel consistency_level)
    throws InvalidRequestException, UnavailableException, TimedOutException;

    /**
     * Performs a get_count in parallel on the given list of keys. The
     * return value maps keys to the count found.
     */ 
    array<KeyCountMapEntry> multiget_count(array<bytes> keys,
                                           ColumnParent column_parent,
                                           SlicePredicate predicate,
                                           ConsistencyLevel consistency_level)
    throws InvalidRequestException, UnavailableException, TimedOutException;

    /** 
     * Returns the subset of columns specified in SlicePredicate for 
     * the rows matching the IndexClause.
     */
    array<KeySlice> get_indexed_slices(ColumnParent column_parent,
                                      IndexClause index_clause,
                                      SlicePredicate column_predicate,
                                      ConsistencyLevel consistency_level)
    throws InvalidRequestException, UnavailableException, TimedOutException;

    /**
     * Returns the number of columns matching a predicate for a particular
     * key, ColumnFamily, and optionally SuperColumn.
     */
    int get_count(bytes key,
                  ColumnParent column_parent,
                  SlicePredicate predicate,
                  ConsistencyLevel consistency_level)
    throws InvalidRequestException, UnavailableException, TimedOutException;

    void insert(bytes key,
                ColumnParent column_parent,
                Column column,
                ConsistencyLevel consistency_level)
    throws InvalidRequestException, UnavailableException, TimedOutException;
    
    void remove(bytes key,
                ColumnPath column_path,
                long timestamp,
                ConsistencyLevel consistency_level)
    throws InvalidRequestException, UnavailableException, TimedOutException;

    void batch_mutate(array<MutationsMapEntry> mutation_map,
                      ConsistencyLevel consistency_level)
    throws InvalidRequestException, UnavailableException, TimedOutException;

    /**
     * Truncate will mark and entire column family as deleted. From the user's
     * perspective a successful call to truncate will result in complete data
     * deletion from column family. Internally, however, disk space will not be
     * immediately released, as with all deletes in Cassandra, this one only
     * marks the data as deleted. The operation succeeds only if all hosts in
     * the cluster at available and will throw an UnavailableException if some
     * hosts are down.
     */
    void truncate(string column_family)
    throws InvalidRequestException, UnavailableException;

    /** 
     * Ask the cluster if they all are using the same migration id. Returns a
     * map of version->hosts-on-that-version. Hosts that did not respond will
     * be under the key DatabaseDescriptor.INITIAL_VERSION. Agreement can be
     * determined by checking if the size of the map is 1. 
     */
    map<array<string>> check_schema_agreement()
    throws InvalidRequestException;

    string system_add_column_family(CfDef cf_def)
    throws InvalidRequestException;

    string system_add_keyspace(KsDef ks_def) throws InvalidRequestException;
    
    string system_drop_column_family(string column_family)
    throws InvalidRequestException;
    
    string system_drop_keyspace(string keyspace)
    throws InvalidRequestException;
    
    string system_update_column_family(CfDef cf_def)
    throws InvalidRequestException;
    
    string system_update_keyspace(KsDef ks_def)
    throws InvalidRequestException;

    array<string> describe_keyspaces();
    
    KsDef describe_keyspace(string keyspace) throws NotFoundException;

    string describe_cluster_name();

    string describe_version();

    string describe_partitioner();

    /**
     * experimental API for hadoop/parallel query support.
     * may change violently and without warning.
     *
     * returns list of token strings such that first subrange is (list[0], list[1]],
     * next is (list[1], list[2]], etc.
     */
    array<string> describe_splits(string cfName,
                                  string start_token,
                                  string end_token,
                                  int keys_per_split);
    
    /** 
     * Get the token ring: a map of ranges to host addresses, represented as
     * an array of TokenRange->start-end range and list of host addresses.
     */
    array<TokenRange> describe_ring(string keyspace)
    throws InvalidRequestException;

    /**
     *returns a subset of columns for a contiguous range of keys.
     */
    array<KeySlice> get_range_slices(ColumnParent column_parent,
                                     SlicePredicate predicate,
                                     KeyRange range,
                                     ConsistencyLevel consistency_level)
    throws InvalidRequestException, UnavailableException, TimedOutException;
}