#include "Login_global.h"
#include <string>
#include <memory>
#include <chrono>
#include <filesystem>
#include <sqlite3.h>
#include <openssl/evp.h>
#include <openssl/sha.h>
#include <nlohmann/json.hpp>
#include <cstring>
#include <stdexcept>
#include <sstream>
#include <iomanip>
#include <iostream>
#include <vector>
#include <algorithm>
#include <openssl/rand.h>
#include <openssl/bio.h>
#include <openssl/buffer.h>

using json	 = nlohmann::json;
namespace fs = std::filesystem;

std::string generateSalt(const std::string &username)
{
	// 使用用户名生成盐值
	return username + "XNSim_Salt_Key";
}

std::string encryptPassword(const std::string &password, const std::string &salt)
{
	// 将密码和盐值组合
	std::string saltedPassword = password;
	if (!salt.empty()) {
		saltedPassword += salt;
	}

	// 使用SHA-256算法对加盐密码进行加密
	unsigned char hash[SHA256_DIGEST_LENGTH];
	EVP_MD_CTX *ctx = EVP_MD_CTX_new();
	EVP_DigestInit_ex(ctx, EVP_sha256(), NULL);
	EVP_DigestUpdate(ctx, saltedPassword.c_str(), saltedPassword.length());
	EVP_DigestFinal_ex(ctx, hash, NULL);
	EVP_MD_CTX_free(ctx);

	// 转换为十六进制字符串
	std::stringstream ss;
	for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
		ss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(hash[i]);
	}
	return ss.str();
}

// Base64编码函数
std::string base64_encode(const unsigned char *data, size_t length)
{
	BIO *bio, *b64;
	BUF_MEM *bufferPtr;

	b64 = BIO_new(BIO_f_base64());
	bio = BIO_new(BIO_s_mem());
	bio = BIO_push(b64, bio);

	BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL); // 不添加换行符
	BIO_write(bio, data, length);
	BIO_flush(bio);
	BIO_get_mem_ptr(bio, &bufferPtr);

	std::string result(bufferPtr->data, bufferPtr->length);
	BIO_free_all(bio);

	return result;
}

// Base64解码函数
std::vector<unsigned char> base64_decode(const std::string &encoded_string)
{
	BIO *bio, *b64;
	std::vector<unsigned char> result;

	b64 = BIO_new(BIO_f_base64());
	bio = BIO_new_mem_buf(encoded_string.c_str(), encoded_string.length());
	bio = BIO_push(b64, bio);

	BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL); // 不添加换行符

	// 计算解码后的长度
	size_t decoded_length = (encoded_string.length() * 3) / 4;
	result.resize(decoded_length);

	int actual_length = BIO_read(bio, result.data(), decoded_length);
	if (actual_length > 0) {
		result.resize(actual_length);
	} else {
		result.clear();
	}

	BIO_free_all(bio);
	return result;
}

// 利用用户名和固定密钥派生32字节AES密钥
std::vector<unsigned char> derive_aes_key(const std::string &username, const std::string &fixed_key)
{
	unsigned char hash[SHA256_DIGEST_LENGTH];
	std::string key_material = username + fixed_key;
	EVP_MD_CTX *ctx			 = EVP_MD_CTX_new();
	EVP_DigestInit_ex(ctx, EVP_sha256(), NULL);
	EVP_DigestUpdate(ctx, key_material.c_str(), key_material.length());
	EVP_DigestFinal_ex(ctx, hash, NULL);
	EVP_MD_CTX_free(ctx);
	return std::vector<unsigned char>(hash, hash + SHA256_DIGEST_LENGTH);
}

// AES-256-CBC加密
std::vector<unsigned char> aes_encrypt(const std::string &plaintext,
									   const std::vector<unsigned char> &key,
									   std::vector<unsigned char> &iv_out)
{
	EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
	if (!ctx)
		throw std::runtime_error("EVP_CIPHER_CTX_new failed");
	iv_out.resize(16);
	if (!RAND_bytes(iv_out.data(), iv_out.size())) {
		EVP_CIPHER_CTX_free(ctx);
		throw std::runtime_error("RAND_bytes failed");
	}
	if (1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key.data(), iv_out.data()))
		throw std::runtime_error("EVP_EncryptInit_ex failed");
	std::vector<unsigned char> ciphertext(plaintext.size() + 16);
	int len = 0, ciphertext_len = 0;
	if (1
		!= EVP_EncryptUpdate(ctx, ciphertext.data(), &len,
							 reinterpret_cast<const unsigned char *>(plaintext.c_str()),
							 plaintext.size()))
		throw std::runtime_error("EVP_EncryptUpdate failed");
	ciphertext_len = len;
	if (1 != EVP_EncryptFinal_ex(ctx, ciphertext.data() + len, &len))
		throw std::runtime_error("EVP_EncryptFinal_ex failed");
	ciphertext_len += len;
	ciphertext.resize(ciphertext_len);
	EVP_CIPHER_CTX_free(ctx);
	return ciphertext;
}

