easy_mysql.cpp

// Copyright (c) 2026 Yang Zhengguo. All Rights Reserved.

#include "easy_mysql.h"

#include <iostream>

namespace easymysql {

// --- EasyMySQL Implementation ---

EasyMySQL::EasyMySQL() : driver_(nullptr), in_transaction_(false) {
    try {
        driver_ = sql::mysql::get_mysql_driver_instance();
    } catch (const sql::SQLException& e) {
        // Since logger isn't set yet, output to stderr
        std::cerr << "[EasyMySQL][Error] Failed to get driver instance: " 
                  << e.what() << std::endl;
    }
}

EasyMySQL::~EasyMySQL() {
    if (conn_) {
        try {
            conn_->close();
        } catch (...) {
            // Suppress exceptions in destructor
        }
    }
}

void EasyMySQL::SetLogger(LoggerCallback logger) {
    logger_ = std::move(logger);
}

bool EasyMySQL::Connect(const DbConfig& config) {
    std::lock_guard<std::mutex> lock(conn_mutex_);
    config_ = config;

    if (!driver_) {
        Log(LogLevel::kError, "MySQL Driver not initialized.");
        return false;
    }

    try {
        sql::ConnectOptionsMap options;
        options["hostName"] = config.host;
        options["port"] = config.port;
        options["userName"] = config.user;
        options["password"] = config.password;
        options["schema"] = config.database;
        options["OPT_CONNECT_TIMEOUT"] = config.connect_timeout;
        // Some versions of connector support this, others don't
        // options["OPT_RECONNECT"] = config.auto_reconnect; 

        conn_.reset(driver_->connect(options));
        
        Log(LogLevel::kInfo, "Successfully connected to database: " + config.database);
        return true;
    } catch (const sql::SQLException& e) {
        LogSqlError(e, "Connect");
        return false;
    }
}

bool EasyMySQL::CheckConnection() {
    if (!conn_ || conn_->isClosed()) {
        if (in_transaction_) {
            Log(LogLevel::kError, "Connection lost inside a transaction. Cannot auto-reconnect.");
            return false;
        }

        if (config_.auto_reconnect) {
            Log(LogLevel::kWarning, "Connection lost. Attempting to reconnect...");
            // Release the lock temporarily if Connect calls public methods, 
            // but here we are reusing logic. We need to be careful about recursion.
            // Since we are inside a locked scope (from public methods), 
            // we should not call Connect() which locks again (deadlock).
            // Instead, we duplicate the connection logic or refactor Connect to an internal _Connect.
            // For simplicity here, we assume direct driver call:
            
            try {
                 sql::ConnectOptionsMap options;
                options["hostName"] = config_.host;
                options["port"] = config_.port;
                options["userName"] = config_.user;
                options["password"] = config_.password;
                options["schema"] = config_.database;
                options["OPT_CONNECT_TIMEOUT"] = config_.connect_timeout;

                conn_.reset(driver_->connect(options));
                Log(LogLevel::kInfo, "Reconnected successfully.");
                return true;
            } catch (const sql::SQLException& e) {
                LogSqlError(e, "AutoReconnect");
                return false;
            }
        }
        return false;
    }
    return true;
}

bool EasyMySQL::Ping() {
    std::lock_guard<std::mutex> lock(conn_mutex_);
    return CheckConnection();
}

bool EasyMySQL::BeginTransaction() {
    std::lock_guard<std::mutex> lock(conn_mutex_);
    if (!CheckConnection()) return false;
    if (in_transaction_) return true; 

    try {
        conn_->setAutoCommit(false);
        in_transaction_ = true;
        Log(LogLevel::kDebug, "Transaction Started");
        return true;
    } catch (const sql::SQLException& e) {
        LogSqlError(e, "BeginTransaction");
        return false;
    }
}

bool EasyMySQL::Commit() {
    std::lock_guard<std::mutex> lock(conn_mutex_);
    if (!in_transaction_) return false;

    try {
        conn_->commit();
        conn_->setAutoCommit(true);
        in_transaction_ = false;
        Log(LogLevel::kDebug, "Transaction Committed");
        return true;
    } catch (const sql::SQLException& e) {
        LogSqlError(e, "Commit");
        return false;
    }
}

bool EasyMySQL::Rollback() {
    std::lock_guard<std::mutex> lock(conn_mutex_);
    if (!in_transaction_) return false;

    try {
        conn_->rollback();
        conn_->setAutoCommit(true);
        in_transaction_ = false;
        Log(LogLevel::kDebug, "Transaction Rolled Back");
        return true;
    } catch (const sql::SQLException& e) {
        LogSqlError(e, "Rollback");
        return false;
    }
}

void EasyMySQL::Log(LogLevel level, const std::string& msg) {
    if (logger_) {
        logger_(level, msg);
    } else {
        // Default fallback logging
        if (level == LogLevel::kError) {
            std::cerr << "[EasyMySQL] " << msg << std::endl;
        }
    }
}

void EasyMySQL::LogSqlError(const sql::SQLException& e, std::string_view sql) {
    std::stringstream ss;
    ss << "SQLException: " << e.what()
       << " (Code: " << e.getErrorCode() << ", State: " << e.getSQLState() << ")"
       << " [Context: " << sql << "]";
    Log(LogLevel::kError, ss.str());
}

// --- Transaction Guard Implementation ---

EasyMySQL::Transaction::Transaction(EasyMySQL* db) 
    : db_(db), committed_(false), valid_(false) {
    if (db_) {
        valid_ = db_->BeginTransaction();
    }
}

EasyMySQL::Transaction::~Transaction() {
    if (valid_ && !committed_ && db_) {
        db_->Rollback();
    }
}

bool EasyMySQL::Transaction::Commit() {
    if (valid_ && !committed_ && db_) {
        if (db_->Commit()) {
            committed_ = true;
            return true;
        }
    }
    return false;
}

}  // namespace easymysql