#include "SH_SqlDB.hpp"
#include "../API_log/SH_log.h"
#include "../common/SH_global.h"
#include <unistd.h>

bool SqlSwitch()
{
    if (access("./sql", 0) >= 0) {
        return true;
    }
    return false;
}

SqliteDB *sql_ctl = SqliteDB::instance();

SqliteDB::SqliteDB()
{
}

SqliteDB::~SqliteDB()
{
}

void SqliteDB::SqliteInit(const char *pDbName,  bool isDB2)
{
    char sql_exec[2048];
    memset(sql_exec, 0, 2048);

    //创建传感器信息存储表
    memset(sql_exec, 0, 2048);
    sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s);",
						T_SENSOR_INFO(TNAME),
						T_SENSOR_INFO(DATANODENO),
						T_SENSOR_INFO(DATANODENAME), 
					    T_SENSOR_INFO(INITFLAG), 
						T_SENSOR_INFO(ACCFLAG), 
						T_SENSOR_INFO(ZIGBEEFLAG), 
						T_SENSOR_INFO(TEMTOPFLAG),
						T_SENSOR_INFO(TEMBOTFLAG),
						T_SENSOR_INFO(EQUIPSTA),
						T_SENSOR_INFO(HARDVERSION),
						T_SENSOR_INFO(SOFTVERSION),
						T_SENSOR_INFO(BPNO),
						T_SENSOR_INFO(SERIALNO),
						T_SENSOR_INFO(FIRSTPOWERNO),
				        T_SENSOR_INFO(CONFIGFLAG),
						T_SENSOR_INFO(STARTBRANDS),
						T_SENSOR_INFO(STOPBRANDS),
						T_SENSOR_INFO(FEATUREINTERVAL),
						T_SENSOR_INFO(WAVEINTERVAL),
						T_SENSOR_INFO(SAMPLINGRATE),
						T_SENSOR_INFO(SCOPE),
						T_SENSOR_INFO(RANGE),
						T_SENSOR_INFO(ENVELOPEBANDPASS),
						T_SENSOR_INFO(FAULTFREQUENCY),
						T_SENSOR_INFO(ZIGBEEPANID),
						T_SENSOR_INFO(ZIGBEECHANNEL),
						T_SENSOR_INFO(ZIGBEESHORTADDR),
						T_SENSOR_INFO(ZIGBEELONGADDR),
						T_SENSOR_INFO(ZIGBEEDESADDR),
						T_SENSOR_INFO(STATUS),
						T_SENSOR_INFO(TIMESTAMP),
						T_SENSOR_INFO(VIFF),
    					T_SENSOR_INFO(RSSI)),
    CreateTable(sql_exec, isDB2);

    //创建传感器数据存储表
    memset(sql_exec, 0, 2048);
    sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s);", 
                       T_DATA_INFO(TNAME),
                       T_DATA_INFO(DATANODENO),
                       T_DATA_INFO(CHANNELID), 
                       T_DATA_INFO(DIAGNOSISEAK), 
                       T_DATA_INFO(INTEGRATPK), 
                       T_DATA_INFO(INTEGRATRMS), 
                       T_DATA_INFO(RMSVALUES),
                       T_DATA_INFO(ENVELOPNERGY),
                       T_DATA_INFO(AMP1),
                       T_DATA_INFO(AMP2),
                       T_DATA_INFO(AMP3),
                       T_DATA_INFO(AMP4),
                       T_DATA_INFO(AMP5),
                       T_DATA_INFO(PHASE1),
                       T_DATA_INFO(PHASE2),
                       T_DATA_INFO(PHASE3),
                       T_DATA_INFO(PHASE4),
                       T_DATA_INFO(TIMESTAMP));
    CreateTable(sql_exec, isDB2);



    //创建传感器静态数据存储表
    memset(sql_exec, 0, 2048);
    sprintf(sql_exec, "create table if not exists %s(%s,%s,%s,%s,%s,%s,%s);", 
                       T_DATASTATIC_INFO(TNAME),
                       T_DATASTATIC_INFO(DATANODENO),
                       T_DATASTATIC_INFO(CHANNELID), 
                       T_DATASTATIC_INFO(TEMTOP), 
                       T_DATASTATIC_INFO(TEMBOT), 
                       T_DATASTATIC_INFO(DIP), 
                       T_DATASTATIC_INFO(VOLTAGE),
                       T_DATASTATIC_INFO(TIMESTAMP));
    CreateTable(sql_exec, isDB2);    
}