// AES-256-CBC解密
std::string aes_decrypt(const std::vector<unsigned char> &ciphertext,
						const std::vector<unsigned char> &key, const std::vector<unsigned char> &iv)
{
	EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
	if (!ctx)
		throw std::runtime_error("EVP_CIPHER_CTX_new failed");
	if (1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key.data(), iv.data()))
		throw std::runtime_error("EVP_DecryptInit_ex failed");
	std::vector<unsigned char> plaintext(ciphertext.size());
	int len = 0, plaintext_len = 0;
	if (1 != EVP_DecryptUpdate(ctx, plaintext.data(), &len, ciphertext.data(), ciphertext.size()))
		throw std::runtime_error("EVP_DecryptUpdate failed");
	plaintext_len = len;
	if (1 != EVP_DecryptFinal_ex(ctx, plaintext.data() + len, &len))
		throw std::runtime_error("EVP_DecryptFinal_ex failed");
	plaintext_len += len;
	plaintext.resize(plaintext_len);
	EVP_CIPHER_CTX_free(ctx);
	return std::string(plaintext.begin(), plaintext.end());
}

// 二进制转16进制字符串
std::string bin2hex(const std::vector<unsigned char> &data)
{
	std::ostringstream oss;
	for (auto c : data) {
		oss << std::hex << std::setw(2) << std::setfill('0') << (int)c;
	}
	return oss.str();
}

// 16进制字符串转二进制
std::vector<unsigned char> hex2bin(const std::string &hex)
{
	std::vector<unsigned char> out;
	for (size_t i = 0; i + 1 < hex.length(); i += 2) {
		std::string byteString = hex.substr(i, 2);
		unsigned char byte	   = (unsigned char)strtol(byteString.c_str(), nullptr, 16);
		out.push_back(byte);
	}
	return out;
}

extern "C" LOGIN_EXPORT int validateUser(const char *username_buffer, size_t username_length,
										 const char *password_buffer, size_t password_length)
{
	try {
		std::string username_str(username_buffer, username_length);
		std::string password_str(password_buffer, password_length);

		if (username_str.empty() || password_str.empty()) {
			return -1;
		}

		std::string salt			  = generateSalt(username_str);
		std::string encryptedPassword = encryptPassword(password_str, salt);

		// 获取环境变量
		const char *xnCorePath = std::getenv("XNCore");
		if (!xnCorePath) {
			return -1;
		}

		fs::path dbPath = fs::path(xnCorePath) / "database" / "UserInfo.db";

		sqlite3 *db;
		if (sqlite3_open(dbPath.string().c_str(), &db) != SQLITE_OK) {
			return -1;
		}

		int userId = -1;
		sqlite3_stmt *stmt;
		const char *queryStr = "SELECT * FROM users WHERE username = ? AND password = ?";

		if (sqlite3_prepare_v2(db, queryStr, -1, &stmt, nullptr) == SQLITE_OK) {
			sqlite3_bind_text(stmt, 1, username_str.c_str(), -1, SQLITE_STATIC);
			sqlite3_bind_text(stmt, 2, encryptedPassword.c_str(), -1, SQLITE_STATIC);

			if (sqlite3_step(stmt) == SQLITE_ROW) {
				userId = sqlite3_column_int(stmt, 0);
			}

			sqlite3_finalize(stmt);
		}

		sqlite3_close(db);
		return userId;

	} catch (const std::exception &) {
		return -1;
	}
}

