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

#include "SessionC.h"
#include "Session.h"
#include "TableSession.h"
#include "TableSessionBuilder.h"
#include "SessionBuilder.h"
#include "SessionDataSet.h"

#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <memory>

/* ============================================================
 *  Internal wrapper structs — the opaque handles point to these
 * ============================================================ */

struct CSession_ {
    std::shared_ptr<Session> cpp;
};

struct CTableSession_ {
    std::shared_ptr<TableSession> cpp;
};

struct CTablet_ {
    Tablet cpp;
};

struct CSessionDataSet_ {
    std::unique_ptr<SessionDataSet> cpp;
};

struct CRowRecord_ {
    std::shared_ptr<RowRecord> cpp;
};

/* ============================================================
 *  Thread-local error message buffer
 * ============================================================ */

static thread_local std::string g_lastError;

static void clearError() {
    g_lastError.clear();
}

static TsStatus setError(TsStatus code, const std::string& msg) {
    g_lastError = msg;
    return code;
}

static TsStatus setError(TsStatus code, const std::exception& e) {
    g_lastError = e.what();
    return code;
}

static TsStatus handleException(const std::exception& e) {
#if defined(_CPPRTTI) || defined(__GXX_RTTI)
    // Try to classify exception type (requires RTTI enabled).
    if (dynamic_cast<const IoTDBConnectionException*>(&e)) {
        return setError(TS_ERR_CONNECTION, e);
    }
    if (dynamic_cast<const ExecutionException*>(&e) ||
        dynamic_cast<const StatementExecutionException*>(&e) ||
        dynamic_cast<const BatchExecutionException*>(&e)) {
        return setError(TS_ERR_EXECUTION, e);
    }
#endif
    return setError(TS_ERR_UNKNOWN, e);
}

extern "C" {

const char* ts_get_last_error(void) {
    return g_lastError.c_str();
}

}  /* extern "C" */

/* ============================================================
 *  Helpers — convert C arrays to C++ vectors
 * ============================================================ */

static std::vector<std::string> toStringVec(const char* const* arr, int count) {
    std::vector<std::string> v;
    v.reserve(count);
    for (int i = 0; i < count; i++) {
        v.emplace_back(arr[i]);
    }
    return v;
}

static std::vector<TSDataType::TSDataType> toTypeVec(const TSDataType_C* arr, int count) {
    std::vector<TSDataType::TSDataType> v;
    v.reserve(count);
    for (int i = 0; i < count; i++) {
        v.push_back(static_cast<TSDataType::TSDataType>(arr[i]));
    }
    return v;
}

static std::vector<TSEncoding::TSEncoding> toEncodingVec(const TSEncoding_C* arr, int count) {
    std::vector<TSEncoding::TSEncoding> v;
    v.reserve(count);
    for (int i = 0; i < count; i++) {
        v.push_back(static_cast<TSEncoding::TSEncoding>(arr[i]));
    }
    return v;
}

static std::vector<CompressionType::CompressionType> toCompressionVec(const TSCompressionType_C* arr, int count) {
    std::vector<CompressionType::CompressionType> v;
    v.reserve(count);
    for (int i = 0; i < count; i++) {
        v.push_back(static_cast<CompressionType::CompressionType>(arr[i]));
    }
    return v;
}

static std::map<std::string, std::string> toStringMap(int count, const char* const* keys, const char* const* values) {
    std::map<std::string, std::string> m;
    for (int i = 0; i < count; i++) {
        m[keys[i]] = values[i];
    }
    return m;
}

/**
 * Convert C typed values (void* const* values, TSDataType_C* types, int count)
 * to C++ vector<char*> that Session expects.
 * The caller must free the returned char* pointers using freeCharPtrVec().
 */
static std::vector<char*> toCharPtrVec(const TSDataType_C* types, const void* const* values, int count) {
    std::vector<char*> result(count);
    for (int i = 0; i < count; i++) {
        switch (types[i]) {
            case TS_TYPE_BOOLEAN: {
                bool* p = new bool(*static_cast<const bool*>(values[i]));
                result[i] = reinterpret_cast<char*>(p);
                break;
            }
            case TS_TYPE_INT32: {
                int32_t* p = new int32_t(*static_cast<const int32_t*>(values[i]));
                result[i] = reinterpret_cast<char*>(p);
                break;
            }
            case TS_TYPE_INT64:
            case TS_TYPE_TIMESTAMP: {
                int64_t* p = new int64_t(*static_cast<const int64_t*>(values[i]));
                result[i] = reinterpret_cast<char*>(p);
                break;
            }
            case TS_TYPE_FLOAT: {
                float* p = new float(*static_cast<const float*>(values[i]));
                result[i] = reinterpret_cast<char*>(p);
                break;
            }
            case TS_TYPE_DOUBLE: {
                double* p = new double(*static_cast<const double*>(values[i]));
                result[i] = reinterpret_cast<char*>(p);
                break;
            }
            case TS_TYPE_TEXT:
            case TS_TYPE_STRING:
            case TS_TYPE_BLOB:
            default: {
                const char* src = static_cast<const char*>(values[i]);
                size_t len = strlen(src) + 1;
                char* p = new char[len];
                memcpy(p, src, len);
                result[i] = p;
                break;
            }
        }
    }
    return result;
}

