#include <fstream>
#include <iostream>
#include <sstream>
#include <vector>
#include <iterator>

#include "log_db.h"

#ifdef _WIN32
#include <io.h>
#include <direct.h>
#include "atlbase.h"
#endif //_WIN32

#include "CMBSMDLL.h"
#include "CppSQLite3.h"
#include "inner_log.h"
#include "log_util.h"
#include <vector>
#include <sys/stat.h>
#include "zlib.h"
#include "base64_openssl.h"
#include <chrono>
#include "baseFun.h"
#include <log_producer_client.h>

#ifndef _WIN32


char* itoa(int value, char* buffer, int radix)
{
    char* p;
    unsigned int a;
    //int len;
    char* b;
    char temp;
    unsigned  int u;

    p = buffer;

    if (value < 0) {
        *p++ = '-';
        value = 0 - value;
    }

    u = (unsigned int)value;
    b = p;

    do {
        a = u % radix;
        u /= radix;
        *p++ = a + '0';
    } while (u > 0);

    //len = (int)(p-buffer);
    *p-- = 0;

    do {
        temp = *p;
        *p = *b;
        *b = temp;
        --p;
        ++b;
    } while (b < p);

    return buffer;
}
#endif // _WIN32


#define MAX_CACHEDB_SIZE 500*1024*1024
#define MIN_CACHEFREQUENCE_SIZE 50
#define COMPRESS_CONTEXT

const std::string COLUMN_ID = "id";
const std::string COLUMN_DateTime = "date_time";
const std::string COLUMN_Uuid = "uuid";
const std::string COLUMN_Level = "level";
const std::string COLUMN_Type = "type";
const std::string COLUMN_Status = "status";
const std::string COLUMN_Encrypt = "encrypt";
const std::string COLUMN_Content = "content";

int db_move_to_main(log_db_manager* manager);

struct _log_db_manager {
	log_producer_config* config;
	 CppSQLite3DB *db;
	 std::string file_path;
	 std::string file_name;
	 std::string table_name;
};


log_db_manager* create_log_db(log_producer_config* config, char* base_path, char* file_name, char* table_name) {
	std::string str_file_name, dstFile;
	if (base_path == NULL || table_name == NULL || file_name == NULL) {
		aos_debug_log((LB, "create log db failed for null"));
		return NULL;
	}

	auto getFileSize = [](const char* fileName) -> int {

		if (fileName == NULL) {
			return -1;
		}

		struct stat statbuf;
		if (stat(fileName, &statbuf) == -1)
			return -1;

		// 获取文件大小
		size_t filesize = statbuf.st_size;

		return filesize;
	};

	auto IsFileOutDate = [](const char* fileName) -> bool
	{
		if (fileName == NULL) {
			return false;
		}

		struct stat statbuf;
		if (stat(fileName, &statbuf) == -1)
			return false;
		
		auto modifyTime = statbuf.st_mtime;
		auto curTime = time(nullptr);
		return (curTime - modifyTime) > 3600 * 72;//3 days
	};

	dstFile = std::string(base_path) + std::string(file_name);
	auto curFileSize = getFileSize(dstFile.c_str());
	const int MAX_DB_SIZE = 50 * 1024 * 1024;
	if (IsFileOutDate(dstFile.c_str()) || curFileSize > MAX_DB_SIZE) {
#if defined(_MSC_VER)
		DeleteFile(dstFile.c_str());
#else
		int status;
		status = unlink(dstFile.c_str());
#endif //_MSC_VER
	}
		

	log_db_manager*log_db = new log_db_manager();
	log_db->file_path = base_path;

	str_file_name = file_name;
	log_db->file_name = str_file_name;

	log_db->table_name = table_name;
	log_db->db = new CppSQLite3DB();
	log_db->config = config;

	aos_debug_log((LB, "create log db success, db file_path %s, file_name %s, table_name %s",
		log_db->file_path.c_str(), log_db->file_name.c_str(), log_db->table_name.c_str()));
	return log_db;
}


void destroy_log_db(log_db_manager* manager) {
	if (manager != NULL) {
		if (manager != NULL) {
			try {
				if (manager->db)
				{
					manager->db->close();
					delete manager->db;
					manager->db = NULL;
				}
			}
			catch (...) {
				aos_error_log((LB, "close log db name %s failed.", manager->file_name.c_str()));
			}
		}
		aos_debug_log((LB, "destroy log db %s", manager->file_name.c_str()));
		delete manager;
		manager = NULL;
	}
}