bool SqliteDB::OpenDB(const char *pDbName, bool isDB2)
{
    if (isDB2 == false) {
        int ret = 0;
        ret = sqlite3_open(pDbName, &mDBAcess);
        if (ret == SQLITE_OK) {
            sqlite3_exec(mDBAcess, "PRAGMA synchronous = NORMAL;", 0, 0, 0);
            sqlite3_exec(mDBAcess, "PRAGMA cache_size=8000;", 0, 0, 0);
            sqlite3_exec(mDBAcess, "PRAGMA temp_store = MEMORY;", 0, 0, 0);
            sqlite3_exec(mDBAcess, "PRAGMA auto_vacuum = 1;", 0, 0, 0);
            print_info("Success To Open DataBase!\n");
        }
        else {
            print_error("Fail To Open DataBase!\n");
            return false;
        }
    }
    else {
        int ret = 0;
        ret = sqlite3_open(pDbName, &mDb2);
        if (ret == SQLITE_OK) {
            sqlite3_exec(mDb2, "PRAGMA synchronous = NORMAL;", 0, 0, 0);
            sqlite3_exec(mDb2, "PRAGMA cache_size=8000;", 0, 0, 0);
            sqlite3_exec(mDb2, "PRAGMA temp_store = MEMORY;", 0, 0, 0);
            sqlite3_exec(mDb2, "PRAGMA auto_vacuum = 1;", 0, 0, 0);
            print_info("Success To Open DataBase!\n");
        }
        else {
            print_error("Fail To Open DataBase!\n");
            return false;
        }
    }
    return true;
}

int SqliteDB::CloseDB()
{
    return sqlite3_close(mDBAcess);
}

sqlite3 *SqliteDB::GetDbHandle(bool isDB2)
{
    if (isDB2 == false) {
        return mDBAcess;
    }
    else {
        return mDb2;
    }
}

int SqliteDB::CreateTable(const char *sql, bool isDB2)
{
    print_light_green("%s\n", sql);
  //  if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", sql);
    char *msg;
    int iRet = sqlite3_exec(GetDbHandle(isDB2), sql, 0, 0, &msg);
    if (iRet != SQLITE_OK) {
        print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
        sqlite3_free(msg);
    }
    return iRet;
}

int SqliteDB::GetTableColumnCount(const char *tablename, bool isDB2)
{
    std::string  strSql = "select * from ";
    int count = 0;
    sqlite3_stmt *stmt;
    strSql = strSql + tablename + ";";
    print_light_green("%s\n", strSql.c_str());
  //  if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
    sqlite3_prepare_v2(GetDbHandle(isDB2), strSql.c_str(), -1, &stmt, 0);
    count = sqlite3_column_count(stmt);
    sqlite3_finalize(stmt);
    return count;
}

int SqliteDB::GetTableRows(const char *tablename, const char *whereCon)
{
    int nRow = 0;
    std::string  strSql = "select count(*) from ";
    if (whereCon != NULL) {
        strSql = strSql + tablename + " where " + whereCon + ";";
    }
    else {
        strSql = strSql + tablename + ";";
    }
    print_light_green("%s\n", strSql.c_str());
 //   if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
    sqlite3_stmt *stmt;
    if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
        print_error("sqlite3_prepare_v2:%s\n",sqlite3_errmsg(mDBAcess));
        sqlite3_finalize(stmt);
        return -1;
    }
    int retStep = sqlite3_step(stmt);
    if (retStep == SQLITE_ROW) {
        nRow = sqlite3_column_int(stmt, 0);
    }
    sqlite3_finalize(stmt);
    return nRow;
}

int SqliteDB::AlterTable(const char *tablename, const char *column, bool isAdd, bool isDB2)
{
    int iRet = SQLITE_ERROR;
    if (isAdd) {
        std::string strSql = "alter table ";
        strSql = strSql + tablename + " add " + column + ";";
        print_light_green("%s\n", strSql.c_str());
     //   if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
        iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, NULL);
        if (iRet != SQLITE_OK) {
            perror_info("sqlite3_exec");
        }
    }
    else {
    }
    return iRet;
}