extern "C" LOGIN_EXPORT int getUserInfo(int user_id, char *result, int result_length)
{
	try {
		const char *xnCorePath = std::getenv("XNCore");
		if (!xnCorePath) {
			std::cout << "xnCorePath is null" << std::endl;
			return -1;
		}

		fs::path dbPath = fs::path(xnCorePath) / "database" / "UserInfo.db";

		sqlite3 *db;
		if (sqlite3_open(dbPath.string().c_str(), &db) != SQLITE_OK) {
			std::cout << "sqlite3_open failed" << std::endl;
			return -1;
		}

		sqlite3_stmt *stmt;
		const char *queryStr = "SELECT * FROM users WHERE id = ?";

		if (sqlite3_prepare_v2(db, queryStr, -1, &stmt, nullptr) == SQLITE_OK) {
			sqlite3_bind_int(stmt, 1, user_id);

			if (sqlite3_step(stmt) == SQLITE_ROW) {
				json userInfo;
				userInfo["id"]		 = sqlite3_column_int(stmt, 0);
				userInfo["username"] = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 1));
				// access_level 解密
				std::string accessLevelEnc =
					reinterpret_cast<const char *>(sqlite3_column_text(stmt, 3));
				std::vector<unsigned char> iv_and_ciphertext = hex2bin(accessLevelEnc);
				if (iv_and_ciphertext.size() < 16) {
					userInfo["access_level"] = nullptr;
				} else {
					std::vector<unsigned char> iv(iv_and_ciphertext.begin(),
												  iv_and_ciphertext.begin() + 16);
					std::vector<unsigned char> ciphertext(iv_and_ciphertext.begin() + 16,
														  iv_and_ciphertext.end());
					std::string fixed_key		   = "XNSim_Access_Key";
					std::string username		   = userInfo["username"].get<std::string>();
					std::vector<unsigned char> key = derive_aes_key(username, fixed_key);
					try {
						std::string accessLevelStr = aes_decrypt(ciphertext, key, iv);
						userInfo["access_level"]   = std::stoi(accessLevelStr);
					} catch (...) {
						userInfo["access_level"] = nullptr;
					}
				}
				userInfo["full_name"] =
					reinterpret_cast<const char *>(sqlite3_column_text(stmt, 4));
				userInfo["phone"] = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 5));
				userInfo["email"] = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 6));
				userInfo["department"] =
					reinterpret_cast<const char *>(sqlite3_column_text(stmt, 7));
				userInfo["position"] = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 8));

				// 处理二进制数据
				const void *blob_data = sqlite3_column_blob(stmt, 9);
				int blob_size		  = sqlite3_column_bytes(stmt, 9);
				if (blob_data && blob_size > 0) {
					userInfo["icon"] =
						base64_encode(static_cast<const unsigned char *>(blob_data), blob_size);
				} else {
					userInfo["icon"] = nullptr; // 使用null值代替空字符串
				}

				std::string jsonData = userInfo.dump();
				if (result_length >= jsonData.size() + 1) {
					std::strcpy(result, jsonData.c_str());
					sqlite3_finalize(stmt);
					sqlite3_close(db);
					return 0;
				} else {
					std::cout << "result_length: " << result_length << std::endl;
					sqlite3_finalize(stmt);
					sqlite3_close(db);
					return -1;
				}
			} else {
				// 用户不存在
				sqlite3_finalize(stmt);
				sqlite3_close(db);
				return -2; // 用户不存在
			}
		}

		sqlite3_close(db);
		return 0;

	} catch (const std::exception &) {
		std::cout << "getUserInfo failed" << std::endl;
		return -1;
	}
}

extern "C" LOGIN_EXPORT void freeUserInfo(const char *ptr)
{
	if (ptr) {
		delete[] ptr;
	}
}

extern "C" LOGIN_EXPORT void cleanup()
{
}

// 检查用户名是否已存在
int checkUsernameExists(const void *username_buffer, size_t username_length)
{
	try {
		const char *username_data = static_cast<const char *>(username_buffer);
		std::string username_str(username_data, username_length);

		if (username_str.empty()) {
			return -1;
		}

		const char *xnCorePath = std::getenv("XNCore");
		if (!xnCorePath) {
			return -1;
		}

		fs::path dbPath = fs::path(xnCorePath) / "database" / "UserInfo.db";
		std::string connectionName =
			"usercheck_"
			+ std::to_string(std::chrono::duration_cast<std::chrono::milliseconds>(
								 std::chrono::system_clock::now().time_since_epoch())
								 .count());

		int result = -1;
		{
			sqlite3 *db;
			if (sqlite3_open(dbPath.string().c_str(), &db) != SQLITE_OK) {
				return -1;
			}

			sqlite3_stmt *stmt;
			const char *queryStr = "SELECT COUNT(*) FROM users WHERE username = ?";

			if (sqlite3_prepare_v2(db, queryStr, -1, &stmt, nullptr) == SQLITE_OK) {
				sqlite3_bind_text(stmt, 1, username_str.c_str(), -1, SQLITE_STATIC);

				if (sqlite3_step(stmt) == SQLITE_ROW) {
					result = sqlite3_column_int(stmt, 0) > 0 ? 1 : 0;
				}

				sqlite3_finalize(stmt);
			}

			sqlite3_close(db);
		}
		return result;

	} catch (const std::exception &) {
		return -1;
	}
}