bool createFile(std::string fileName) {
	std::fstream file;
	file.open(fileName, std::ios::out);
	if (!file) {
		return false;
	}
	file.close();
	return true;
}


int open_db(log_db_manager * manager) {
	if (manager == NULL || manager->db == NULL) {
		aos_error_log((LB, "open log db %s failed for null.", manager->file_name.c_str()));
		return false;
	}

	bool ret = true;
	try {
		std::string full_file_name;
		int mk_ret = mkdir_foreach((char*)manager->file_path.c_str(), manager->file_path.length());
		if (mk_ret < 0){
			aos_error_log((LB, "make log db %s file path failed.", manager->file_name.c_str()));
			return false;
		}
		full_file_name = manager->file_path + manager->file_name;
		char* name = (char*)full_file_name.c_str();
		manager->db->open(name);
		if (!db_is_exist_table_ex(manager, (char *)manager->table_name.c_str())) {
			std::string strCreateTable = "CREATE TABLE IF NOT EXISTS ";
			strCreateTable.append(manager->table_name).append(" (" +
				//COLUMN_ID + " INTEGER DEFAULT '1' NOT NULL PRIMARY KEY AUTOINCREMENT," +
				COLUMN_DateTime + " INTEGER," +
				COLUMN_Uuid + " TEXT NOT NULL PRIMARY KEY," +
				COLUMN_Level + " INTEGER," +
				COLUMN_Type + " INTEGER," +
				COLUMN_Status + " INTEGER DEFAULT 0," +
				COLUMN_Encrypt + " INTEGER DEFAULT 0," +
				COLUMN_Content + " TEXT" +
				");");
			
			int CTRet = manager->db->execDML(strCreateTable.c_str());
			//aos_debug_log((LB, "create log table result %d, db name %s", CTRet, name));
		}
		//manager->db->execDML("PRAGMA synchronous = FULL;");
	}
	catch (CppSQLite3Exception& e)
	{
		aos_error_log((LB, "open log db %s error %s", manager->file_name.c_str(), e.errorMessage()));
		if (manager->db != NULL) {
			try {
				manager->db->close();
			}
			catch (...) {
				aos_error_log((LB, "close log db %s failed.", manager->file_name.c_str()));
			}
			delete manager->db;
			manager->db = NULL;
		}
		ret = false;
	}
	return ret;
}


void close_logdb(log_db_manager* manager)
{
	if (manager!= NULL && manager->db != NULL) {
		try {
			manager->db->close();
		}
		catch (...) {
			aos_error_log((LB, "close log db %s failed.", manager->file_name.c_str()));
		}
		delete manager->db;
		manager->db = NULL;
	}
}

int drop_db(log_db_manager* manager)
{
	if (manager == NULL || manager->db == NULL) {
		aos_error_log((LB, "drop log db %s failed for null.", manager->file_name.c_str()));
		return false;
	}

	bool ret = true;
	try {
		std::string strSql = "DROP TABLE IF EXISTS ";
		strSql.append(manager->table_name);
		int CTRet = manager->db->execDML(strSql.c_str());
		aos_debug_log((LB, "drop log db %s result %d table name %s", manager->file_name.c_str(), CTRet, manager->table_name.c_str()));
	}
	catch (CppSQLite3Exception& e)
	{
		aos_error_log((LB, "drop log db %s error %s", manager->file_name.c_str(), e.errorMessage()));
		ret = false;
	}

	return ret;
}

int db_insert_group(log_db_manager* manager, log_group_builder* builder) {
	if (manager == NULL || manager->db == NULL) {
		aos_error_log((LB, "insert log db %s failed for null.", manager->file_name.c_str()));
		return false;
	}

	int ret = true;
	serialize_buf buf;
	
	for (int i = 0; i < builder->grp->n_logs; i++) {
		memset(&buf, 0, sizeof(serialize_buf));
		serialize_to_buf(&builder->grp->logs[i], &buf);
		ret = db_insert_one(manager, &buf);
		
	}
	return ret;
}