vec_t SqliteDB::GetDataSingleLine(const char *tablename, const char *column, const char *whereCon)
{
    vec_t vecResult;
    std::string strSql = "select ";
    if (whereCon != NULL) {
        strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
    }
    else {
        strSql = strSql + column + " from " + tablename + ";";
    }
    print_light_green("%s\n", strSql.c_str());
 //   if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
    sqlite3_stmt *stmt;
    if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
        print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
        sqlite3_finalize(stmt);
        return vecResult;
    }
    int retStep = sqlite3_step(stmt);
    int column_count = sqlite3_column_count(stmt);
    if (retStep == SQLITE_ROW) {
        for (int iCol = 0; iCol < column_count; iCol++) {
            char *columninfo = (char*)sqlite3_column_text(stmt, iCol);
            std::string str = columninfo != NULL ? columninfo : "";
            vecResult.push_back(str);
        }
    }
    sqlite3_finalize(stmt);
    return vecResult;
}



std::string SqliteDB::GetData(const char *tablename, const char *column, const char *whereCon)
{
    std::string strRes;
    std::string strSql = "select ";
    if (whereCon != NULL) {
        strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
    }
    else {
        strSql = strSql + column + " from " + tablename + ";";
    }
    print_light_green("%s\n", strSql.c_str());
 //   if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
    sqlite3_stmt *stmt;
    if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
        print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
        sqlite3_finalize(stmt);
        return strRes;
    }
    int retStep = sqlite3_step(stmt);
    if (retStep == SQLITE_ROW) {
        char *columninfo = (char*)sqlite3_column_text(stmt, 0);
        strRes = columninfo != NULL ? columninfo : "";
    }
    sqlite3_finalize(stmt);
    return strRes;
}

array_t SqliteDB::GetDataMultiLine(const char *tablename, const char *column, const char *whereCon)
{
    array_t arrResult;
    std::string strSql = "select ";
    if (whereCon != NULL) {
        strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
    }
    else {
        strSql = strSql + column + " from " + tablename + ";";
    }
    print_light_green("%s\n", strSql.c_str());
//    if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
    sqlite3_stmt *stmt;
    if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
        print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
        sqlite3_finalize(stmt);
        return arrResult;
    }
    int retStep = sqlite3_step(stmt);
    int column_count = sqlite3_column_count(stmt);
    while (retStep == SQLITE_ROW) {
        vec_t vecResult;
        for (int iCol = 0; iCol < column_count; iCol++) {
            char *columninfo = (char*)sqlite3_column_text(stmt, iCol);
            std::string str = columninfo != NULL ? columninfo : "";
            vecResult.push_back(str);
        }
        arrResult.push_back(vecResult);
        retStep = sqlite3_step(stmt);
    }
    sqlite3_finalize(stmt);
    return arrResult;
}

vec_t SqliteDB::GetDataMultiLineOfOneColumn(const char *tablename, const char *column, const char *whereCon)
{
    vec_t vecResult;
    std::string strSql = "select ";
    if (whereCon != NULL) {
        strSql = strSql + column + " from " + tablename + " where " + whereCon + ";";
    }
    else {
        strSql = strSql + column + " from " + tablename + ";";
    }
    print_light_green("%s\n", strSql.c_str());
 //   if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
    sqlite3_stmt *stmt;
    if (sqlite3_prepare_v2(mDBAcess, strSql.c_str(), -1, &stmt, 0) != SQLITE_OK) {
        print_error("sqlite3_prepare_v2:%s\n", sqlite3_errmsg(mDBAcess));
        sqlite3_finalize(stmt);
        return vecResult;
    }
    int retStep = sqlite3_step(stmt);
    while (retStep == SQLITE_ROW) {
        char *columninfo = (char*)sqlite3_column_text(stmt, 0);
        std::string str = columninfo != NULL ? columninfo : "";
        vecResult.push_back(str);
        retStep = sqlite3_step(stmt);
    }
    sqlite3_finalize(stmt);
    return vecResult;
}



int SqliteDB::DeleteTableData(const char* tablename, const char* whereCond, bool isDB2)
{
    std::string strSql = "delete from ";
    if (whereCond != NULL) {
        strSql = strSql + tablename + " where " + whereCond + ";";
    }
    else {
        strSql = strSql + tablename + ";";
    }
    print_light_green("%s\n", strSql.c_str());
 //   if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
    char *msg;
    int iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, &msg);

    if (iRet != SQLITE_OK) {
        print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
        sqlite3_free(msg);
    }
    return iRet;
}

