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

#ifndef IOTDB_SESSION_C_H
#define IOTDB_SESSION_C_H

#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>

#ifdef __cplusplus
extern "C" {
#endif

/* ============================================================
 *  Error Handling
 * ============================================================ */

typedef int64_t TsStatus;

#define TS_OK                   0
#define TS_ERR_CONNECTION      -1
#define TS_ERR_EXECUTION       -2
#define TS_ERR_INVALID_PARAM   -3
#define TS_ERR_NULL_PTR        -4
#define TS_ERR_UNKNOWN         -99

/**
 * Returns the error message from the last failed C API call on the current thread.
 * The returned pointer is valid until the next C API call on the same thread.
 */
const char* ts_get_last_error(void);

/* ============================================================
 *  Opaque Handle Types
 * ============================================================ */

typedef struct CSession_        CSession;
typedef struct CTableSession_   CTableSession;
typedef struct CTablet_         CTablet;
typedef struct CSessionDataSet_ CSessionDataSet;
typedef struct CRowRecord_      CRowRecord;

/* ============================================================
 *  Enums  (values match C++ TSDataType / TSEncoding / CompressionType)
 * ============================================================ */

typedef enum {
    TS_TYPE_BOOLEAN   = 0,
    TS_TYPE_INT32     = 1,
    TS_TYPE_INT64     = 2,
    TS_TYPE_FLOAT     = 3,
    TS_TYPE_DOUBLE    = 4,
    TS_TYPE_TEXT      = 5,
    TS_TYPE_TIMESTAMP = 8,
    TS_TYPE_DATE      = 9,
    TS_TYPE_BLOB      = 10,
    TS_TYPE_STRING    = 11,
    /** Not a server type; used for invalid arguments / error paths in the C API. */
    TS_TYPE_INVALID   = 255
} TSDataType_C;

typedef enum {
    TS_ENCODING_PLAIN      = 0,
    TS_ENCODING_DICTIONARY = 1,
    TS_ENCODING_RLE        = 2,
    TS_ENCODING_DIFF       = 3,
    TS_ENCODING_TS_2DIFF   = 4,
    TS_ENCODING_BITMAP     = 5,
    TS_ENCODING_GORILLA_V1 = 6,
    TS_ENCODING_REGULAR    = 7,
    TS_ENCODING_GORILLA    = 8,
    TS_ENCODING_ZIGZAG     = 9,
    TS_ENCODING_FREQ       = 10
} TSEncoding_C;

typedef enum {
    TS_COMPRESSION_UNCOMPRESSED = 0,
    TS_COMPRESSION_SNAPPY       = 1,
    TS_COMPRESSION_GZIP         = 2,
    TS_COMPRESSION_LZO          = 3,
    TS_COMPRESSION_SDT          = 4,
    TS_COMPRESSION_PAA          = 5,
    TS_COMPRESSION_PLA          = 6,
    TS_COMPRESSION_LZ4          = 7,
    TS_COMPRESSION_ZSTD         = 8,
    TS_COMPRESSION_LZMA2        = 9
} TSCompressionType_C;

typedef enum {
    TS_COL_TAG       = 0,
    TS_COL_FIELD     = 1,
    TS_COL_ATTRIBUTE = 2
} TSColumnCategory_C;

/* ============================================================
 *  Session Lifecycle  —  Tree Model
 * ============================================================ */

CSession* ts_session_new(const char* host, int rpcPort,
                          const char* username, const char* password);

CSession* ts_session_new_with_zone(const char* host, int rpcPort,
                                    const char* username, const char* password,
                                    const char* zoneId, int fetchSize);

CSession* ts_session_new_multi_node(const char* const* nodeUrls, int urlCount,
                                     const char* username, const char* password);

void ts_session_destroy(CSession* session);

TsStatus ts_session_open(CSession* session);

TsStatus ts_session_open_with_compression(CSession* session, bool enableRPCCompression);

TsStatus ts_session_close(CSession* session);

/* ============================================================
 *  Session Lifecycle  —  Table Model
 * ============================================================ */

CTableSession* ts_table_session_new(const char* host, int rpcPort,
                                     const char* username, const char* password,
                                     const char* database);

CTableSession* ts_table_session_new_multi_node(const char* const* nodeUrls, int urlCount,
                                                const char* username, const char* password,
                                                const char* database);

void ts_table_session_destroy(CTableSession* session);

TsStatus ts_table_session_open(CTableSession* session);

TsStatus ts_table_session_close(CTableSession* session);

/* ============================================================
 *  Timezone
 * ============================================================ */

TsStatus ts_session_set_timezone(CSession* session, const char* zoneId);

TsStatus ts_session_get_timezone(CSession* session, char* buf, int bufLen);

/* ============================================================
 *  Database Management  (Tree Model)
 * ============================================================ */

TsStatus ts_session_create_database(CSession* session, const char* database);

TsStatus ts_session_delete_database(CSession* session, const char* database);

TsStatus ts_session_delete_databases(CSession* session, const char* const* databases, int count);

/* ============================================================
 *  Timeseries Management  (Tree Model)
 * ============================================================ */

TsStatus ts_session_create_timeseries(CSession* session, const char* path,
                                       TSDataType_C dataType, TSEncoding_C encoding,
                                       TSCompressionType_C compressor);

TsStatus ts_session_create_timeseries_ex(CSession* session, const char* path,
                                          TSDataType_C dataType, TSEncoding_C encoding,
                                          TSCompressionType_C compressor,
                                          int propsCount,
                                          const char* const* propKeys,
                                          const char* const* propValues,
                                          int tagsCount,
                                          const char* const* tagKeys,
                                          const char* const* tagValues,
                                          int attrsCount,
                                          const char* const* attrKeys,
                                          const char* const* attrValues,
                                          const char* measurementAlias);

TsStatus ts_session_create_multi_timeseries(CSession* session, int count,
                                             const char* const* paths,
                                             const TSDataType_C* dataTypes,
                                             const TSEncoding_C* encodings,
                                             const TSCompressionType_C* compressors);

TsStatus ts_session_create_aligned_timeseries(CSession* session, const char* deviceId,
                                               int count,
                                               const char* const* measurements,
                                               const TSDataType_C* dataTypes,
                                               const TSEncoding_C* encodings,
                                               const TSCompressionType_C* compressors);

TsStatus ts_session_check_timeseries_exists(CSession* session, const char* path, bool* exists);

TsStatus ts_session_delete_timeseries(CSession* session, const char* path);

TsStatus ts_session_delete_timeseries_batch(CSession* session, const char* const* paths, int count);

/* ============================================================
 *  Tablet Operations
 * ============================================================ */

CTablet* ts_tablet_new(const char* deviceId, int columnCount,
                        const char* const* columnNames,
                        const TSDataType_C* dataTypes,
                        int maxRowNumber);

CTablet* ts_tablet_new_with_category(const char* deviceId, int columnCount,
                                      const char* const* columnNames,
                                      const TSDataType_C* dataTypes,
                                      const TSColumnCategory_C* columnCategories,
                                      int maxRowNumber);

void ts_tablet_destroy(CTablet* tablet);

void ts_tablet_reset(CTablet* tablet);

int ts_tablet_get_row_count(CTablet* tablet);

TsStatus ts_tablet_set_row_count(CTablet* tablet, int rowCount);

TsStatus ts_tablet_add_timestamp(CTablet* tablet, int rowIndex, int64_t timestamp);

TsStatus ts_tablet_add_value_bool(CTablet* tablet, int colIndex, int rowIndex, bool value);

TsStatus ts_tablet_add_value_int32(CTablet* tablet, int colIndex, int rowIndex, int32_t value);

TsStatus ts_tablet_add_value_int64(CTablet* tablet, int colIndex, int rowIndex, int64_t value);

TsStatus ts_tablet_add_value_float(CTablet* tablet, int colIndex, int rowIndex, float value);

TsStatus ts_tablet_add_value_double(CTablet* tablet, int colIndex, int rowIndex, double value);

TsStatus ts_tablet_add_value_string(CTablet* tablet, int colIndex, int rowIndex, const char* value);

/* ============================================================
 *  Data Insertion  —  Tree Model  (Record)
 * ============================================================ */

TsStatus ts_session_insert_record_str(CSession* session, const char* deviceId,
                                       int64_t time, int count,
                                       const char* const* measurements,
                                       const char* const* values);

TsStatus ts_session_insert_record(CSession* session, const char* deviceId,
                                   int64_t time, int count,
                                   const char* const* measurements,
                                   const TSDataType_C* types,
                                   const void* const* values);

TsStatus ts_session_insert_aligned_record_str(CSession* session, const char* deviceId,
                                               int64_t time, int count,
                                               const char* const* measurements,
                                               const char* const* values);

TsStatus ts_session_insert_aligned_record(CSession* session, const char* deviceId,
                                           int64_t time, int count,
                                           const char* const* measurements,
                                           const TSDataType_C* types,
                                           const void* const* values);

/* Batch insert — multiple devices (string values) */
TsStatus ts_session_insert_records_str(CSession* session, int deviceCount,
                                        const char* const* deviceIds,
                                        const int64_t* times,
                                        const int* measurementCounts,
                                        const char* const* const* measurementsList,
                                        const char* const* const* valuesList);

TsStatus ts_session_insert_aligned_records_str(CSession* session, int deviceCount,
                                                const char* const* deviceIds,
                                                const int64_t* times,
                                                const int* measurementCounts,
                                                const char* const* const* measurementsList,
                                                const char* const* const* valuesList);

/* Batch insert — multiple devices (typed values) */
TsStatus ts_session_insert_records(CSession* session, int deviceCount,
                                    const char* const* deviceIds,
                                    const int64_t* times,
                                    const int* measurementCounts,
                                    const char* const* const* measurementsList,
                                    const TSDataType_C* const* typesList,
                                    const void* const* const* valuesList);

TsStatus ts_session_insert_aligned_records(CSession* session, int deviceCount,
                                            const char* const* deviceIds,
                                            const int64_t* times,
                                            const int* measurementCounts,
                                            const char* const* const* measurementsList,
                                            const TSDataType_C* const* typesList,
                                            const void* const* const* valuesList);

/* Batch insert — single device (typed values) */
TsStatus ts_session_insert_records_of_one_device(CSession* session, const char* deviceId,
                                                  int rowCount, const int64_t* times,
                                                  const int* measurementCounts,
                                                  const char* const* const* measurementsList,
                                                  const TSDataType_C* const* typesList,
                                                  const void* const* const* valuesList,
                                                  bool sorted);

TsStatus ts_session_insert_aligned_records_of_one_device(CSession* session, const char* deviceId,
                                                          int rowCount, const int64_t* times,
                                                          const int* measurementCounts,
                                                          const char* const* const* measurementsList,
                                                          const TSDataType_C* const* typesList,
                                                          const void* const* const* valuesList,
                                                          bool sorted);

/* ============================================================
 *  Data Insertion  —  Tree Model  (Tablet)
 * ============================================================ */

TsStatus ts_session_insert_tablet(CSession* session, CTablet* tablet, bool sorted);

TsStatus ts_session_insert_aligned_tablet(CSession* session, CTablet* tablet, bool sorted);

TsStatus ts_session_insert_tablets(CSession* session, int tabletCount,
                                    const char* const* deviceIds,
                                    CTablet** tablets, bool sorted);

TsStatus ts_session_insert_aligned_tablets(CSession* session, int tabletCount,
                                            const char* const* deviceIds,
                                            CTablet** tablets, bool sorted);

/* ============================================================
 *  Data Insertion  —  Table Model  (Tablet)
 * ============================================================ */

TsStatus ts_table_session_insert(CTableSession* session, CTablet* tablet);

/* ============================================================
 *  Query  —  Tree Model
 * ============================================================ */

TsStatus ts_session_execute_query(CSession* session, const char* sql,
                                   CSessionDataSet** dataSet);

TsStatus ts_session_execute_query_with_timeout(CSession* session, const char* sql,
                                                int64_t timeoutInMs,
                                                CSessionDataSet** dataSet);

TsStatus ts_session_execute_non_query(CSession* session, const char* sql);

TsStatus ts_session_execute_raw_data_query(CSession* session,
                                            int pathCount, const char* const* paths,
                                            int64_t startTime, int64_t endTime,
                                            CSessionDataSet** dataSet);

TsStatus ts_session_execute_last_data_query(CSession* session,
                                             int pathCount, const char* const* paths,
                                             CSessionDataSet** dataSet);

TsStatus ts_session_execute_last_data_query_with_time(CSession* session,
                                                       int pathCount, const char* const* paths,
                                                       int64_t lastTime,
                                                       CSessionDataSet** dataSet);

/* ============================================================
 *  Query  —  Table Model
 * ============================================================ */

TsStatus ts_table_session_execute_query(CTableSession* session, const char* sql,
                                         CSessionDataSet** dataSet);

TsStatus ts_table_session_execute_query_with_timeout(CTableSession* session, const char* sql,
                                                      int64_t timeoutInMs,
                                                      CSessionDataSet** dataSet);

TsStatus ts_table_session_execute_non_query(CTableSession* session, const char* sql);

/* ============================================================
 *  SessionDataSet & RowRecord  —  Result Iteration
 * ============================================================ */

void ts_dataset_destroy(CSessionDataSet* dataSet);

/** On failure (null handle, exception), see ts_get_last_error(). */
bool ts_dataset_has_next(CSessionDataSet* dataSet);

/** On failure (null handle, exception), see ts_get_last_error(); nullptr may also mean end of rows. */
CRowRecord* ts_dataset_next(CSessionDataSet* dataSet);

int ts_dataset_get_column_count(CSessionDataSet* dataSet);

const char* ts_dataset_get_column_name(CSessionDataSet* dataSet, int index);

const char* ts_dataset_get_column_type(CSessionDataSet* dataSet, int index);

void ts_dataset_set_fetch_size(CSessionDataSet* dataSet, int fetchSize);

void ts_row_record_destroy(CRowRecord* record);

int64_t ts_row_record_get_timestamp(CRowRecord* record);

int ts_row_record_get_field_count(CRowRecord* record);

bool ts_row_record_is_null(CRowRecord* record, int index);

bool ts_row_record_get_bool(CRowRecord* record, int index);

int32_t ts_row_record_get_int32(CRowRecord* record, int index);

int64_t ts_row_record_get_int64(CRowRecord* record, int index);

float ts_row_record_get_float(CRowRecord* record, int index);

double ts_row_record_get_double(CRowRecord* record, int index);

const char* ts_row_record_get_string(CRowRecord* record, int index);

/** Returns TS_TYPE_INVALID if record is null or index is out of range. */
TSDataType_C ts_row_record_get_data_type(CRowRecord* record, int index);

/* ============================================================
 *  Data Deletion  (Tree Model)
 * ============================================================ */

TsStatus ts_session_delete_data(CSession* session, const char* path, int64_t endTime);

TsStatus ts_session_delete_data_batch(CSession* session, int pathCount,
                                       const char* const* paths, int64_t endTime);

TsStatus ts_session_delete_data_range(CSession* session, int pathCount,
                                       const char* const* paths,
                                       int64_t startTime, int64_t endTime);

#ifdef __cplusplus
}  /* extern "C" */
#endif

#endif /* IOTDB_SESSION_C_H */