int db_insert_one(log_db_manager* manager, serialize_buf* buf) {
	if (manager == NULL || manager->db == NULL) {
		aos_error_log((LB, "insert log db %s failed for null.", manager->file_name.c_str()));
		return false;
	}

	int ret = true;
	std::string strSql = "insert into ";
	long time = LOG_GET_TIME();
	char strTime[128];
	char strLevel[32];
	char strType[32];
	char strEncrypt[32];
	sprintf(strTime, "%ld", time);

	sprintf(strLevel, "%d", buf->level);
	sprintf(strType, "%d", buf->type);
	sprintf(strEncrypt, "%d", manager->config->usePersistentEncrypt);

	unsigned long end_time;
	unsigned long start_time = GetTickCount();

	//SM4加密，密文会比明文长16字节
	if (manager->config->usePersistentEncrypt == 1) {
		int input_length = strlen(buf->buffer) + 1;
		unsigned char* input_data = (unsigned char*)buf->buffer;

		int output_length = input_length + 16;
		unsigned char* output_data = (unsigned char*)malloc(output_length);
		CMBSM4EncryptWithECB((unsigned char*)manager->config->PersistentEncryptPassword,	input_data, input_length, output_data, &output_length);

		char* output_str_data = (char*)malloc(output_length * 2 + 1);
		memset(output_str_data, 0, output_length * 2 + 1);
		convertUnCharTotr(output_str_data, output_data, output_length);

		strSql.append(manager->table_name).append("(" + COLUMN_DateTime +
			"," + COLUMN_Uuid + "," + COLUMN_Level + "," + COLUMN_Type + "," + COLUMN_Content + "," + COLUMN_Encrypt + "," + COLUMN_Status +
			") VALUES (").append(strTime).append(",'").append(buf->uuid).append("',").
			append(strLevel).append(",").append(strType).append(",'").
			append(output_str_data).append("',").append(strEncrypt).append(",0)");

		free(output_data);
		free(output_str_data);
		end_time = GetTickCount();
		//aos_debug_log((LB, "db_insert_one Encrypt cust %d", end_time - start_time));
	}
	else if(manager->config->usePersistentEncrypt == 2)
	{
		int input_length = strlen(buf->buffer) + 1;
		unsigned char* input_data = (unsigned char*)buf->buffer;

		unsigned long compressLen = input_length * 2 + 1;
		unsigned char* compress_str_data = (unsigned char*)malloc(compressLen);
		memset(compress_str_data, 0, compressLen);
		compress(compress_str_data, &compressLen, (unsigned char*)input_data, input_length);

		int output_length = compressLen + 16;
		unsigned char* output_data = (unsigned char*)malloc(output_length);
		CMBSM4EncryptWithECB((unsigned char*)manager->config->PersistentEncryptPassword, compress_str_data, compressLen, output_data, &output_length);
		char* output_str_data = openssl_base64_encode((char*)output_data, output_length);

		//try to decrypt
		/*
		char* input_str_data = output_str_data;

		char* decoded_bytes = NULL;
		size_t decoded_length = 0;
		openssl_base64_decode(input_str_data, &decoded_bytes, &decoded_length);

		int SM4_length = decoded_length;
		char* SM4_data = (char*)malloc(decoded_length);
		memset(SM4_data, 0, decoded_length);
		CMBSM4DecryptWithECB((unsigned char*)manager->config->PersistentEncryptPassword,
			(unsigned char*)decoded_bytes, decoded_length, (unsigned char*)SM4_data, &SM4_length);

		uLongf uncompress_length = SM4_length * 3;
		char *output_data2 = (char*)malloc(uncompress_length);
		memset(output_data2, 0, uncompress_length);

		uncompress((unsigned char*)output_data2, &uncompress_length, (unsigned char*)SM4_data, SM4_length);
		if(SM4_data)
			free(SM4_data);
		if(decoded_bytes)
			free(decoded_bytes);
			*/

		strSql.append(manager->table_name).append("(" + COLUMN_DateTime +
			"," + COLUMN_Uuid + "," + COLUMN_Level + "," + COLUMN_Type + "," + COLUMN_Content + "," + COLUMN_Encrypt + "," + COLUMN_Status +
			") VALUES (").append(strTime).append(",'").append(buf->uuid).append("',").
			append(strLevel).append(",").append(strType).append(",'").
			append((char*)output_str_data).append("',").append(strEncrypt).append(",0)");

		if(compress_str_data)
			free(compress_str_data);
		if(output_data)
			free(output_data);
		if(output_str_data)
			free(output_str_data);
		end_time = GetTickCount();
	}
	else if (manager->config->usePersistentEncrypt == 3)
	{
		if (strlen(buf->buffer) == 0)
			return ret;
		int input_length = strlen(buf->buffer) + 1;
		unsigned char* input_data = (unsigned char*)buf->buffer;

		int output_length = input_length + 16;
		unsigned char* output_data = (unsigned char*)malloc(output_length);
		CMBSM4EncryptWithECB((unsigned char*)manager->config->PersistentEncryptPassword, input_data, input_length, output_data, &output_length);
		char* output_str_data = openssl_base64_encode((char*)output_data, output_length);

		//try to decrypt
		/*
		char* input_str_data = output_str_data;

		char* decoded_bytes = NULL;
		size_t decoded_length = 0;
		openssl_base64_decode(input_str_data, &decoded_bytes, &decoded_length);

		int SM4_length = decoded_length;
		char* SM4_data = (char*)malloc(decoded_length);
		memset(SM4_data, 0, decoded_length);
		CMBSM4DecryptWithECB((unsigned char*)manager->config->PersistentEncryptPassword,
			(unsigned char*)decoded_bytes, decoded_length, (unsigned char*)SM4_data, &SM4_length);
		//RvcLogSdkManager::getInstance().SendTestLog(output_str_data);

		if(SM4_data)
			free(SM4_data);
		if(decoded_bytes)
			free(decoded_bytes);
		*/
		/*
		if (buf->type == LOG_TYPE_BEIDOU)
		{
			std::string dstLog = std::string(buf->uuid) + " db_insert_one_beidou encrypt3";
			log_producer_sendTestLog_loki("RVCLogSDK", buf->uuid, dstLog.c_str());
		}
		else
		{
			std::string dstLog = std::string(buf->uuid) + " db_insert_one_skyeye encrypt3";
			log_producer_sendTestLog_loki("RVCLogSDK", buf->uuid, dstLog.c_str());
		}
		*/
		

		strSql.append(manager->table_name).append("(" + COLUMN_DateTime +
			"," + COLUMN_Uuid + "," + COLUMN_Level + "," + COLUMN_Type + "," + COLUMN_Content + "," + COLUMN_Encrypt + "," + COLUMN_Status +
			") VALUES (").append(strTime).append(",'").append(buf->uuid).append("',").
			append(strLevel).append(",").append(strType).append(",'").
			append((char*)output_str_data).append("',").append(strEncrypt).append(",0)");

		if (output_data)
			free(output_data);
		if (output_str_data)
			free(output_str_data);
		end_time = GetTickCount();
	}
	else {
#ifdef COMPRESS_CONTEXT
        unsigned char dstBuf[10000] = "";
        unsigned long len = 10000;
        compress(dstBuf, &len, (unsigned char*)buf->buffer, buf->buffer_len);
        strSql.append(manager->table_name).append("(" + COLUMN_DateTime +
                                                  "," + COLUMN_Uuid + "," + COLUMN_Level + "," + COLUMN_Type + "," + COLUMN_Content + "," + COLUMN_Encrypt + "," + COLUMN_Status +
                                                  ") VALUES (").append(strTime).append(",'").append(buf->uuid).append("',").
            append(strLevel).append(",").append(strType).append(",'").
            append((char*)dstBuf).append("',").append(strEncrypt).append(",0)");
#else
        strSql.append(manager->table_name).append("(" + COLUMN_DateTime +
                                                  "," + COLUMN_Uuid + "," + COLUMN_Level + "," + COLUMN_Type + "," + COLUMN_Content + "," + COLUMN_Encrypt + "," + COLUMN_Status +
                                                  ") VALUES (").append(strTime).append(",'").append(buf->uuid).append("',").
            append(strLevel).append(",").append(strType).append(",'").
            append((char*)buf->buffer).append("',").append(strEncrypt).append(",0)");
#endif

	}

	try {
		int CTRet = manager->db->execDML(strSql.c_str());
		end_time = GetTickCount();
		//aos_debug_log((LB, "db_insert_one execDML cust %d", end_time - start_time));
		//aos_debug_log((LB, "db %s insert one log result %d, log uuid %s", manager->file_name.c_str(), CTRet, buf->uuid));
	}
	catch (CppSQLite3Exception& e)
	{
		aos_error_log((LB, "db %s insert one log error %s, log uuid %s", manager->file_name.c_str(), e.errorMessage(), buf->uuid));
		ret = false;
	}
	
	return ret;
}




