/*
 * Copyright (c) 2014 Amlogic, Inc. All rights reserved.
 *
 * This source code is subject to the terms and conditions defined in the
 * file 'LICENSE' which is part of this source code package.
 *
 * Description: c++ file
 */

#define LOG_MODULE_TAG "PQ"
#define LOG_CLASS_TAG "CSqlite"

#include "CSqlite.h"

CSqlite::Cursor::Cursor()
{
    mData = NULL;
    mCurRowIndex = 0;
    mRowNums = 0;
    mColNums = 0;
    mIsClosed = false;
}

CSqlite::Cursor::~Cursor()
{
    close();
}

void CSqlite::Cursor::Init(char **data, int cow, int col)
{
    if (mData != NULL) {
        sqlite3_free_table(mData);
    }

    mData = data;
    mCurRowIndex = 0;
    mRowNums = cow;
    mColNums = col;
    mIsClosed = false;
}

int CSqlite::Cursor::getCount()
{
    return mRowNums;
}

int CSqlite::Cursor::getPosition()
{
    return 0;
}

bool CSqlite::Cursor::move(int offset)
{
    return false;
}

bool CSqlite::Cursor::moveToPosition(int position)
{
    return false;
}

bool CSqlite::Cursor::moveToFirst()
{
    if (mRowNums <= 0) {
        return false;
    } else {
        mCurRowIndex = 0;
        return true;
    }
}

bool CSqlite::Cursor::moveToLast()
{
    return false;
}

bool CSqlite::Cursor::moveToNext()
{
    if (mCurRowIndex >= mRowNums - 1) {
        return false;
    } else {
        mCurRowIndex++;
        return true;
    }
}

bool CSqlite::Cursor::moveToPrevious()
{
    return false;
}

int CSqlite::Cursor::getColumnIndex(const char *columnName)
{
    int index = 0;
    for (int i = 0; i < mColNums; i++) {
        if (strcmp(columnName, mData[i]) == 0)
            return index;
        index++;
    }

    return -1;
}

int CSqlite::Cursor::getColumnCount()
{
    return -1;
}

std::string CSqlite::Cursor::getString(int columnIndex)
{
    if (columnIndex >= mColNums) {
        return std::string("");
    } else {
        return std::string(mData[mColNums * (mCurRowIndex + 1) + columnIndex]);
    }
}

int CSqlite::Cursor::getInt(int columnIndex)
{
    return atoi(mData[mColNums * (mCurRowIndex + 1) + columnIndex]);
}

unsigned long int CSqlite::Cursor::getUInt(int columnIndex)
{
    return strtoul(mData[mColNums * (mCurRowIndex + 1) + columnIndex], NULL, 10);
}

double CSqlite::Cursor::getF(int columnIndex)
{
    return atof(mData[mColNums * (mCurRowIndex + 1) + columnIndex]);
}

int CSqlite::Cursor::getType(int columnIndex)
{
    return -1;
}

void CSqlite::Cursor::close()
{
    if (mData != NULL) {
        sqlite3_free_table(mData);
    }

    mData = NULL;
    mCurRowIndex = 0;
    mRowNums = 0;
    mIsClosed = true;
}

bool CSqlite::Cursor::isClosed()
{
    return mIsClosed;
}

CSqlite::CSqlite()
{
    mHandle = NULL;
    m_pStmtSelect = NULL;
    m_pStmtUpdate = NULL;
    m_pStmtDelete = NULL;
}

CSqlite::~CSqlite()
{
    std::lock_guard<std::mutex> lock(mLock);
    if (mHandle != NULL) {
        sqlite3_close(mHandle);
        mHandle = NULL;
    }
}

int CSqlite::sqlite3_exec_callback(void *data __unused, int nColumn, char **colValues __unused, char **colNames __unused)
{
    LOGD("%s: nums = %d", __FUNCTION__, nColumn);
    return 0;
}

int CSqlite::openDb(const char *path)
{
    std::lock_guard<std::mutex> lock(mLock);
    if (sqlite3_open(path, &mHandle) != SQLITE_OK) {
        LOGD("open db(%s) error", path);
        mHandle = NULL;
        return -1;
    }

    return 0;
}