static void freeCharPtrVec(std::vector<char*>& vec, const TSDataType_C* types, int count) {
    for (int i = 0; i < count; i++) {
        switch (types[i]) {
            case TS_TYPE_BOOLEAN:   delete reinterpret_cast<bool*>(vec[i]); break;
            case TS_TYPE_INT32:     delete reinterpret_cast<int32_t*>(vec[i]); break;
            case TS_TYPE_INT64:
            case TS_TYPE_TIMESTAMP: delete reinterpret_cast<int64_t*>(vec[i]); break;
            case TS_TYPE_FLOAT:     delete reinterpret_cast<float*>(vec[i]); break;
            case TS_TYPE_DOUBLE:    delete reinterpret_cast<double*>(vec[i]); break;
            default:                delete[] vec[i]; break;
        }
    }
}

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

extern "C" {

CSession* ts_session_new(const char* host, int rpcPort,
                          const char* username, const char* password) {
    clearError();
    try {
        auto cpp = std::make_shared<Session>(
            std::string(host), rpcPort,
            std::string(username), std::string(password));
        auto* cs = new CSession_();
        cs->cpp = std::move(cpp);
        return cs;
    } catch (const std::exception& e) {
        handleException(e);
        return nullptr;
    }
}

CSession* ts_session_new_with_zone(const char* host, int rpcPort,
                                    const char* username, const char* password,
                                    const char* zoneId, int fetchSize) {
    clearError();
    try {
        auto cpp = std::make_shared<Session>(
            std::string(host), rpcPort,
            std::string(username), std::string(password),
            std::string(zoneId), fetchSize);
        auto* cs = new CSession_();
        cs->cpp = std::move(cpp);
        return cs;
    } catch (const std::exception& e) {
        handleException(e);
        return nullptr;
    }
}

CSession* ts_session_new_multi_node(const char* const* nodeUrls, int urlCount,
                                     const char* username, const char* password) {
    clearError();
    try {
        auto urls = toStringVec(nodeUrls, urlCount);
        auto cpp = std::make_shared<Session>(urls, std::string(username), std::string(password));
        auto* cs = new CSession_();
        cs->cpp = std::move(cpp);
        return cs;
    } catch (const std::exception& e) {
        handleException(e);
        return nullptr;
    }
}

void ts_session_destroy(CSession* session) {
    delete session;
}

TsStatus ts_session_open(CSession* session) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        session->cpp->open();
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_session_open_with_compression(CSession* session, bool enableRPCCompression) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        session->cpp->open(enableRPCCompression);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_session_close(CSession* session) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        session->cpp->close();
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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

CTableSession* ts_table_session_new(const char* host, int rpcPort,
                                     const char* username, const char* password,
                                     const char* database) {
    clearError();
    try {
        std::unique_ptr<TableSessionBuilder> builder(new TableSessionBuilder());
        auto tableSession = builder->host(std::string(host))
            ->rpcPort(rpcPort)
            ->username(std::string(username))
            ->password(std::string(password))
            ->database(std::string(database ? database : ""))
            ->build();
        CTableSession_ tmp{};
        tmp.cpp = std::move(tableSession);
        auto* cts = new CTableSession_();
        cts->cpp = std::move(tmp.cpp);
        return cts;
    } catch (const std::exception& e) {
        handleException(e);
        return nullptr;
    }
}

CTableSession* ts_table_session_new_multi_node(const char* const* nodeUrls, int urlCount,
                                                const char* username, const char* password,
                                                const char* database) {
    clearError();
    try {
        auto urls = toStringVec(nodeUrls, urlCount);
        std::unique_ptr<TableSessionBuilder> builder(new TableSessionBuilder());
        auto tableSession = builder->nodeUrls(urls)
            ->username(std::string(username))
            ->password(std::string(password))
            ->database(std::string(database ? database : ""))
            ->build();
        CTableSession_ tmp{};
        tmp.cpp = std::move(tableSession);
        auto* cts = new CTableSession_();
        cts->cpp = std::move(tmp.cpp);
        return cts;
    } catch (const std::exception& e) {
        handleException(e);
        return nullptr;
    }
}

void ts_table_session_destroy(CTableSession* session) {
    delete session;
}

TsStatus ts_table_session_open(CTableSession* session) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        session->cpp->open();
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_table_session_close(CTableSession* session) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        session->cpp->close();
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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

TsStatus ts_session_set_timezone(CSession* session, const char* zoneId) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        session->cpp->setTimeZone(std::string(zoneId));
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_session_get_timezone(CSession* session, char* buf, int bufLen) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    if (!buf || bufLen <= 0) return setError(TS_ERR_INVALID_PARAM, "invalid buffer");
    try {
        std::string tz = session->cpp->getTimeZone();
        if ((int)tz.size() >= bufLen) {
            return setError(TS_ERR_INVALID_PARAM, "buffer too small");
        }
        strncpy(buf, tz.c_str(), bufLen);
        buf[bufLen - 1] = '\0';
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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

TsStatus ts_session_create_database(CSession* session, const char* database) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        session->cpp->createDatabase(std::string(database));
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_session_delete_database(CSession* session, const char* database) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        session->cpp->deleteDatabase(std::string(database));
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_session_delete_databases(CSession* session, const char* const* databases, int count) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        auto dbs = toStringVec(databases, count);
        session->cpp->deleteDatabases(dbs);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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

TsStatus ts_session_create_timeseries(CSession* session, const char* path,
                                       TSDataType_C dataType, TSEncoding_C encoding,
                                       TSCompressionType_C compressor) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        session->cpp->createTimeseries(
            std::string(path),
            static_cast<TSDataType::TSDataType>(dataType),
            static_cast<TSEncoding::TSEncoding>(encoding),
            static_cast<CompressionType::CompressionType>(compressor));
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        std::map<std::string, std::string> props = propsCount > 0 ? toStringMap(propsCount, propKeys, propValues) : std::map<std::string, std::string>();
        std::map<std::string, std::string> tags = tagsCount > 0 ? toStringMap(tagsCount, tagKeys, tagValues) : std::map<std::string, std::string>();
        std::map<std::string, std::string> attrs = attrsCount > 0 ? toStringMap(attrsCount, attrKeys, attrValues) : std::map<std::string, std::string>();
        session->cpp->createTimeseries(
            std::string(path),
            static_cast<TSDataType::TSDataType>(dataType),
            static_cast<TSEncoding::TSEncoding>(encoding),
            static_cast<CompressionType::CompressionType>(compressor),
            &props, &tags, &attrs,
            std::string(measurementAlias ? measurementAlias : ""));
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        auto pathsVec = toStringVec(paths, count);
        auto typesVec = toTypeVec(dataTypes, count);
        auto encVec = toEncodingVec(encodings, count);
        auto compVec = toCompressionVec(compressors, count);
        session->cpp->createMultiTimeseries(
            pathsVec, typesVec, encVec, compVec,
            nullptr, nullptr, nullptr, nullptr);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        auto measurementsVec = toStringVec(measurements, count);
        auto typesVec = toTypeVec(dataTypes, count);
        auto encVec = toEncodingVec(encodings, count);
        auto compVec = toCompressionVec(compressors, count);
        session->cpp->createAlignedTimeseries(
            std::string(deviceId), measurementsVec, typesVec, encVec, compVec);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_session_check_timeseries_exists(CSession* session, const char* path, bool* exists) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    if (!exists) return setError(TS_ERR_INVALID_PARAM, "exists pointer is null");
    try {
        *exists = session->cpp->checkTimeseriesExists(std::string(path));
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_session_delete_timeseries(CSession* session, const char* path) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        session->cpp->deleteTimeseries(std::string(path));
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_session_delete_timeseries_batch(CSession* session, const char* const* paths, int count) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        auto pathsVec = toStringVec(paths, count);
        session->cpp->deleteTimeseries(pathsVec);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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

CTablet* ts_tablet_new(const char* deviceId, int columnCount,
                        const char* const* columnNames,
                        const TSDataType_C* dataTypes,
                        int maxRowNumber) {
    try {
        std::vector<std::pair<std::string, TSDataType::TSDataType>> schemas;
        schemas.reserve(columnCount);
        for (int i = 0; i < columnCount; i++) {
            schemas.emplace_back(std::string(columnNames[i]),
                                 static_cast<TSDataType::TSDataType>(dataTypes[i]));
        }
        Tablet tablet(std::string(deviceId), schemas, maxRowNumber);
        auto* ct = new CTablet_();
        ct->cpp = std::move(tablet);
        return ct;
    } catch (const std::exception& e) {
        handleException(e);
        return nullptr;
    }
}

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) {
    try {
        std::vector<std::pair<std::string, TSDataType::TSDataType>> schemas;
        std::vector<ColumnCategory> colTypes;
        schemas.reserve(columnCount);
        colTypes.reserve(columnCount);
        for (int i = 0; i < columnCount; i++) {
            schemas.emplace_back(std::string(columnNames[i]),
                                 static_cast<TSDataType::TSDataType>(dataTypes[i]));
            colTypes.push_back(static_cast<ColumnCategory>(columnCategories[i]));
        }
        Tablet tablet(std::string(deviceId), schemas, colTypes, maxRowNumber);
        auto* ct = new CTablet_();
        ct->cpp = std::move(tablet);
        return ct;
    } catch (const std::exception& e) {
        handleException(e);
        return nullptr;
    }
}

void ts_tablet_destroy(CTablet* tablet) {
    delete tablet;
}

void ts_tablet_reset(CTablet* tablet) {
    if (tablet) {
        tablet->cpp.reset();
    }
}

int ts_tablet_get_row_count(CTablet* tablet) {
    if (!tablet) return 0;
    return static_cast<int>(tablet->cpp.rowSize);
}

TsStatus ts_tablet_set_row_count(CTablet* tablet, int rowCount) {
    clearError();
    if (!tablet) return setError(TS_ERR_NULL_PTR, "tablet is null");
    tablet->cpp.rowSize = rowCount;
    return TS_OK;
}

TsStatus ts_tablet_add_timestamp(CTablet* tablet, int rowIndex, int64_t timestamp) {
    clearError();
    if (!tablet) return setError(TS_ERR_NULL_PTR, "tablet is null");
    try {
        tablet->cpp.addTimestamp(static_cast<size_t>(rowIndex), timestamp);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_tablet_add_value_bool(CTablet* tablet, int colIndex, int rowIndex, bool value) {
    clearError();
    if (!tablet) return setError(TS_ERR_NULL_PTR, "tablet is null");
    try {
        tablet->cpp.addValue(static_cast<size_t>(colIndex), static_cast<size_t>(rowIndex), value);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_tablet_add_value_int32(CTablet* tablet, int colIndex, int rowIndex, int32_t value) {
    clearError();
    if (!tablet) return setError(TS_ERR_NULL_PTR, "tablet is null");
    try {
        tablet->cpp.addValue(static_cast<size_t>(colIndex), static_cast<size_t>(rowIndex), value);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_tablet_add_value_int64(CTablet* tablet, int colIndex, int rowIndex, int64_t value) {
    clearError();
    if (!tablet) return setError(TS_ERR_NULL_PTR, "tablet is null");
    try {
        tablet->cpp.addValue(static_cast<size_t>(colIndex), static_cast<size_t>(rowIndex), value);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_tablet_add_value_float(CTablet* tablet, int colIndex, int rowIndex, float value) {
    clearError();
    if (!tablet) return setError(TS_ERR_NULL_PTR, "tablet is null");
    try {
        tablet->cpp.addValue(static_cast<size_t>(colIndex), static_cast<size_t>(rowIndex), value);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_tablet_add_value_double(CTablet* tablet, int colIndex, int rowIndex, double value) {
    clearError();
    if (!tablet) return setError(TS_ERR_NULL_PTR, "tablet is null");
    try {
        tablet->cpp.addValue(static_cast<size_t>(colIndex), static_cast<size_t>(rowIndex), value);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_tablet_add_value_string(CTablet* tablet, int colIndex, int rowIndex, const char* value) {
    clearError();
    if (!tablet) return setError(TS_ERR_NULL_PTR, "tablet is null");
    try {
        std::string str(value);
        tablet->cpp.addValue(static_cast<size_t>(colIndex), static_cast<size_t>(rowIndex), str);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

/* ============================================================
 *  Data Insertion  —  Tree Model  (Record, string values)
 * ============================================================ */

TsStatus ts_session_insert_record_str(CSession* session, const char* deviceId,
                                       int64_t time, int count,
                                       const char* const* measurements,
                                       const char* const* values) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        auto measurementsVec = toStringVec(measurements, count);
        auto valuesVec = toStringVec(values, count);
        session->cpp->insertRecord(std::string(deviceId), time, measurementsVec, valuesVec);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        auto measurementsVec = toStringVec(measurements, count);
        auto typesVec = toTypeVec(types, count);
        auto charVec = toCharPtrVec(types, values, count);
        session->cpp->insertRecord(std::string(deviceId), time, measurementsVec, typesVec, charVec);
        freeCharPtrVec(charVec, types, count);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        auto measurementsVec = toStringVec(measurements, count);
        auto valuesVec = toStringVec(values, count);
        session->cpp->insertAlignedRecord(std::string(deviceId), time, measurementsVec, valuesVec);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        auto measurementsVec = toStringVec(measurements, count);
        auto typesVec = toTypeVec(types, count);
        auto charVec = toCharPtrVec(types, values, count);
        session->cpp->insertAlignedRecord(std::string(deviceId), time, measurementsVec, typesVec, charVec);
        freeCharPtrVec(charVec, types, count);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

/* ============================================================
 *  Data Insertion  —  Batch, 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) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        auto devVec = toStringVec(deviceIds, deviceCount);
        std::vector<int64_t> timesVec(times, times + deviceCount);
        std::vector<std::vector<std::string>> mList, vList;
        mList.reserve(deviceCount);
        vList.reserve(deviceCount);
        for (int i = 0; i < deviceCount; i++) {
            mList.push_back(toStringVec(measurementsList[i], measurementCounts[i]));
            vList.push_back(toStringVec(valuesList[i], measurementCounts[i]));
        }
        session->cpp->insertRecords(devVec, timesVec, mList, vList);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        auto devVec = toStringVec(deviceIds, deviceCount);
        std::vector<int64_t> timesVec(times, times + deviceCount);
        std::vector<std::vector<std::string>> mList, vList;
        mList.reserve(deviceCount);
        vList.reserve(deviceCount);
        for (int i = 0; i < deviceCount; i++) {
            mList.push_back(toStringVec(measurementsList[i], measurementCounts[i]));
            vList.push_back(toStringVec(valuesList[i], measurementCounts[i]));
        }
        session->cpp->insertAlignedRecords(devVec, timesVec, mList, vList);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

/* ============================================================
 *  Data Insertion  —  Batch, 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) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        auto devVec = toStringVec(deviceIds, deviceCount);
        std::vector<int64_t> timesVec(times, times + deviceCount);
        std::vector<std::vector<std::string>> mList;
        std::vector<std::vector<TSDataType::TSDataType>> tList;
        std::vector<std::vector<char*>> vList;
        mList.reserve(deviceCount);
        tList.reserve(deviceCount);
        vList.reserve(deviceCount);
        for (int i = 0; i < deviceCount; i++) {
            mList.push_back(toStringVec(measurementsList[i], measurementCounts[i]));
            tList.push_back(toTypeVec(typesList[i], measurementCounts[i]));
            vList.push_back(toCharPtrVec(typesList[i], valuesList[i], measurementCounts[i]));
        }
        session->cpp->insertRecords(devVec, timesVec, mList, tList, vList);
        for (int i = 0; i < deviceCount; i++) {
            freeCharPtrVec(vList[i], typesList[i], measurementCounts[i]);
        }
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        auto devVec = toStringVec(deviceIds, deviceCount);
        std::vector<int64_t> timesVec(times, times + deviceCount);
        std::vector<std::vector<std::string>> mList;
        std::vector<std::vector<TSDataType::TSDataType>> tList;
        std::vector<std::vector<char*>> vList;
        mList.reserve(deviceCount);
        tList.reserve(deviceCount);
        vList.reserve(deviceCount);
        for (int i = 0; i < deviceCount; i++) {
            mList.push_back(toStringVec(measurementsList[i], measurementCounts[i]));
            tList.push_back(toTypeVec(typesList[i], measurementCounts[i]));
            vList.push_back(toCharPtrVec(typesList[i], valuesList[i], measurementCounts[i]));
        }
        session->cpp->insertAlignedRecords(devVec, timesVec, mList, tList, vList);
        for (int i = 0; i < deviceCount; i++) {
            freeCharPtrVec(vList[i], typesList[i], measurementCounts[i]);
        }
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

/* ============================================================
 *  Data Insertion  —  Batch, 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) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        std::vector<int64_t> timesVec(times, times + rowCount);
        std::vector<std::vector<std::string>> mList;
        std::vector<std::vector<TSDataType::TSDataType>> tList;
        std::vector<std::vector<char*>> vList;
        mList.reserve(rowCount);
        tList.reserve(rowCount);
        vList.reserve(rowCount);
        for (int i = 0; i < rowCount; i++) {
            mList.push_back(toStringVec(measurementsList[i], measurementCounts[i]));
            tList.push_back(toTypeVec(typesList[i], measurementCounts[i]));
            vList.push_back(toCharPtrVec(typesList[i], valuesList[i], measurementCounts[i]));
        }
        session->cpp->insertRecordsOfOneDevice(std::string(deviceId), timesVec, mList, tList, vList, sorted);
        for (int i = 0; i < rowCount; i++) {
            freeCharPtrVec(vList[i], typesList[i], measurementCounts[i]);
        }
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        std::vector<int64_t> timesVec(times, times + rowCount);
        std::vector<std::vector<std::string>> mList;
        std::vector<std::vector<TSDataType::TSDataType>> tList;
        std::vector<std::vector<char*>> vList;
        mList.reserve(rowCount);
        tList.reserve(rowCount);
        vList.reserve(rowCount);
        for (int i = 0; i < rowCount; i++) {
            mList.push_back(toStringVec(measurementsList[i], measurementCounts[i]));
            tList.push_back(toTypeVec(typesList[i], measurementCounts[i]));
            vList.push_back(toCharPtrVec(typesList[i], valuesList[i], measurementCounts[i]));
        }
        session->cpp->insertAlignedRecordsOfOneDevice(std::string(deviceId), timesVec, mList, tList, vList, sorted);
        for (int i = 0; i < rowCount; i++) {
            freeCharPtrVec(vList[i], typesList[i], measurementCounts[i]);
        }
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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

TsStatus ts_session_insert_tablet(CSession* session, CTablet* tablet, bool sorted) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    if (!tablet) return setError(TS_ERR_NULL_PTR, "tablet is null");
    try {
        session->cpp->insertTablet(tablet->cpp, sorted);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_session_insert_aligned_tablet(CSession* session, CTablet* tablet, bool sorted) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    if (!tablet) return setError(TS_ERR_NULL_PTR, "tablet is null");
    try {
        session->cpp->insertAlignedTablet(tablet->cpp, sorted);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_session_insert_tablets(CSession* session, int tabletCount,
                                    const char* const* deviceIds,
                                    CTablet** tablets, bool sorted) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        std::unordered_map<std::string, Tablet*> tabletMap;
        for (int i = 0; i < tabletCount; i++) {
            tabletMap[std::string(deviceIds[i])] = &(tablets[i]->cpp);
        }
        session->cpp->insertTablets(tabletMap, sorted);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_session_insert_aligned_tablets(CSession* session, int tabletCount,
                                            const char* const* deviceIds,
                                            CTablet** tablets, bool sorted) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        std::unordered_map<std::string, Tablet*> tabletMap;
        for (int i = 0; i < tabletCount; i++) {
            tabletMap[std::string(deviceIds[i])] = &(tablets[i]->cpp);
        }
        session->cpp->insertAlignedTablets(tabletMap, sorted);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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

TsStatus ts_table_session_insert(CTableSession* session, CTablet* tablet) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    if (!tablet) return setError(TS_ERR_NULL_PTR, "tablet is null");
    try {
        session->cpp->insert(tablet->cpp);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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

TsStatus ts_session_execute_query(CSession* session, const char* sql,
                                   CSessionDataSet** dataSet) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    if (!dataSet) return setError(TS_ERR_INVALID_PARAM, "dataSet pointer is null");
    try {
        auto ds = session->cpp->executeQueryStatement(std::string(sql));
        CSessionDataSet_ tmp{};
        tmp.cpp = std::move(ds);
        auto* cds = new CSessionDataSet_();
        cds->cpp = std::move(tmp.cpp);
        *dataSet = cds;
        return TS_OK;
    } catch (const std::exception& e) {
        *dataSet = nullptr;
        return handleException(e);
    }
}

TsStatus ts_session_execute_query_with_timeout(CSession* session, const char* sql,
                                                int64_t timeoutInMs,
                                                CSessionDataSet** dataSet) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    if (!dataSet) return setError(TS_ERR_INVALID_PARAM, "dataSet pointer is null");
    try {
        auto ds = session->cpp->executeQueryStatement(std::string(sql), timeoutInMs);
        CSessionDataSet_ tmp{};
        tmp.cpp = std::move(ds);
        auto* cds = new CSessionDataSet_();
        cds->cpp = std::move(tmp.cpp);
        *dataSet = cds;
        return TS_OK;
    } catch (const std::exception& e) {
        *dataSet = nullptr;
        return handleException(e);
    }
}

TsStatus ts_session_execute_non_query(CSession* session, const char* sql) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        session->cpp->executeNonQueryStatement(std::string(sql));
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_session_execute_raw_data_query(CSession* session,
                                            int pathCount, const char* const* paths,
                                            int64_t startTime, int64_t endTime,
                                            CSessionDataSet** dataSet) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    if (!dataSet) return setError(TS_ERR_INVALID_PARAM, "dataSet pointer is null");
    try {
        auto pathsVec = toStringVec(paths, pathCount);
        auto ds = session->cpp->executeRawDataQuery(pathsVec, startTime, endTime);
        CSessionDataSet_ tmp{};
        tmp.cpp = std::move(ds);
        auto* cds = new CSessionDataSet_();
        cds->cpp = std::move(tmp.cpp);
        *dataSet = cds;
        return TS_OK;
    } catch (const std::exception& e) {
        *dataSet = nullptr;
        return handleException(e);
    }
}

TsStatus ts_session_execute_last_data_query(CSession* session,
                                             int pathCount, const char* const* paths,
                                             CSessionDataSet** dataSet) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    if (!dataSet) return setError(TS_ERR_INVALID_PARAM, "dataSet pointer is null");
    try {
        auto pathsVec = toStringVec(paths, pathCount);
        auto ds = session->cpp->executeLastDataQuery(pathsVec);
        CSessionDataSet_ tmp{};
        tmp.cpp = std::move(ds);
        auto* cds = new CSessionDataSet_();
        cds->cpp = std::move(tmp.cpp);
        *dataSet = cds;
        return TS_OK;
    } catch (const std::exception& e) {
        *dataSet = nullptr;
        return handleException(e);
    }
}

TsStatus ts_session_execute_last_data_query_with_time(CSession* session,
                                                       int pathCount, const char* const* paths,
                                                       int64_t lastTime,
                                                       CSessionDataSet** dataSet) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    if (!dataSet) return setError(TS_ERR_INVALID_PARAM, "dataSet pointer is null");
    try {
        auto pathsVec = toStringVec(paths, pathCount);
        auto ds = session->cpp->executeLastDataQuery(pathsVec, lastTime);
        CSessionDataSet_ tmp{};
        tmp.cpp = std::move(ds);
        auto* cds = new CSessionDataSet_();
        cds->cpp = std::move(tmp.cpp);
        *dataSet = cds;
        return TS_OK;
    } catch (const std::exception& e) {
        *dataSet = nullptr;
        return handleException(e);
    }
}

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

TsStatus ts_table_session_execute_query(CTableSession* session, const char* sql,
                                         CSessionDataSet** dataSet) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    if (!dataSet) return setError(TS_ERR_INVALID_PARAM, "dataSet pointer is null");
    try {
        auto ds = session->cpp->executeQueryStatement(std::string(sql));
        CSessionDataSet_ tmp{};
        tmp.cpp = std::move(ds);
        auto* cds = new CSessionDataSet_();
        cds->cpp = std::move(tmp.cpp);
        *dataSet = cds;
        return TS_OK;
    } catch (const std::exception& e) {
        *dataSet = nullptr;
        return handleException(e);
    }
}

TsStatus ts_table_session_execute_query_with_timeout(CTableSession* session, const char* sql,
                                                      int64_t timeoutInMs,
                                                      CSessionDataSet** dataSet) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    if (!dataSet) return setError(TS_ERR_INVALID_PARAM, "dataSet pointer is null");
    try {
        auto ds = session->cpp->executeQueryStatement(std::string(sql), timeoutInMs);
        CSessionDataSet_ tmp{};
        tmp.cpp = std::move(ds);
        auto* cds = new CSessionDataSet_();
        cds->cpp = std::move(tmp.cpp);
        *dataSet = cds;
        return TS_OK;
    } catch (const std::exception& e) {
        *dataSet = nullptr;
        return handleException(e);
    }
}

TsStatus ts_table_session_execute_non_query(CTableSession* session, const char* sql) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        session->cpp->executeNonQueryStatement(std::string(sql));
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

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

void ts_dataset_destroy(CSessionDataSet* dataSet) {
    if (dataSet) {
        if (dataSet->cpp) {
            dataSet->cpp->closeOperationHandle();
        }
        delete dataSet;
    }
}

bool ts_dataset_has_next(CSessionDataSet* dataSet) {
    clearError();
    if (!dataSet) {
        (void)setError(TS_ERR_NULL_PTR, "dataSet is null");
        return false;
    }
    if (!dataSet->cpp) {
        (void)setError(TS_ERR_NULL_PTR, "dataSet is not initialized");
        return false;
    }
    try {
        return dataSet->cpp->hasNext();
    } catch (const std::exception& e) {
        (void)handleException(e);
        return false;
    } catch (...) {
        (void)setError(TS_ERR_UNKNOWN, "non-standard exception");
        return false;
    }
}

CRowRecord* ts_dataset_next(CSessionDataSet* dataSet) {
    clearError();
    if (!dataSet) {
        (void)setError(TS_ERR_NULL_PTR, "dataSet is null");
        return nullptr;
    }
    if (!dataSet->cpp) {
        (void)setError(TS_ERR_NULL_PTR, "dataSet is not initialized");
        return nullptr;
    }
    try {
        auto row = dataSet->cpp->next();
        if (!row) return nullptr;
        CRowRecord_ tmp{};
        tmp.cpp = std::move(row);
        auto* crr = new CRowRecord_();
        crr->cpp = std::move(tmp.cpp);
        return crr;
    } catch (const std::exception& e) {
        (void)handleException(e);
        return nullptr;
    } catch (...) {
        (void)setError(TS_ERR_UNKNOWN, "non-standard exception");
        return nullptr;
    }
}

int ts_dataset_get_column_count(CSessionDataSet* dataSet) {
    if (!dataSet || !dataSet->cpp) return 0;
    return static_cast<int>(dataSet->cpp->getColumnNames().size());
}

static thread_local std::string g_colNameBuf;

const char* ts_dataset_get_column_name(CSessionDataSet* dataSet, int index) {
    if (!dataSet || !dataSet->cpp) return "";
    const auto& names = dataSet->cpp->getColumnNames();
    if (index < 0 || index >= (int)names.size()) return "";
    g_colNameBuf = names[index];
    return g_colNameBuf.c_str();
}

static thread_local std::string g_colTypeBuf;

const char* ts_dataset_get_column_type(CSessionDataSet* dataSet, int index) {
    if (!dataSet || !dataSet->cpp) return "";
    const auto& types = dataSet->cpp->getColumnTypeList();
    if (index < 0 || index >= (int)types.size()) return "";
    g_colTypeBuf = types[index];
    return g_colTypeBuf.c_str();
}

void ts_dataset_set_fetch_size(CSessionDataSet* dataSet, int fetchSize) {
    if (dataSet && dataSet->cpp) {
        dataSet->cpp->setFetchSize(fetchSize);
    }
}

void ts_row_record_destroy(CRowRecord* record) {
    delete record;
}

int64_t ts_row_record_get_timestamp(CRowRecord* record) {
    if (!record || !record->cpp) return -1;
    return record->cpp->timestamp;
}

int ts_row_record_get_field_count(CRowRecord* record) {
    if (!record || !record->cpp) return 0;
    return static_cast<int>(record->cpp->fields.size());
}

bool ts_row_record_is_null(CRowRecord* record, int index) {
    if (!record || !record->cpp) return true;
    if (index < 0 || index >= (int)record->cpp->fields.size()) return true;
    return record->cpp->fields[index].isNull();
}

bool ts_row_record_get_bool(CRowRecord* record, int index) {
    if (!record || !record->cpp) return false;
    if (index < 0 || index >= (int)record->cpp->fields.size()) return false;
    const Field& f = record->cpp->fields[index];
    return f.boolV.is_initialized() ? f.boolV.value() : false;
}

int32_t ts_row_record_get_int32(CRowRecord* record, int index) {
    if (!record || !record->cpp) return 0;
    if (index < 0 || index >= (int)record->cpp->fields.size()) return 0;
    const Field& f = record->cpp->fields[index];
    return f.intV.is_initialized() ? f.intV.value() : 0;
}

int64_t ts_row_record_get_int64(CRowRecord* record, int index) {
    if (!record || !record->cpp) return 0;
    if (index < 0 || index >= (int)record->cpp->fields.size()) return 0;
    const Field& f = record->cpp->fields[index];
    return f.longV.is_initialized() ? f.longV.value() : 0;
}

float ts_row_record_get_float(CRowRecord* record, int index) {
    if (!record || !record->cpp) return 0.0f;
    if (index < 0 || index >= (int)record->cpp->fields.size()) return 0.0f;
    const Field& f = record->cpp->fields[index];
    return f.floatV.is_initialized() ? f.floatV.value() : 0.0f;
}

double ts_row_record_get_double(CRowRecord* record, int index) {
    if (!record || !record->cpp) return 0.0;
    if (index < 0 || index >= (int)record->cpp->fields.size()) return 0.0;
    const Field& f = record->cpp->fields[index];
    return f.doubleV.is_initialized() ? f.doubleV.value() : 0.0;
}

static thread_local std::string g_stringBuf;

const char* ts_row_record_get_string(CRowRecord* record, int index) {
    if (!record || !record->cpp) return "";
    if (index < 0 || index >= (int)record->cpp->fields.size()) return "";
    const Field& f = record->cpp->fields[index];
    if (f.stringV.is_initialized()) {
        g_stringBuf = f.stringV.value();
        return g_stringBuf.c_str();
    }
    return "";
}

TSDataType_C ts_row_record_get_data_type(CRowRecord* record, int index) {
    if (!record || !record->cpp) return TS_TYPE_INVALID;
    if (index < 0 || index >= (int)record->cpp->fields.size()) return TS_TYPE_INVALID;
    return static_cast<TSDataType_C>(record->cpp->fields[index].dataType);
}

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

TsStatus ts_session_delete_data(CSession* session, const char* path, int64_t endTime) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        session->cpp->deleteData(std::string(path), endTime);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_session_delete_data_batch(CSession* session, int pathCount,
                                       const char* const* paths, int64_t endTime) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        auto pathsVec = toStringVec(paths, pathCount);
        session->cpp->deleteData(pathsVec, endTime);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

TsStatus ts_session_delete_data_range(CSession* session, int pathCount,
                                       const char* const* paths,
                                       int64_t startTime, int64_t endTime) {
    clearError();
    if (!session) return setError(TS_ERR_NULL_PTR, "session is null");
    try {
        auto pathsVec = toStringVec(paths, pathCount);
        session->cpp->deleteData(pathsVec, startTime, endTime);
        return TS_OK;
    } catch (const std::exception& e) {
        return handleException(e);
    }
}

}  /* extern "C" */