int getReadType()
{
	static unsigned int sum = 0;
	sum = sum % 100;
	sum++;
	int cmpData = sum % 11;
	if (cmpData <= 5)
		return build_type_e::LOG_TYPE_SYS_SKYEYE;
	else if (cmpData <= 6)
		return build_type_e::LOG_TYPE_BEIDOU;
	else if (cmpData <= 7)
		return build_type_e::LOG_TYPE_USER_SKYEYE;
	else if (cmpData <= 8)
		return build_type_e::LOG_TYPE_USER_BUSINESS;
	else if (cmpData <= 9)
		return build_type_e::LOG_TYPE_SYS_BUSINESS;
	else if (cmpData <= 10)
		return build_type_e::LOG_TYPE_WEBSDK;
	else
		return 1;

}

log_group_builder* db_read_table_last_logs(log_db_manager* manager, int count) {
	if (manager == NULL || manager->db == NULL) {
		aos_error_log((LB, "read last logs db %s failed for null.", manager->file_name.c_str()));
		return NULL;
	}
	build_item log;
	char strStatus[32];
	char strCount[32];
	log_group_builder* builder = log_group_create(manager->config);
	sprintf(strStatus, "%d", LOG_DB_STATUS_SENDING);
	sprintf(strCount, "%d", count);
	std::string querySql = "select * from ";
	querySql.append(manager->table_name);
	int readType = getReadType();
	querySql.append(" where " + COLUMN_Status + " != ").append(strStatus).append(" AND ").append(COLUMN_Type).append("=").append(std::to_string((long long)readType));
	querySql.append(/*" order by " + COLUMN_DateTime + */" LIMIT ").append(strCount).append(";");

	try {
		CppSQLite3Query q = manager->db->execQuery(querySql.c_str());

		if (q.eof())
		{
			//if can not find, try to get LOG_TYPE_SYS_SKYEYE logs
			std::string searchSys= "select * from ";
			searchSys.append(manager->table_name);
			searchSys.append(" where " + COLUMN_Status + " != ").append(strStatus);
			searchSys.append(/*" order by " + COLUMN_DateTime + */" LIMIT ").append(strCount).append(";");
			q = manager->db->execQuery(searchSys.c_str());
		}

		while (!q.eof()) {
			int encrypt = q.getIntField(COLUMN_Encrypt.c_str(), 0);
			log.type = (build_type_e)q.getIntField(COLUMN_Type.c_str(), LOG_TYPE_USER_SKYEYE);
			//只获取同一类型的日志
			if (builder->grp->n_logs != 0 && builder->grp->logs[0].type != log.type) {
				q.nextRow();
				continue;
			}
			strcpy(log.uuid, q.getStringField(COLUMN_Uuid.c_str()));
			log.level = (LOG_LEVEL_E)q.getIntField(COLUMN_Level.c_str(), LOG_LEVEL_DEBUG);
			//content
			char* output_data = NULL;
			if (encrypt == 1) {
				char* input_str_data = (char*)q.getStringField(COLUMN_Content.c_str());
				int input_length = strlen(input_str_data) / 2;
				unsigned char* input_data = (unsigned char*)malloc(input_length);
				memset(input_data, 0, input_length);

				convertStrToUnChar(input_str_data, input_data);
				int output_length = input_length;
				output_data = (char*)malloc(input_length);
				memset(output_data, 0, input_length);

				CMBSM4DecryptWithECB((unsigned char*)manager->config->PersistentEncryptPassword,
					input_data, input_length, (unsigned char*)output_data, &output_length);

				log.buffer = output_data;
				log.buffer_len = strlen(log.buffer) + 1;
				add_log_raw(builder, &log);
				free(input_data);
			}
			else if (encrypt == 2) {
				char* input_str_data = (char*)q.getStringField(COLUMN_Content.c_str());

				char* decoded_bytes = NULL;
				size_t decoded_length = 0;
				openssl_base64_decode(input_str_data, &decoded_bytes, &decoded_length);

				int SM4_length = decoded_length;
				char *SM4_data = (char*)malloc(decoded_length);
				memset(SM4_data, 0, decoded_length);
				CMBSM4DecryptWithECB((unsigned char*)manager->config->PersistentEncryptPassword,
					(unsigned char*)decoded_bytes, decoded_length, (unsigned char*)SM4_data, &SM4_length);

				uLongf uncompress_length = SM4_length * 3;
				output_data = (char*)malloc(uncompress_length);
				memset(output_data, 0, uncompress_length);

				uncompress((unsigned char*)output_data, &uncompress_length, (unsigned char*)SM4_data, SM4_length);

				log.buffer = (char*)output_data;
				log.buffer_len = strlen(log.buffer) + 1;
				add_log_raw(builder, &log);
				free(SM4_data);
				free(decoded_bytes);
			}
			else if (encrypt == 3) {
				char* input_str_data = (char*)q.getStringField(COLUMN_Content.c_str());

				char* decoded_bytes = NULL;
				size_t decoded_length = 0;
				openssl_base64_decode(input_str_data, &decoded_bytes, &decoded_length);

				int SM4_length = decoded_length;
				char* SM4_data = (char*)malloc(decoded_length);
				memset(SM4_data, 0, decoded_length);
				CMBSM4DecryptWithECB((unsigned char*)manager->config->PersistentEncryptPassword,
					(unsigned char*)decoded_bytes, decoded_length, (unsigned char*)SM4_data, &SM4_length);

				

				log.buffer = (char*)SM4_data;
				log.buffer_len = strlen(log.buffer) + 1;
				add_log_raw(builder, &log);
				free(SM4_data);
				free(decoded_bytes);
			}
			else {
				std::string src = (char*)q.getStringField(COLUMN_Content.c_str());
#ifdef COMPRESS_CONTEXT
                unsigned char dst[10000] = "";
                uLongf dstLen = 10000;
                uncompress(dst, &dstLen, (unsigned char*)src.c_str(), src.length());
                log.buffer = (char*)dst;
                log.buffer_len = dstLen + 1;
#else
                log.buffer = (char*)q.getStringField(COLUMN_Content.c_str());
				log.buffer_len = strlen(log.buffer) + 1;
#endif // COMPRESS_CONTEXT
				add_log_raw(builder, &log);
			}
			strcpy(builder->modular, manager->file_name.c_str());
			
			if (output_data != NULL) {
				free(output_data);
			}
			//aos_debug_log((LB, "read last log db %s, uuid %s.", manager->file_name.c_str(), log.uuid));

			q.nextRow();
		}
		q.finalize();
	}
	catch (CppSQLite3Exception& e)
	{
		aos_error_log((LB, "db %s read logs error %s, querySql %s", manager->file_name.c_str(), e.errorMessage(), querySql.c_str()));
		log_group_destroy(builder);
		return NULL;
	}
	if (builder->grp->n_logs == 0) {
		log_group_destroy(builder);
		return NULL;
	}
	return builder;
}