int CSqlite::closeDb()
{
    std::lock_guard<std::mutex> lock(mLock);
    int rval = 0;
    if (mHandle != NULL) {
        rval = sqlite3_close(mHandle);
        mHandle = NULL;
    }

    return rval;
}

void CSqlite::setHandle(sqlite3 *h)
{
    std::lock_guard<std::mutex> lock(mLock);

    mHandle = h;
}

sqlite3 *CSqlite::getHandle()
{
    std::lock_guard<std::mutex> lock(mLock);

    return mHandle;
}

int CSqlite::select(const char *sql, CSqlite::Cursor &c)
{
    std::lock_guard<std::mutex> lock(mLock);
    int col, row;
    char **pResult = NULL;
    char *errmsg;
    assert(mHandle && sql);

    if (strncmp(sql, "select", 6)) {
        return -1;
    }
    if (sqlite3_get_table(mHandle, sql, &pResult, &row, &col, &errmsg) != SQLITE_OK) {
        LOGE("errmsg=%s.\n", errmsg);
        if (pResult != NULL)
            sqlite3_free_table(pResult);
        return -1;
    }

    c.Init(pResult, row, col);
    return 0;
}

void CSqlite::insert()
{
}

bool CSqlite::exeSql(const char *sql)
{
    std::lock_guard<std::mutex> lock(mLock);
    char *errmsg = NULL;

    if (sql == NULL) {
        return false;
    }

    int result = sqlite3_exec(mHandle, sql, NULL, NULL, &errmsg);

    if (result != SQLITE_OK) {
        SYS_LOGE("exeSql=: %s error=%s, error code = %d", sql, errmsg ? errmsg : "Unknown", result);
        if (errmsg) {
            sqlite3_free(errmsg);
        }
        return false;
    }

    return true;
}

bool CSqlite::EnableBatchHighSpeedMode(void)
{
    std::lock_guard<std::mutex> lock(mLock);

    if (SqlBatchHighSpeedMode) {
        printf("SQL at Batch High Speed mode\n");
        return true;
    }

    // 保存当前设置
    char* errMsg = nullptr;
    int ret = SQLITE_OK;
    ret = sqlite3_exec(mHandle, "PRAGMA journal_mode;", [](void* data, int argc, char** argv, char** colName) -> int {
        if (argc > 0 && argv[0]) {
            *static_cast<std::string*>(data) = argv[0];
        }
        return 0;
    }, &m_originalJournalMode, &errMsg);

    if (ret != SQLITE_OK) {
        printf("Error getting original journal mode: %d - %s\n", ret, errMsg ? errMsg : "Unknown error");
        if (errMsg) {
            sqlite3_free(errMsg);
            errMsg = nullptr;
        }
        return false;
    }
    if (errMsg) {
        sqlite3_free(errMsg);
        errMsg = nullptr;
    }

    ret = sqlite3_exec(mHandle, "PRAGMA synchronous;", [](void* data, int argc, char** argv, char** colName) -> int {
        if (argc > 0 && argv[0]) {
            *static_cast<std::string*>(data) = argv[0];
        }
        return 0;
    }, &m_originalSyncMode, &errMsg);

    if (ret != SQLITE_OK) {
        printf("Error getting original sync mode: %d - %s\n", ret, errMsg ? errMsg : "Unknown error");
        if (errMsg) {
            sqlite3_free(errMsg);
        }
        return false;
    }
    if (errMsg) {
        sqlite3_free(errMsg);
        errMsg = nullptr;
    }

    // 启用高性能设置
    ret = sqlite3_exec(mHandle, "PRAGMA journal_mode = WAL;", nullptr, nullptr, &errMsg);
    if (ret != SQLITE_OK) {
        printf("Error setting WAL mode: %d - %s\n", ret, errMsg ? errMsg : "Unknown error");
        if (errMsg) {
            sqlite3_free(errMsg);
        }
        return false;
    }
    if (errMsg) {
        sqlite3_free(errMsg);
        errMsg = nullptr;
    }

    ret = sqlite3_exec(mHandle, "PRAGMA synchronous = NORMAL;", nullptr, nullptr, &errMsg);
    if (ret != SQLITE_OK) {
        printf("Error setting synchronous mode: %d - %s\n", ret, errMsg ? errMsg : "Unknown error");
        char* rollbackErrMsg = nullptr;
        int rollbackRet = sqlite3_exec(mHandle, ("PRAGMA journal_mode = " + m_originalJournalMode + ";").c_str(),
                                       nullptr, nullptr, &rollbackErrMsg);

        if (rollbackRet != SQLITE_OK) {
            printf("Error rolling back journal mode: %d - %s\n",
                   rollbackRet, rollbackErrMsg ? rollbackErrMsg : "Unknown error");
        }
        if (rollbackErrMsg) {
            sqlite3_free(rollbackErrMsg);
        }

        ret =sqlite3_exec(mHandle, ("PRAGMA journal_mode = " + m_originalJournalMode + ";").c_str(),
                          nullptr, nullptr, nullptr);
        if (ret != SQLITE_OK) {
            printf("Error setting WAL mode: %d - %s\n", ret, errMsg ? errMsg : "Unknown error");
            if (errMsg) {
                sqlite3_free(errMsg);
            }
            return false;
        }
        if (errMsg) {
            sqlite3_free(errMsg);
            errMsg = nullptr;
        }

        return false;
    }

    /*
    // 设置buff 10M 如果需要
    ret = sqlite3_exec(m_pDB, "PRAGMA cache_size = -10000;", nullptr, nullptr, &errMsg);
    if (ret != SQLITE_OK) {
        printf("Error setting cache size: %s\n", errMsg);
        sqlite3_free(errMsg);
    }
    */

    SqlBatchHighSpeedMode = true;
    return true;
}