// 注册新用户
extern "C" LOGIN_EXPORT int registerUser(const char *username_buffer, int username_length,
										 const char *password_buffer, int password_length,
										 const char *userinfo_buffer, int userinfo_length)
{
	try {
		// 转换输入参数
		std::string username_str(username_buffer, username_length);
		std::string password_str(password_buffer, password_length);
		std::string userinfo_str(userinfo_buffer, userinfo_length);

		// 验证用户名和密码非空
		if (username_str.empty()) {
			return -4; // 用户名为空
		}
		if (password_str.empty()) {
			return -5; // 密码为空
		}

		// 检查用户名是否已存在
		if (checkUsernameExists(username_buffer, username_length) != 0) {
			return -2; // 用户名已存在
		}

		// 解析用户信息JSON
		json userInfo;
		try {
			userInfo = json::parse(userinfo_str);
		} catch (const json::parse_error &) {
			return -3; // Invalid user info format
		}

		// 验证权限级别
		int accessLevel = 0;
		if (userInfo.contains("access_level")) {
			accessLevel = userInfo["access_level"].get<int>();
		}
		// access_level 加密
		std::string fixed_key		   = "XNSim_Access_Key";
		std::vector<unsigned char> key = derive_aes_key(username_str, fixed_key);
		std::vector<unsigned char> iv;
		std::vector<unsigned char> ciphertext = aes_encrypt(std::to_string(accessLevel), key, iv);
		std::vector<unsigned char> iv_and_ciphertext = iv;
		iv_and_ciphertext.insert(iv_and_ciphertext.end(), ciphertext.begin(), ciphertext.end());
		std::string accessLevelEnc = bin2hex(iv_and_ciphertext);

		// 生成加密密码
		std::string salt			  = generateSalt(username_str);
		std::string encryptedPassword = encryptPassword(password_str, salt);

		// 连接数据库
		const char *xnCorePath = std::getenv("XNCore");
		if (!xnCorePath) {
			return -1;
		}

		fs::path dbPath = fs::path(xnCorePath) / "database" / "UserInfo.db";

		int newUserId = -1;
		{
			sqlite3 *db;
			if (sqlite3_open(dbPath.string().c_str(), &db) != SQLITE_OK) {
				return -1;
			}

			sqlite3_stmt *stmt;
			const char *queryStr =
				"INSERT INTO users (username, password, access_level, full_name, phone, "
				"email, department, position) "
				"VALUES (?, ?, ?, ?, ?, ?, ?, ?)";

			if (sqlite3_prepare_v2(db, queryStr, -1, &stmt, nullptr) == SQLITE_OK) {
				sqlite3_bind_text(stmt, 1, username_str.c_str(), -1, SQLITE_STATIC);
				sqlite3_bind_text(stmt, 2, encryptedPassword.c_str(), -1, SQLITE_STATIC);
				sqlite3_bind_text(stmt, 3, accessLevelEnc.c_str(), -1, SQLITE_STATIC);
				sqlite3_bind_text(stmt, 4, userInfo["full_name"].get<std::string>().c_str(), -1,
								  SQLITE_STATIC);
				sqlite3_bind_text(stmt, 5, userInfo["phone"].get<std::string>().c_str(), -1,
								  SQLITE_STATIC);
				sqlite3_bind_text(stmt, 6, userInfo["email"].get<std::string>().c_str(), -1,
								  SQLITE_STATIC);
				sqlite3_bind_text(stmt, 7, userInfo["department"].get<std::string>().c_str(), -1,
								  SQLITE_STATIC);
				sqlite3_bind_text(stmt, 8, userInfo["position"].get<std::string>().c_str(), -1,
								  SQLITE_STATIC);

				if (sqlite3_step(stmt) == SQLITE_DONE) {
					newUserId = sqlite3_last_insert_rowid(db);
				}

				sqlite3_finalize(stmt);
			}

			sqlite3_close(db);
		}
		return newUserId;

	} catch (const std::exception &) {
		return -1;
	}
}