int db_delete_old_logs(log_db_manager* manager, int count) {
	if (manager == NULL || manager->db == NULL) {
		aos_error_log((LB, "delete old logs db %s failed for null.", manager->file_name.c_str()));
		return false;
	}

	int ret = true;
	char strCount[64];
	itoa(count, strCount, 10);
	std::string sql = "delete from ";
	sql.append(manager->table_name);
    sql.append(" where "+ COLUMN_Uuid + " in (select " + COLUMN_Uuid + " from "+ manager->table_name +" order by " + COLUMN_DateTime + " ASC LIMIT " + strCount+")");
	sql.append(";");

	try {
		int CTRet = manager->db->execDML(sql.c_str());
		aos_debug_log((LB, "db %s delete old log result %d table name %s", manager->file_name.c_str(), CTRet, manager->table_name.c_str()));
	}
	catch (CppSQLite3Exception& e)
	{
		aos_error_log((LB, "db %s delete old log error %s", manager->file_name.c_str(), e.errorMessage()));
		ret = false;
	}
	return ret;
}


int db_delete_one(log_db_manager* manager, char* uuid) {
	if (manager == NULL || manager->db == NULL) {
		aos_error_log((LB, "delete one log db %s failed for null.", manager->file_name.c_str()));
		return false;
	}

	int ret = true;
	std::string sql = "delete from ";
	sql.append(manager->table_name);
	sql.append(" where "+ COLUMN_Uuid + " = '").append(uuid).append("';");

	try {
		int CTRet = manager->db->execDML(sql.c_str());
		/*
		aos_debug_log((LB, "db %s delete one uuid:%s log result %d", manager->file_name.c_str(), uuid, CTRet));
		if (CTRet != 1)
			MessageBox(NULL, NULL, NULL, 0);
		*/
	}
	catch (CppSQLite3Exception& e)
	{
		aos_error_log((LB, "db %s delete one log error %s, log uuid %s", manager->file_name.c_str(), e.errorMessage(), uuid));
		ret = false;
	}
	return ret;
}