bool CSqlite::DisableBatchHighSpeedMode(void)
{
    std::lock_guard<std::mutex> lock(mLock);

    if (!SqlBatchHighSpeedMode) {
        printf("SQL not at Batch High Speed mode\n");
        return true;
    }

    bool success = true;
    char* errMsg = nullptr;

    //确保所有WAL中的数据都已写入主数据库
    int ret = sqlite3_exec(mHandle, "PRAGMA wal_checkpoint(TRUNCATE);", nullptr, nullptr, &errMsg);
    if (ret != SQLITE_OK) {
        printf("Error during checkpoint: %s\n", errMsg ? errMsg : "Unknown error");
        if (errMsg) {
            sqlite3_free(errMsg);
            errMsg = nullptr;
        }
        success = false;
    }

    // 恢复原始日志模式
    std::string pragmaJournal = "PRAGMA journal_mode = " + m_originalJournalMode + ";";
    ret = sqlite3_exec(mHandle, pragmaJournal.c_str(), nullptr, nullptr, &errMsg);
    if (ret != SQLITE_OK) {
        printf("Error restoring journal mode: %s\n", errMsg ? errMsg : "Unknown error");
        if (errMsg) {
            sqlite3_free(errMsg);
            errMsg = nullptr;
        }
        success = false;
    }

    // 恢复原始同步模式
    std::string pragmaSync = "PRAGMA synchronous = " + m_originalSyncMode + ";";
    ret = sqlite3_exec(mHandle, pragmaSync.c_str(), nullptr, nullptr, &errMsg);
    if (ret != SQLITE_OK) {
        printf("Error restoring sync mode: %s\n", errMsg ? errMsg : "Unknown error");
        if (errMsg) {
            sqlite3_free(errMsg);
            errMsg = nullptr;
        }
        success = false;
    }

    if (errMsg) {
        sqlite3_free(errMsg);
        errMsg = nullptr;
    }

    /*
    //恢复 buff 2M
    ret = sqlite3_exec(m_pDB, "PRAGMA cache_size = -2000;", nullptr, nullptr, &errMsg);
    if (ret != SQLITE_OK) {
        printf("Error restoring cache size: %s\n", errMsg);
        sqlite3_free(errMsg);
    }
    */

    SqlBatchHighSpeedMode = false;

    return success;
}