int SqliteDB::DeleteTableDataOneConditon(const char* tablename, const char* condColumnName, const char * condColumnValue, bool isDB2)
{
    std::string strSql = "delete from ";
    if (condColumnName != NULL) {
        strSql = strSql + tablename + " where " + condColumnName + "='" + condColumnValue + "';";
    }
    else {
        strSql = strSql + tablename + ";";
    }
    print_light_green("%s\n", strSql.c_str());
//    if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
    char *msg;
    int iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, &msg);

    if (iRet != SQLITE_OK) {
        print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
        sqlite3_free(msg);
    }
    return iRet;
}

int SqliteDB::UpdateTableData(const char* tablename, const char* updateColumn, const char* whereCond, bool isDB2)
{
    std::string strSql = "update ";
    if (whereCond != NULL) {
        strSql = strSql + tablename + " set " + updateColumn + " where " + whereCond + ";";
    }
    else {
        strSql = strSql + tablename + " set " + updateColumn + ";";
    }
    print_light_green("%s\n", strSql.c_str());
//    if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
    char *msg;
    int iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, &msg);

    if (iRet != SQLITE_OK) {
        print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
        sqlite3_free(msg);
    }
    return iRet;
}

int SqliteDB::UpdateTableData(const char* directSql, bool isDB2)
{
    print_light_green("%s\n", directSql);
//    if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", directSql);
    char *msg;
    int iRet = sqlite3_exec(GetDbHandle(isDB2), directSql, 0, 0, &msg);

    if (iRet != SQLITE_OK) {
        print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
        sqlite3_free(msg);
    }
    return iRet;
}

int SqliteDB::UpdateTableDataOneColumn(const char* tablename, const char* columnName, const char* columnValue, const char* whereColName, const char * whereColValue, bool isDB2)
{
    std::string strSql = "update ";
    if (whereColName != NULL) {
        strSql = strSql + tablename + " set " + columnName + "='" + columnValue + "'" + " where " + whereColName + "='" + whereColValue + "';";
    }
    else {
        strSql = strSql + tablename + " set " + columnName + "='" + columnValue + "';";
    }
    print_light_green("%s\n", strSql.c_str());
 //   if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
    char *msg;
    int iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, &msg);

    if (iRet != SQLITE_OK) {
        print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
        sqlite3_free(msg);
    }
    return iRet;
}

int SqliteDB::InsertData(const char* tablename, const char* insertValues, int replace, bool expandable, bool isDB2)
{
    char *msg;
    int iRet = 0;
    if (expandable) {
        char *strSql = (char *)malloc(4096);
        if (strSql == NULL) {
            print_error("malloc error\n");
            abort();
        }
        char strReplace[] = "replace into ";
        memset(strSql, 0, 4096);
        if (replace == 0) {
            memset(strReplace, 0, sizeof(strSql));
        }
        sprintf(strSql, "%s %s%s %s %s %s", "insert into", strReplace, tablename, "values(", insertValues, ");");
        print_light_green("%s\n", strSql);
//        if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql);
        iRet = sqlite3_exec(GetDbHandle(isDB2), strSql, 0, 0, &msg);

        free(strSql);
    } else {
        std::string strSql = "insert into ";
        if (replace != 0) {
            strSql = "replace into ";
        }
        strSql = strSql + tablename + " values(" + insertValues + ");";
        print_light_green("%s\n", strSql.c_str());
//        if (SqlSwitch()) log_system->log_write_system("[info]","%s\n", strSql.c_str());
        iRet = sqlite3_exec(GetDbHandle(isDB2), strSql.c_str(), 0, 0, &msg);
    }
    if (iRet != SQLITE_OK) {
        print_error("sqlite3 error: code=%d msg=%s\n", iRet, msg);
        sqlite3_free(msg);
    }
    return iRet;
}

int SqliteDB::TransBegin()
{
    return sqlite3_exec(mDBAcess, "begin;", 0, 0, 0);
}

int SqliteDB::TransRollback()
{
    return sqlite3_exec(mDBAcess, "rollback;", 0, 0, 0);
}

int SqliteDB::TransCommit()
{
    return sqlite3_exec(mDBAcess, "commit;", 0, 0, 0);
}

void SqliteDB::HandError(int code)
{
    if (code == SQLITE_CORRUPT) {
    /*
    * 用system 删除数据库 
    */
        exit(1);
    }
}