#if defined(_WIN32)
#include <windows.h>
#else
#include <dirent.h>
#include <cstring>
#endif
#include <winpr/file.h>
#include <uuid4.h>
#include <winpr/library.h>
#include "../libtoolkit/path.h"

std::vector<std::string> scan_db_files(const std::string& directory) {
	std::vector<std::string> db_files;

#if defined(_WIN32)
	std::string search_path = directory + "/RvcLogSdk_*.db";
	WIN32_FIND_DATA find_file_data;
	HANDLE hFind = FindFirstFile(search_path.c_str(), &find_file_data);

	if (hFind == INVALID_HANDLE_VALUE) {
		std::cerr << "No files found." << std::endl;
	}
	else {
		do {
			std::string filename = find_file_data.cFileName;
			if (filename.size() > 3 && filename.substr(filename.size() - 3) == ".db") {
				db_files.push_back(directory + "/" + filename);
			}
		} while (FindNextFile(hFind, &find_file_data) != 0);
		FindClose(hFind);
	}
#else
	DIR* dir = opendir(directory.c_str());
	if (dir != nullptr) {
		struct dirent* entry;
		while ((entry = readdir(dir)) != nullptr) {
			std::string filename = entry->d_name;
			if (filename.rfind("RvcLogSdk_", 0) == 0 && filename.size() > 3 && filename.substr(filename.size() - 3) == ".db") {
				db_files.push_back(directory + "/" + filename);
			}
		}
		closedir(dir);
	}
	else {
		std::cerr << "Failed to open directory." << std::endl;
	}
#endif

	return db_files;
}