bool CSqlite::beginTransaction()
{
    std::lock_guard<std::mutex> lock(mLock);

    if (!mHandle) {
        printf("Database handle is invalid\n");
        return false;
    }

    if (sqlite3_get_autocommit(mHandle) == 0) {
        printf("Already in transaction\n");
        return false;
    }

    char* errMsg = nullptr;
    int ret = sqlite3_exec(mHandle, "BEGIN TRANSACTION;", nullptr, nullptr, &errMsg);

    bool success = (ret == SQLITE_OK);
    if (!success) {
        fprintf(stderr, "Error beginning transaction (code %d): %s\n", ret, errMsg ? errMsg : "Unknown error");
    }

    if (errMsg) {
        sqlite3_free(errMsg);
    }

    return success;
}

bool CSqlite::commitTransaction()
{
    std::lock_guard<std::mutex> lock(mLock);

    char* errMsg = nullptr;
    int ret = sqlite3_exec(mHandle, "COMMIT;", nullptr, nullptr, &errMsg);

    if (ret != SQLITE_OK) {
        const char* errorDescription = "Unknown error";
        switch (ret) {
            case SQLITE_BUSY: errorDescription = "Database is busy"; break;
            case SQLITE_READONLY: errorDescription = "Database is read-only"; break;
            case SQLITE_IOERR: errorDescription = "Disk I/O error"; break;
            case SQLITE_CORRUPT: errorDescription = "Database is corrupt"; break;
            default: break;
        }

        fprintf(stderr, "Error committing transaction (code %d): %s - %s\n",
                ret, errorDescription, errMsg ? errMsg : "No details");

        if (errMsg != nullptr) {
            sqlite3_free(errMsg);
        }

        return false;
    }

    if (errMsg != nullptr) {
        sqlite3_free(errMsg);
    }

    return true;
}

bool CSqlite::rollbackTransaction()
{
    std::lock_guard<std::mutex> lock(mLock);

    char* errMsg = nullptr;
    int ret = sqlite3_exec(mHandle, "ROLLBACK;", nullptr, nullptr, &errMsg);
    if (ret != SQLITE_OK) {
        printf("Error rolling back transaction: %s\n", errMsg);
        sqlite3_free(errMsg);
        return false;
    }

    return true;
}

void CSqlite::del()
{
}

void CSqlite::update()
{
}

void CSqlite::xxtable()
{
}

bool CSqlite::PrepareSqlSelect(const char *msql)
{
    std::lock_guard<std::mutex> lock(mLock);

    if (m_pStmtSelect) {
        sqlite3_finalize(m_pStmtSelect);
        m_pStmtSelect = nullptr;
    }

    int ret = sqlite3_prepare_v2(mHandle, msql, -1, &m_pStmtSelect, 0);

    if (ret != SQLITE_OK || !m_pStmtSelect) {
        printf("ret: %d, msql =%s, errorCode=%d\n", ret, msql, sqlite3_errcode(mHandle));
        sqlite3_finalize(m_pStmtSelect);
        m_pStmtSelect = 0;
        assert(0 && "Failed to prepare SELECT statement");
    }

    return true;
}

bool CSqlite::PrepareSqlUpdate(const char *msql)
{
    std::lock_guard<std::mutex> lock(mLock);

    if (m_pStmtUpdate) {
        sqlite3_finalize(m_pStmtUpdate);
        m_pStmtUpdate = nullptr;
    }

    int ret = sqlite3_prepare_v2(mHandle, msql, -1, &m_pStmtUpdate, 0);

    if (ret != SQLITE_OK || !m_pStmtUpdate) {
        printf("ret: %d, msql =%s, errorCode=%d\n", ret, msql, sqlite3_errcode(mHandle));
        sqlite3_finalize(m_pStmtUpdate);
        m_pStmtUpdate = 0;
        assert(0 && "Failed to prepare UPDATE statement");
    }

    return true;
}