// 修改密码
extern "C" LOGIN_EXPORT int changePassword(int user_id, const char *old_password_buffer,
										   int old_password_length, const char *new_password_buffer,
										   int new_password_length)
{
	try {
		std::string old_password_str(old_password_buffer, old_password_length);
		std::string new_password_str(new_password_buffer, new_password_length);

		if (old_password_str.empty() || new_password_str.empty()) {
			return -1;
		}

		if (old_password_str == new_password_str) {
			return -2;
		}

		const char *xnCorePath = std::getenv("XNCore");
		if (!xnCorePath) {
			return -3;
		}

		fs::path dbPath = fs::path(xnCorePath) / "database" / "UserInfo.db";

		{
			sqlite3 *db;
			if (sqlite3_open(dbPath.string().c_str(), &db) != SQLITE_OK) {
				return -3;
			}

			// 首先验证旧密码
			sqlite3_stmt *stmt;
			const char *queryStr = "SELECT username, password FROM users WHERE id = ?";

			if (sqlite3_prepare_v2(db, queryStr, -1, &stmt, nullptr) == SQLITE_OK) {
				sqlite3_bind_int(stmt, 1, user_id);

				if (sqlite3_step(stmt) == SQLITE_ROW) {
					std::string username =
						reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0));
					std::string storedPassword =
						reinterpret_cast<const char *>(sqlite3_column_text(stmt, 1));

					// 验证旧密码
					std::string salt				 = generateSalt(username);
					std::string encryptedOldPassword = encryptPassword(old_password_str, salt);

					if (encryptedOldPassword != storedPassword) {
						sqlite3_finalize(stmt);
						sqlite3_close(db);
						return -4; // 旧密码错误
					}

					// 生成新的加密密码
					std::string encryptedNewPassword = encryptPassword(new_password_str, salt);

					// 更新密码
					sqlite3_finalize(stmt);
					stmt	 = nullptr;
					queryStr = "UPDATE users SET password = ? WHERE id = ?";

					if (sqlite3_prepare_v2(db, queryStr, -1, &stmt, nullptr) == SQLITE_OK) {
						sqlite3_bind_text(stmt, 1, encryptedNewPassword.c_str(), -1, SQLITE_STATIC);
						sqlite3_bind_int(stmt, 2, user_id);

						if (sqlite3_step(stmt) == SQLITE_DONE) {
							sqlite3_finalize(stmt);
							sqlite3_close(db);
							return 0; // 密码修改成功
						}

						sqlite3_finalize(stmt);
					}
				} else {
					// 用户不存在
					sqlite3_finalize(stmt);
					sqlite3_close(db);
					return -5; // 用户不存在
				}
			}

			sqlite3_close(db);
		}

		return -6; // Default error return
	} catch (const std::exception &) {
		return -3;
	}
}

extern "C" LOGIN_EXPORT int resetPassword(int user_id)
{
	try {
		const char *xnCorePath = std::getenv("XNCore");
		if (!xnCorePath) {
			return -1;
		}

		fs::path dbPath = fs::path(xnCorePath) / "database" / "UserInfo.db";
		{
			sqlite3 *db;
			if (sqlite3_open(dbPath.string().c_str(), &db) != SQLITE_OK) {
				return -2;
			}

			// 首先查询用户名
			sqlite3_stmt *stmt;
			const char *queryStr = "SELECT username FROM users WHERE id = ?";

			if (sqlite3_prepare_v2(db, queryStr, -1, &stmt, nullptr) != SQLITE_OK) {
				sqlite3_close(db);
				return -3; // SELECT 语句准备失败
			}

			sqlite3_bind_int(stmt, 1, user_id);

			if (sqlite3_step(stmt) == SQLITE_ROW) {
				std::string username = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0));

				// 生成新的加密密码
				std::string salt				 = generateSalt(username);
				std::string new_password_str	 = "123456";
				std::string encryptedNewPassword = encryptPassword(new_password_str, salt);

				// 更新密码
				sqlite3_finalize(stmt);
				stmt	 = nullptr;
				queryStr = "UPDATE users SET password = ? WHERE id = ?";

				if (sqlite3_prepare_v2(db, queryStr, -1, &stmt, nullptr) != SQLITE_OK) {
					sqlite3_close(db);
					return -4; // UPDATE 语句准备失败
				}

				sqlite3_bind_text(stmt, 1, encryptedNewPassword.c_str(), -1, SQLITE_STATIC);
				sqlite3_bind_int(stmt, 2, user_id);

				if (sqlite3_step(stmt) == SQLITE_DONE) {
					sqlite3_finalize(stmt);
					sqlite3_close(db);
					return 0; // 密码重置成功
				} else {
					// 获取具体的错误信息
					int error_code		  = sqlite3_errcode(db);
					const char *error_msg = sqlite3_errmsg(db);
					std::cout << "UPDATE failed with error code: " << error_code
							  << ", message: " << (error_msg ? error_msg : "unknown") << std::endl;
					sqlite3_finalize(stmt);
					sqlite3_close(db);
					return -5; // UPDATE 语句执行失败
				}
			} else {
				// 用户不存在
				sqlite3_finalize(stmt);
				sqlite3_close(db);
				return -6; // 用户不存在
			}
		}

		return -7; // 其他错误
	} catch (const std::exception &) {
		return -8;
	}
}