int db_get_count(log_db_manager* manager) {
	static auto start_time = std::chrono::high_resolution_clock::now();
	if (manager == NULL || manager->db == NULL) {
		aos_error_log((LB, "get db %s count failed for null.", manager->file_name.c_str()));
		return 0;
	}

	int ret = 0;
	std::string sql = "select count(";
	sql.append(COLUMN_Uuid).append(") from ");
	sql.append(manager->table_name);

	try {
		ret = manager->db->execScalar(sql.c_str());
		g_notUploadLogNum = ret;
		//aos_debug_log((LB, "db %s get count %d", manager->file_name.c_str(), ret));
	}
	catch (CppSQLite3Exception& e)
	{
		aos_error_log((LB, "get db %s count error %s", manager->file_name.c_str(), e.errorMessage()));
		ret = 0;
	}
	
	


	auto elapsed_time = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::high_resolution_clock::now() - start_time);
	if (elapsed_time.count() > 120 && ret < 500)
	{
		db_move_to_main(manager);
		start_time = std::chrono::high_resolution_clock::now();
	}
	

	return ret;
}


int db_move_to_main(log_db_manager* manager)
{
	if (manager == NULL || manager->db == NULL) {
		aos_error_log((LB, "db_move_to_main get db %s count failed for null.", manager->file_name.c_str()));
		return 0;
	}
	char tmp[MAX_PATH];
	GetModuleFileNameA(NULL, tmp, MAX_PATH);
	*strrchr(tmp, SPLIT_SLASH) = 0;
	*strrchr(tmp, SPLIT_SLASH) = 0;
	*strrchr(tmp, SPLIT_SLASH) = 0;
	*strrchr(tmp, SPLIT_SLASH) = 0;
	*strrchr(tmp, SPLIT_SLASH) = 0;
	sprintf(tmp, "%s" SPLIT_SLASH_STR "rvc" SPLIT_SLASH_STR "terminaldbstorage" SPLIT_SLASH_STR "RVC.LogSdk", tmp);


	auto db_files = scan_db_files(tmp);
	if (db_files.size() == 0)
		return 0;

	auto uuidStr = "sql"+uuid4_generate(8);
	int ret = true;
	char *zSql = sqlite3_mprintf(
		"ATTACH DATABASE \"%s\" AS %s;\n"
		"INSERT OR IGNORE INTO RvcLogTable SELECT * FROM %s.RvcLogTable;\n"
		"DELETE FROM %s.RvcLogTable;\n"
		"DETACH DATABASE %s;\n",
		db_files[0].c_str(), uuidStr.c_str(), uuidStr.c_str(), uuidStr.c_str(), uuidStr.c_str()
	);
	std::string sqlStr = zSql;
	sqlite3_free(zSql);
	try {
		ret = manager->db->execDML(sqlStr.c_str()); // if failed, it will throw exception
		DeleteFile(db_files[0].c_str());
	}
	catch (CppSQLite3Exception& e)
	{
		ret = false;
	}
	return ret;


}