bool CSqlite::PrepareSqlDelete(const char *msql)
{
    std::lock_guard<std::mutex> lock(mLock);

    if (m_pStmtDelete) {
        sqlite3_finalize(m_pStmtDelete);
        m_pStmtDelete = nullptr;
    }

    int ret = sqlite3_prepare_v2(mHandle, msql, -1, &m_pStmtDelete, 0);

    if (ret != SQLITE_OK || !m_pStmtDelete) {
        const char* errMsg = sqlite3_errmsg(mHandle);
        printf("Prepare DELETE failed: ret=%d, sql=%s, error=%s\n", ret, msql, errMsg);

        if (m_pStmtDelete) {
            sqlite3_finalize(m_pStmtDelete);
            m_pStmtDelete = nullptr;
        }

        assert(0 && "Failed to prepare DELETE statement");
        return false;
    }

    return true;
}

bool CSqlite::SetBlobValueToTable(const char *Key, void *pData, int iSize)
{
    std::lock_guard<std::mutex> lock(mLock);

    if (Key == nullptr || pData == nullptr) {
        printf("Error: Key or pData is null\n");
        return false;
    }

    if (iSize < 0) {
        printf("Error: Invalid blob size %d\n", iSize);
        return false;
    }

    if (!m_pStmtUpdate) {
        printf("m_pStmtUpdateINVALID VALUES");
        return false;
    }

    sqlite3_reset(m_pStmtUpdate);
    sqlite3_clear_bindings(m_pStmtUpdate);

    if (sqlite3_bind_text(m_pStmtUpdate, 1, Key, -1, SQLITE_TRANSIENT) != SQLITE_OK) {
        return false;
    }

    if (sqlite3_bind_blob(m_pStmtUpdate, 2, pData, iSize, SQLITE_TRANSIENT) != SQLITE_OK) {
        return false;
    }

    int ret = sqlite3_step(m_pStmtUpdate);

    if (ret != SQLITE_DONE) {
        return false;
    }

    return true;
}

bool CSqlite::GetBlobValueFromTable(const char *Key, void *pData, int iSize)
{
    std::lock_guard<std::mutex> lock(mLock);

    if (Key == nullptr || pData == nullptr) {
        printf("Error: Key or pData is null\n");
        return false;
    }

    if (iSize <= 0) {
        printf("Error: Invalid buffer size %d\n", iSize);
        return false;
    }

    if (!m_pStmtSelect) {
        printf("Error: Select statement null\n");
        return false;
    }

    sqlite3_reset(m_pStmtSelect);
    sqlite3_clear_bindings(m_pStmtSelect);

    if (sqlite3_bind_text(m_pStmtSelect, 1, Key, -1, SQLITE_TRANSIENT) != SQLITE_OK) {
        return false;
    }

    int ret = sqlite3_step(m_pStmtSelect);
    if (ret == SQLITE_DONE) {
        return false;
    }

    if (ret != SQLITE_ROW) {
        return false;
    }

    int valSize = sqlite3_column_bytes(m_pStmtSelect, 0);
    if (valSize <= 0) {
        return false;
    }

    const void* blob = sqlite3_column_blob(m_pStmtSelect, 0);
    if (!blob) {
        return false;
    }

    if (valSize > iSize) {
        return false;
    }
    memcpy(pData, blob, valSize);

    return true;
}

bool CSqlite::DeleteValueFromTable(const char *Key)
{
    std::lock_guard<std::mutex> lock(mLock);

    if (Key == nullptr) {
        printf("Error: Key is null\n");
        return false;
    }

    if (!m_pStmtDelete) {
        printf("Error: Delete statement not prepared (m_pStmtDelete is null)\n");
        return false;
    }

    sqlite3_reset(m_pStmtDelete);
    sqlite3_clear_bindings(m_pStmtDelete);

    if (sqlite3_bind_text(m_pStmtDelete, 1, Key, -1, SQLITE_TRANSIENT) != SQLITE_OK) {
        return false;
    }

    int ret = sqlite3_step(m_pStmtDelete);

    if (ret != SQLITE_DONE) {
        return false;
    }

    return true;
}