// 更新用户信息
extern "C" LOGIN_EXPORT int updateUserInfo(int user_id, const char *userinfo_buffer,
										   int userinfo_length)
{
	try {
		std::string userinfo_str(userinfo_buffer, userinfo_length);

		// 解析用户信息JSON
		json userInfo;
		try {
			userInfo = json::parse(userinfo_str);
		} catch (const json::parse_error &) {
			return -1; // Invalid user info format
		}

		// 连接数据库
		const char *xnCorePath = std::getenv("XNCore");
		if (!xnCorePath) {
			return -1;
		}

		fs::path dbPath = fs::path(xnCorePath) / "database" / "UserInfo.db";

		int result = -1;
		{
			sqlite3 *db;
			if (sqlite3_open(dbPath.string().c_str(), &db) != SQLITE_OK) {
				return -1;
			}

			// 首先检查用户是否存在
			sqlite3_stmt *stmt;
			const char *checkQueryStr = "SELECT id FROM users WHERE id = ?";

			if (sqlite3_prepare_v2(db, checkQueryStr, -1, &stmt, nullptr) == SQLITE_OK) {
				sqlite3_bind_int(stmt, 1, user_id);

				if (sqlite3_step(stmt) != SQLITE_ROW) {
					sqlite3_finalize(stmt);
					sqlite3_close(db);
					return -2; // 用户不存在
				}
				sqlite3_finalize(stmt);
			}

			stmt = nullptr;
			const char *queryStr =
				"UPDATE users SET full_name = ?, phone = ?, email = ?, department = ?, "
				"position = ? "
				"WHERE id = ?";

			if (sqlite3_prepare_v2(db, queryStr, -1, &stmt, nullptr) == SQLITE_OK) {
				// 安全地获取字符串值，处理null情况
				std::string full_name =
					userInfo.contains("full_name") && !userInfo["full_name"].is_null()
						? userInfo["full_name"].get<std::string>()
						: "";
				std::string phone = userInfo.contains("phone") && !userInfo["phone"].is_null()
										? userInfo["phone"].get<std::string>()
										: "";
				std::string email = userInfo.contains("email") && !userInfo["email"].is_null()
										? userInfo["email"].get<std::string>()
										: "";
				std::string department =
					userInfo.contains("department") && !userInfo["department"].is_null()
						? userInfo["department"].get<std::string>()
						: "";
				std::string position =
					userInfo.contains("position") && !userInfo["position"].is_null()
						? userInfo["position"].get<std::string>()
						: "";

				sqlite3_bind_text(stmt, 1, full_name.c_str(), -1, SQLITE_TRANSIENT);
				sqlite3_bind_text(stmt, 2, phone.c_str(), -1, SQLITE_TRANSIENT);
				sqlite3_bind_text(stmt, 3, email.c_str(), -1, SQLITE_TRANSIENT);
				sqlite3_bind_text(stmt, 4, department.c_str(), -1, SQLITE_TRANSIENT);
				sqlite3_bind_text(stmt, 5, position.c_str(), -1, SQLITE_TRANSIENT);
				sqlite3_bind_int(stmt, 6, user_id);

				if (sqlite3_step(stmt) == SQLITE_DONE) {
					result = 0; // 更新成功
				}

				sqlite3_finalize(stmt);
			}

			sqlite3_close(db);
		}
		return result;

	} catch (const std::exception &) {
		return -1;
	}
}

