#include <sqlManager/sqlBase.h>
#include <sqlManager/sqliteModule.h>
#include <iostream>
#include <qdebug.h>
#include <io.h>
#include <direct.h>
#include <iomanip>
#include <sstream>

std::string getCurrentDateTimeHMSx() {
	// 获取当前时间点
	std::chrono::system_clock::time_point now = std::chrono::system_clock::now();

	// 转换为字符串
	std::time_t currentTime = std::chrono::system_clock::to_time_t(now);
	std::tm* localTime = std::localtime(&currentTime);
	std::stringstream ss;
	ss << std::put_time(localTime, "%H:%M:%S");

	return ss.str();
}
sqliteModule::sqliteModule(std::string path)
{
	sqliteDbPtr = nullptr; // 初始化 sqliteDbPtr
	int rc = sqlite3_open(path.c_str(), &sqliteDbPtr);
	if (rc != SQLITE_OK) {
		std::cerr << "无法打开数据库: " << sqlite3_errmsg(sqliteDbPtr) << std::endl;
		return;
	}
}

sqliteModule::~sqliteModule()
{
	if (sqliteDbPtr) {
		sqlite3_close(sqliteDbPtr);
		sqliteDbPtr = nullptr;
	}
}
bool sqliteModule::backup(std::string path)
{
	//备份数据库
	if (!sqliteDbPtr) {
		std::cout << "数据库未打开无法备份  " << path << std::endl;
		qDebug() << "[ERROR] " << QString::fromStdString(path) << "数据库未打开,无法备份";
		return false;
	}

	sqlite3* sqliteDbPtr_dst;
	int rc = sqlite3_open(path.c_str(), &sqliteDbPtr_dst);
	if (rc != SQLITE_OK) {
		std::cerr << "无法打开备份数据库，检查路径: " << sqlite3_errmsg(sqliteDbPtr_dst) << std::endl;
		sqlite3_close(sqliteDbPtr_dst);
		return false;
	}
	sqlite3_backup* backupHandle;

	backupHandle = sqlite3_backup_init(sqliteDbPtr_dst, "main", sqliteDbPtr, "main");
	if (!backupHandle) {
		std::cout << "无法初始化数据库备份: " << sqlite3_errmsg(sqliteDbPtr) << std::endl;
		sqlite3_close(sqliteDbPtr_dst);
		return false;
	}

	rc = sqlite3_backup_step(backupHandle, -1);
	if (rc != SQLITE_DONE) {
		std::cout << "备份数据库失败: " << sqlite3_errmsg(sqliteDbPtr) << std::endl;
		sqlite3_backup_finish(backupHandle);
		sqlite3_close(sqliteDbPtr_dst);
		return false;
	}

	sqlite3_backup_finish(backupHandle);
	sqlite3_close(sqliteDbPtr_dst);
	return true;
}

bool sqliteModule::createTable(std::string tableName, std::vector<std::string>dataVec)
{
	std::string query = "CREATE TABLE IF NOT EXISTS \'" + tableName
		+"\' (SN TEXT PRIMARY KEY, timeCode TEXT,saveHour TEXT";
	for (auto data : dataVec)
		query += ","+data + " TEXT";
	query += ",updateTime TEXT);";
	int rc = sqlite3_exec(sqliteDbPtr, query.c_str(), 0, 0, 0);
	if (rc != SQLITE_OK) {
		std::string errStr = sqlite3_errmsg(sqliteDbPtr);
		std::cout << "创建表失败: " << errStr << ";" << query;
		qDebug() << "[ERROR] " << QString::fromStdString(errStr);
		return false;
	}
	return true;
}
bool sqliteModule::deleteTable(std::string tableName)
{
	std::string query = "DROP TABLE IF EXISTS \'" + tableName + "\';";
	int rc = sqlite3_exec(sqliteDbPtr, query.c_str(), nullptr, nullptr, nullptr);
	if (rc != SQLITE_OK) {
		std::string errStr = sqlite3_errmsg(sqliteDbPtr);
		std::cout << "删除表失败: " << errStr << ";" << query;
		qDebug() << "[ERROR] " << QString::fromStdString(errStr);
		return false;
	}
	return true;
}
std::vector<std::string> sqliteModule::getTableList() {
	std::vector<std::string> tableNames;

	// SQL 查询语句，选择类型为 "table" 的项，并提取表名
	const char* query = "SELECT name FROM sqlite_master WHERE type='table';";

	// 准备 SQL 查询
	sqlite3_stmt* stmt;
	if (sqlite3_prepare_v2(sqliteDbPtr, query, -1, &stmt, nullptr) != SQLITE_OK) {
		// 查询准备失败，返回空的表名列表
		return tableNames;
	}

	// 执行 SQL 查询并获取结果
	while (sqlite3_step(stmt) == SQLITE_ROW) {
		// 提取结果中的表名并加入到表名列表中
		const unsigned char* tableName = sqlite3_column_text(stmt, 0);
		tableNames.push_back(reinterpret_cast<const char*>(tableName));
	}

	// 释放 SQL 语句资源
	sqlite3_finalize(stmt);

	return tableNames;
}