int db_update_status(log_db_manager* manager, char* uuid, log_db_status_e status) {
	if (manager == NULL || manager->db == NULL) {
		aos_error_log((LB, "db %s update log status failed for null.", manager->file_name.c_str()));
		return false;
	}

	int ret = true;
	char strStatus[32];
	char strSendingStatus[32];
	sprintf(strSendingStatus, "%d", LOG_DB_STATUS_SENDING);
	sprintf(strStatus, "%d", status);
	std::string sql = "update ";
	sql.append(manager->table_name);
	sql.append(" set " + COLUMN_Status + " = ").append(strStatus);
	if (uuid == NULL) {
		//sql.append(";");
		sql.append(" where " + COLUMN_Status + " = ").append(strSendingStatus).append(";");
	}
	else {
		sql.append(" where " + COLUMN_Uuid + " = '").append(uuid).append("';");
	}

	try {
		int CTRet = manager->db->execDML(sql.c_str());
		//aos_debug_log((LB, "db %s update one uuid:%s status:%d log result %d", manager->file_name.c_str(), uuid, status, CTRet));
	}
	catch (CppSQLite3Exception& e)
	{
		aos_error_log((LB, "db %s update one log error %s, log uuid %s", manager->file_name.c_str(), e.errorMessage(), uuid));
		ret = false;
	}
	return ret;
}

int db_is_exist_table_ex(log_db_manager* manager, char* tablename){
	if (manager == NULL || manager->db == NULL) {
		aos_error_log((LB, "db %s is exist table ex failed for null.", manager->file_name.c_str()));
		return false;
	}

	std::string beginStr = "select count(*) from sqlite_master where type ='table' and name='";
	std::string queryStr = beginStr.append(tablename).append("';");

	try {
		int Ret = 0;
		Ret = manager->db->execScalar(queryStr.c_str());
		if( 0 == Ret)
			return false;
	}
	catch (CppSQLite3Exception& e)
	{
		aos_error_log((LB, "db %s update one log error %s", manager->file_name.c_str(), e.errorMessage()));
		return false;
	}
	return true;
}

int db_get_tables(log_db_manager* manager, char** tables, int* table_count) {
	if (manager == NULL || manager->db == NULL) {
		aos_error_log((LB, "db %s get table names failed for null.", manager->file_name.c_str()));
		return false;
	}
	std::vector<std::string> table_vec;
	std::string queryStr = "select name from sqlite_master where type ='table' and name NOT LIKE 'sqlite_%'";

	try {
		CppSQLite3Query q = manager->db->execQuery(queryStr.c_str());
		while (!q.eof()) {
			char* table_name = (char*)q.getStringField("name");
			table_vec.insert(table_vec.begin(), table_name);
			q.nextRow();
		}
		q.finalize();

		*table_count = table_vec.size();
		tables = (char **)malloc(*table_count * sizeof(char *));

		for (int i = 0; i < *table_count; i++) {
			int len = table_vec[i].length();
			tables[i] = (char *)malloc(len + 1);
			strcpy(tables[i], table_vec[i].c_str());
		}
	}
	catch (CppSQLite3Exception& e)
	{
		aos_error_log((LB, "db %s get table names error %s", manager->file_name.c_str(), e.errorMessage()));
		return false;
	}
	return true;
}

int db_vacuum(log_db_manager* manager){
	int CTRet;
	try {
		CTRet = manager->db->execDML("VACUUM");
		aos_debug_log((LB, "db %s exec VACUUM result %d", manager->file_name.c_str(), CTRet));
	}
	catch (CppSQLite3Exception& e)
	{
		aos_error_log((LB, "db %s exec VACUUM error %s", manager->file_name.c_str(), e.errorMessage()));
		return false;
	}
	return true;
}

int db_transaction_begin(log_db_manager* manager) {
	int CTRet;
	try {
		CTRet = manager->db->execDML("begin;");
		//aos_debug_log((LB, "db %s exec begin result %d", manager->file_name.c_str(), CTRet));
	}
	catch (CppSQLite3Exception& e)
	{
		aos_error_log((LB, "db %s exec begin error %s", manager->file_name.c_str(), e.errorMessage()));
		return false;
	}
	return true;
}
int db_transaction_commit(log_db_manager* manager) {
	int CTRet;
	try {
		CTRet = manager->db->execDML("commit;");
		//aos_debug_log((LB, "db %s exec commit result %d", manager->file_name.c_str(), CTRet));
	}
	catch (CppSQLite3Exception& e)
	{
		aos_error_log((LB, "db %s exec commit error %s", manager->file_name.c_str(), e.errorMessage()));
		return false;
	}
	return true;
}