// 更新用户权限级别
extern "C" LOGIN_EXPORT int updateUserAccessLevel(int user_id, int access_level)
{
	try {
		// 验证权限级别
		if (access_level < 0 || access_level > 3) {
			return -3; // 无效的权限级别
		}

		// 连接数据库
		const char *xnCorePath = std::getenv("XNCore");
		if (!xnCorePath) {
			return -1;
		}

		fs::path dbPath = fs::path(xnCorePath) / "database" / "UserInfo.db";

		int result = -1;
		{
			sqlite3 *db;
			if (sqlite3_open(dbPath.string().c_str(), &db) != SQLITE_OK) {
				return -1;
			}

			// 首先检查用户是否存在
			sqlite3_stmt *stmt;
			const char *checkQueryStr = "SELECT id FROM users WHERE id = ?";

			if (sqlite3_prepare_v2(db, checkQueryStr, -1, &stmt, nullptr) == SQLITE_OK) {
				sqlite3_bind_int(stmt, 1, user_id);

				if (sqlite3_step(stmt) != SQLITE_ROW) {
					sqlite3_finalize(stmt);
					sqlite3_close(db);
					return -2; // 用户不存在
				}
				sqlite3_finalize(stmt);
			}

			stmt				 = nullptr;
			const char *queryStr = "UPDATE users SET access_level = ? WHERE id = ?";

			if (sqlite3_prepare_v2(db, queryStr, -1, &stmt, nullptr) == SQLITE_OK) {
				// 需要查用户名
				std::string username;
				{
					sqlite3_stmt *stmt2;
					const char *q2 = "SELECT username FROM users WHERE id = ?";
					if (sqlite3_prepare_v2(db, q2, -1, &stmt2, nullptr) == SQLITE_OK) {
						sqlite3_bind_int(stmt2, 1, user_id);
						if (sqlite3_step(stmt2) == SQLITE_ROW) {
							username =
								reinterpret_cast<const char *>(sqlite3_column_text(stmt2, 0));
						}
						sqlite3_finalize(stmt2);
					}
				}
				std::string fixed_key		   = "XNSim_Access_Key";
				std::vector<unsigned char> key = derive_aes_key(username, fixed_key);
				std::vector<unsigned char> iv;
				std::vector<unsigned char> ciphertext =
					aes_encrypt(std::to_string(access_level), key, iv);
				std::vector<unsigned char> iv_and_ciphertext = iv;
				iv_and_ciphertext.insert(iv_and_ciphertext.end(), ciphertext.begin(),
										 ciphertext.end());
				std::string accessLevelEnc = bin2hex(iv_and_ciphertext);
				sqlite3_bind_text(stmt, 1, accessLevelEnc.c_str(), -1, SQLITE_STATIC);
				sqlite3_bind_int(stmt, 2, user_id);

				if (sqlite3_step(stmt) == SQLITE_DONE) {
					result = 0; // 更新成功
				}

				sqlite3_finalize(stmt);
			}

			sqlite3_close(db);
		}
		return result;

	} catch (const std::exception &) {
		return -1;
	}
}

// 获取所有用户的username、full_name和access_level，返回JSON数组字符串
extern "C" LOGIN_EXPORT int getAllUsersSimpleInfo(char *result, int result_length)
{
	try {
		const char *xnCorePath = std::getenv("XNCore");
		if (!xnCorePath) {
			return -1;
		}
		fs::path dbPath = fs::path(xnCorePath) / "database" / "UserInfo.db";
		sqlite3 *db;
		if (sqlite3_open(dbPath.string().c_str(), &db) != SQLITE_OK) {
			return -1;
		}
		const char *queryStr = "SELECT id, username, full_name, access_level FROM users";
		sqlite3_stmt *stmt;
		json arr = json::array();
		if (sqlite3_prepare_v2(db, queryStr, -1, &stmt, nullptr) == SQLITE_OK) {
			while (sqlite3_step(stmt) == SQLITE_ROW) {
				json userInfo;
				userInfo["id"]		 = sqlite3_column_int(stmt, 0);
				std::string username = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 1));
				userInfo["username"] = username;
				userInfo["full_name"] =
					reinterpret_cast<const char *>(sqlite3_column_text(stmt, 2));
				// access_level 解密
				std::string accessLevelEnc =
					reinterpret_cast<const char *>(sqlite3_column_text(stmt, 3));
				std::vector<unsigned char> iv_and_ciphertext = hex2bin(accessLevelEnc);
				if (iv_and_ciphertext.size() < 16) {
					userInfo["access_level"] = nullptr;
				} else {
					std::vector<unsigned char> iv(iv_and_ciphertext.begin(),
												  iv_and_ciphertext.begin() + 16);
					std::vector<unsigned char> ciphertext(iv_and_ciphertext.begin() + 16,
														  iv_and_ciphertext.end());
					std::string fixed_key		   = "XNSim_Access_Key";
					std::vector<unsigned char> key = derive_aes_key(username, fixed_key);
					try {
						std::string accessLevelStr = aes_decrypt(ciphertext, key, iv);
						userInfo["access_level"]   = std::stoi(accessLevelStr);
					} catch (...) {
						userInfo["access_level"] = nullptr;
					}
				}
				arr.push_back(userInfo);
			}
			sqlite3_finalize(stmt);
		}
		sqlite3_close(db);
		std::string jsonStr = arr.dump();
		if (result_length >= jsonStr.size() + 1) {
			std::strcpy(result, jsonStr.c_str());
			return 0;
		} else {
			return -1;
		}
	} catch (const std::exception &) {
		return -1;
	}
}