bool sqliteModule::addColumn(
	std::string &tableName,
	std::string &columnName,
	std::string columnType)
{
	std::string query = "ALTER TABLE '" + tableName + "' ADD COLUMN '" + columnName + "' " + columnType + ";";
	int rc = sqlite3_exec(sqliteDbPtr, query.c_str(), nullptr, nullptr, nullptr);
	if (rc != SQLITE_OK) {
		std::cerr << "无法添加列: " << sqlite3_errmsg(sqliteDbPtr) << std::endl;
		return false;
	}
	return true;
}
bool sqliteModule::deleteColumn(
	std::string tableName,
	std::string columnName)
{
	std::string query = "ALTER TABLE '" + tableName + "' DROP COLUMN '" + columnName + "';";
	int rc = sqlite3_exec(sqliteDbPtr, query.c_str(), nullptr, nullptr, nullptr);
	if (rc != SQLITE_OK) {
		std::cerr << "无法删除列: " << sqlite3_errmsg(sqliteDbPtr) << std::endl;
		return false;
	}
	return true;
}
std::vector<std::string> sqliteModule::getColumn(std::string tableName) {
	std::vector<std::string> columnNames;

	// SQL 查询语句，选择指定表格的列名信息
	std::string query = "PRAGMA table_info('" + tableName + "');";

	// 准备 SQL 查询
	sqlite3_stmt* stmt;
	if (sqlite3_prepare_v2(sqliteDbPtr, query.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
		// 查询准备失败，返回空的列名列表
		return columnNames;
	}

	// 执行 SQL 查询并获取结果
	while (sqlite3_step(stmt) == SQLITE_ROW) {
		// 提取结果中的列名并加入到列名列表中
		const unsigned char* columnName = sqlite3_column_text(stmt, 1);
		columnNames.push_back(reinterpret_cast<const char*>(columnName));
	}

	// 释放 SQL 语句资源
	sqlite3_finalize(stmt);

	return columnNames;
}

sqlErr sqliteModule::Insert(
	std::string tableName, 
	std::string SN, 
	std::vector<sqlData>dataVec)
{
	std::string insertQuery = "INSERT INTO \'" + tableName + "\' (SN,";
	for (auto data : dataVec)
		insertQuery += data.key + ",";
	insertQuery += "updateTime,";
	insertQuery.replace(insertQuery.find_last_of(","), 1, ") VALUES (\'" + SN + "\',");
	for (auto data : dataVec)
		insertQuery += "\'" + data.value + "\',";
	insertQuery += "\'" + getCurrentDateTimeHMSx() + "\',";
	insertQuery.replace(insertQuery.find_last_of(","), 1, " );");

	int rc = sqlite3_exec(sqliteDbPtr, insertQuery.c_str(), nullptr, nullptr, nullptr);
	if (rc != SQLITE_OK) {
		std::string errStr = sqlite3_errmsg(sqliteDbPtr);
		std::cout << "插入操作失败: " << errStr << ";" << insertQuery;
		qDebug() << "[ERROR] " << QString::fromStdString(errStr);
		return sqlErr(sqlFalse, errStr);
	}
	return sqlErr(sqlOK, "");
}
bool sqliteModule::Delete(
	std::string tableName, 
	std::string Where,
	std::string equal)
{
	std::string query = "DELETE FROM '" + tableName + "'";
	if (!Where.empty() && !equal.empty()) {
		query += " WHERE " + Where + " = '" + equal + "'";
	}
	query += ";";

	int rc = sqlite3_exec(sqliteDbPtr, query.c_str(), nullptr, nullptr, nullptr);
	if (rc != SQLITE_OK) {
		std::string errStr = sqlite3_errmsg(sqliteDbPtr);
		std::cout << "删除操作失败: " << errStr << "; " << query << std::endl;
		qDebug() << "[ERROR] " << QString::fromStdString(errStr);
		return false;
	}
	return true;
}
sqlErr sqliteModule::Select(
	std::string tableName,
	std::vector<std::string>selectStr, 
	sqlTableDatas& output,
	std::string Where,
	std::string equal)
{
	output.tableName = tableName;
	std::string query = "SELECT ";
	if(selectStr.size()>0)
	{
		for (auto str : selectStr)
			query += str + " ";
	}
	else
	{
		query += "* ";
	}	
	query+=" FROM '" + tableName + "'";
	if (!Where.empty() && !equal.empty()) {
		query += " WHERE " + Where + " = '" + equal + "'";
	}
	query += ";";
	sqlite3_stmt* stmt;
	int rc = sqlite3_prepare_v2(sqliteDbPtr, query.c_str(), -1, &stmt, nullptr);
	if (rc != SQLITE_OK) {
		std::string errStr = sqlite3_errmsg(sqliteDbPtr);
		std::cout << "查询操作失败: " << errStr << "; " << query << std::endl;
		qDebug() << "[ERROR] " << QString::fromStdString(errStr);
		return sqlErr(sqlFalse, errStr); // 返回空的结果集
	}

	while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
		sqlRowDatas row;
		for (int i = 0; i < sqlite3_column_count(stmt); ++i) {
			const char* columnName = sqlite3_column_name(stmt, i);
			const char* columnValue = reinterpret_cast<const char*>(sqlite3_column_text(stmt, i));
			std::string columnNameStr = columnName ? std::string(columnName) : "";
			std::string columnValueStr = columnValue ? std::string(columnValue) : "";
			columnNameStr.erase(std::remove(columnNameStr.begin(), columnNameStr.end(), '\''), columnNameStr.end());

			//if (columnNameStr.find(columnValueStr) != std::string::npos) {
			//	columnValueStr = "";
			//}
			row.push_back({ columnNameStr, columnValueStr });
		}
		output.rowDatas.push_back(row);
	}
	
	sqlite3_finalize(stmt);
	return sqlErr(sqlOK,"");


}
bool sqliteModule::Update(
	std::string tableName,
	std::vector<sqlData>str,
	std::string Where,
	std::string equal)
{
	if (str.empty()) {
		std::cout << "修改数组为空" << std::endl;
		qDebug() << u8"[ERROR] 修改数组为空" ;
		return false;
	}

	std::string query = "UPDATE '" + tableName + "' SET ";
	for (size_t i = 0; i < str.size(); ++i) {
		query += "'" + str[i].key + "' = '" + str[i].value + "'";
		if (i < str.size() - 1) {
			query += ", ";
		}
	}

	if (!Where.empty() && !equal.empty()) {
		query += " WHERE " + Where + " = '" + equal + "'";
	}

	query += ";";

	int rc = sqlite3_exec(sqliteDbPtr, query.c_str(), nullptr, nullptr, nullptr);
	if (rc != SQLITE_OK) {
		std::string errStr = sqlite3_errmsg(sqliteDbPtr);
		std::cout << "更新操作失败: " << errStr << "; " << query << std::endl;
		qDebug() << "[ERROR] " << QString::fromStdString(errStr);
		return false;
	}

	return true;
}