extern "C" LOGIN_EXPORT int deleteUser(int user_id)
{
	try {
		const char *xnCorePath = std::getenv("XNCore");
		if (!xnCorePath) {
			return -1;
		}
		fs::path dbPath = fs::path(xnCorePath) / "database" / "UserInfo.db";
		sqlite3 *db;
		if (sqlite3_open(dbPath.string().c_str(), &db) != SQLITE_OK) {
			return -1;
		}
		const char *queryStr = "DELETE FROM users WHERE id = ?";
		sqlite3_stmt *stmt;
		if (sqlite3_prepare_v2(db, queryStr, -1, &stmt, nullptr) == SQLITE_OK) {
			sqlite3_bind_int(stmt, 1, user_id);
			if (sqlite3_step(stmt) == SQLITE_DONE) {
				sqlite3_finalize(stmt);
				sqlite3_close(db);
				return 0;
			}
		}
		sqlite3_close(db);
		return -1;
	} catch (const std::exception &) {
		return -1;
	}
}

// 更新用户头像
extern "C" LOGIN_EXPORT int updateUserIcon(int user_id, const char *icon_base64_buffer,
										   int icon_base64_length)
{
	try {
		if (!icon_base64_buffer || icon_base64_length <= 0) {
			return -1; // 无效的输入参数
		}

		std::string icon_base64(icon_base64_buffer, icon_base64_length);
		if (icon_base64.empty()) {
			return -1; // 空的Base64数据
		}

		const char *xnCorePath = std::getenv("XNCore");
		if (!xnCorePath) {
			return -2; // 环境变量未设置
		}

		fs::path dbPath = fs::path(xnCorePath) / "database" / "UserInfo.db";

		{
			sqlite3 *db;
			if (sqlite3_open(dbPath.string().c_str(), &db) != SQLITE_OK) {
				return -3; // 数据库连接失败
			}

			// 首先检查用户是否存在
			sqlite3_stmt *stmt;
			const char *checkQueryStr = "SELECT id FROM users WHERE id = ?";

			if (sqlite3_prepare_v2(db, checkQueryStr, -1, &stmt, nullptr) == SQLITE_OK) {
				sqlite3_bind_int(stmt, 1, user_id);

				if (sqlite3_step(stmt) != SQLITE_ROW) {
					sqlite3_finalize(stmt);
					sqlite3_close(db);
					return -4; // 用户不存在
				}
				sqlite3_finalize(stmt);
			}

			// 将Base64字符串转换为二进制数据
			std::vector<unsigned char> icon_data;
			try {
				icon_data = base64_decode(icon_base64);
			} catch (...) {
				sqlite3_close(db);
				return -5; // Base64解码失败
			}

			if (icon_data.empty()) {
				sqlite3_close(db);
				return -6; // 解码后数据为空
			}

			// 更新用户头像
			stmt				 = nullptr;
			const char *queryStr = "UPDATE users SET icon = ? WHERE id = ?";

			if (sqlite3_prepare_v2(db, queryStr, -1, &stmt, nullptr) == SQLITE_OK) {
				sqlite3_bind_blob(stmt, 1, icon_data.data(), icon_data.size(), SQLITE_TRANSIENT);
				sqlite3_bind_int(stmt, 2, user_id);

				if (sqlite3_step(stmt) == SQLITE_DONE) {
					sqlite3_finalize(stmt);
					sqlite3_close(db);
					return 0; // 更新成功
				} else {
					// 获取具体的错误信息
					int error_code		  = sqlite3_errcode(db);
					const char *error_msg = sqlite3_errmsg(db);
					std::cout << "UPDATE icon failed with error code: " << error_code
							  << ", message: " << (error_msg ? error_msg : "unknown") << std::endl;
					sqlite3_finalize(stmt);
					sqlite3_close(db);
					return -7; // UPDATE语句执行失败
				}
			} else {
				sqlite3_close(db);
				return -8; // UPDATE语句准备失败
			}
		}

		return -9; // 其他错误
	} catch (const std::exception &) {
		return -10; // 异常错误
	}
}