"""
数据存储系统模块
负责持久化存储用户数据和游戏状态
"""

import time
import threading
import json
import os
import sqlite3
from typing import Dict, Any, List, Optional

class StorageManager:
    """
    数据存储管理器
    负责持久化存储用户数据和游戏状态
    """
    
    def __init__(self, plugin):
        """
        初始化数据存储管理器
        
        Args:
            plugin: 服务器架构插件实例
        """
        self.plugin = plugin
        self.enabled = False
        self.initialized = False
        
        # 存储配置
        self.storage_config = {
            "database_path": "/home/hello/EG/plugins/user/server_architecture/data/server_database.db",
            "enable_caching": True,
            "cache_size": 1000,
            "enable_compression": True,
            "backup_interval": 3600,  # 1小时
            "enable_auto_backup": True,
            "max_backups": 10,
            "enable_encryption": False,
            "enable_async_writes": True
        }
        
        # 数据库连接
        self.db_connection = None
        
        # 缓存管理
        self.data_cache = {}
        self.cache_lock = threading.RLock()
        
        # 存储统计
        self.storage_stats = {
            "reads": 0,
            "writes": 0,
            "cache_hits": 0,
            "cache_misses": 0,
            "backups_created": 0,
            "errors": 0,
            "bytes_read": 0,
            "bytes_written": 0
        }
        
        # 异步写入队列
        self.write_queue = []
        self.write_queue_lock = threading.RLock()
        self.write_thread = None
        self.write_thread_running = False
        
        # 回调函数
        self.storage_callbacks = {
            "data_saved": [],
            "data_loaded": [],
            "backup_created": [],
            "storage_error": []
        }
        
        # 时间戳记录
        self.last_backup = 0.0
        self.last_write = 0.0
        self.last_read = 0.0
        
        print("✓ 数据存储管理器已创建")
        
    def initialize(self) -> bool:
        """
        初始化数据存储管理器
        
        Returns:
            是否初始化成功
        """
        try:
            print("正在初始化数据存储管理器...")
            
            # 创建数据目录
            data_dir = os.path.dirname(self.storage_config["database_path"])
            if not os.path.exists(data_dir):
                os.makedirs(data_dir)
                
            # 初始化数据库
            self._initialize_database()
            
            # 启动异步写入线程
            if self.storage_config["enable_async_writes"]:
                self._start_write_thread()
                
            self.initialized = True
            print("✓ 数据存储管理器初始化完成")
            return True
            
        except Exception as e:
            print(f"✗ 数据存储管理器初始化失败: {e}")
            self.storage_stats["errors"] += 1
            import traceback
            traceback.print_exc()
            return False
            
    def _initialize_database(self):
        """初始化数据库"""
        try:
            # 连接到SQLite数据库
            self.db_connection = sqlite3.connect(
                self.storage_config["database_path"], 
                check_same_thread=False
            )
            
            # 创建表
            cursor = self.db_connection.cursor()
            
            # 用户表
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS users (
                    user_id TEXT PRIMARY KEY,
                    username TEXT UNIQUE NOT NULL,
                    email TEXT,
                    password_hash TEXT,
                    created_time REAL,
                    last_login REAL,
                    user_data TEXT
                )
            ''')
            
            # 房间表
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS rooms (
                    room_id TEXT PRIMARY KEY,
                    room_name TEXT NOT NULL,
                    host_user_id TEXT,
                    created_time REAL,
                    room_settings TEXT,
                    room_state TEXT
                )
            ''')
            
            # 游戏状态表
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS game_states (
                    state_id TEXT PRIMARY KEY,
                    room_id TEXT,
                    state_data TEXT,
                    timestamp REAL,
                    FOREIGN KEY (room_id) REFERENCES rooms (room_id)
                )
            ''')
            
            # 用户房间关系表
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS user_rooms (
                    user_id TEXT,
                    room_id TEXT,
                    join_time REAL,
                    PRIMARY KEY (user_id, room_id),
                    FOREIGN KEY (user_id) REFERENCES users (user_id),
                    FOREIGN KEY (room_id) REFERENCES rooms (room_id)
                )
            ''')
            
            # 系统配置表
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS system_config (
                    config_key TEXT PRIMARY KEY,
                    config_value TEXT,
                    updated_time REAL
                )
            ''')
            
            # 日志表
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS logs (
                    log_id INTEGER PRIMARY KEY AUTOINCREMENT,
                    log_level TEXT,
                    log_message TEXT,
                    timestamp REAL,
                    user_id TEXT
                )
            ''')
            
            # 提交更改
            self.db_connection.commit()
            
            print("✓ 数据库初始化完成")
            
        except Exception as e:
            print(f"✗ 数据库初始化失败: {e}")
            self.storage_stats["errors"] += 1
            raise
            
    def _start_write_thread(self):
        """启动异步写入线程"""
        try:
            self.write_thread_running = True
            self.write_thread = threading.Thread(target=self._write_thread_loop, daemon=True)
            self.write_thread.start()
            print("✓ 异步写入线程已启动")
        except Exception as e:
            print(f"✗ 异步写入线程启动失败: {e}")
            self.storage_stats["errors"] += 1
            
    def _write_thread_loop(self):
        """异步写入线程循环"""
        try:
            while self.write_thread_running:
                try:
                    # 处理写入队列
                    self._process_write_queue()
                    
                    # 短暂休眠
                    time.sleep(0.1)
                    
                except Exception as e:
                    print(f"✗ 异步写入循环错误: {e}")
                    self.storage_stats["errors"] += 1
                    time.sleep(1.0)  # 出错时延长休眠
                    
        except Exception as e:
            print(f"✗ 异步写入线程失败: {e}")
            self.storage_stats["errors"] += 1
            
    def _process_write_queue(self):
        """处理写入队列"""
        try:
            if not self.write_queue:
                return
                
            with self.write_queue_lock:
                write_items = self.write_queue[:]
                self.write_queue.clear()
                
            # 执行写入操作
            for item in write_items:
                try:
                    operation = item["operation"]
                    if operation == "save_user":
                        self._save_user_internal(item["user_id"], item["user_data"])
                    elif operation == "save_room":
                        self._save_room_internal(item["room_id"], item["room_data"])
                    elif operation == "save_game_state":
                        self._save_game_state_internal(item["state_id"], item["state_data"])
                        
                except Exception as e:
                    print(f"✗ 队列写入操作失败: {e}")
                    self.storage_stats["errors"] += 1
                    
        except Exception as e:
            print(f"✗ 写入队列处理失败: {e}")
            self.storage_stats["errors"] += 1
            
    def enable(self) -> bool:
        """
        启用数据存储管理器
        
        Returns:
            是否启用成功
        """
        try:
            if not self.initialized:
                print("✗ 数据存储管理器未初始化")
                return False
                
            self.enabled = True
            print("✓ 数据存储管理器已启用")
            return True
            
        except Exception as e:
            print(f"✗ 数据存储管理器启用失败: {e}")
            self.storage_stats["errors"] += 1
            import traceback
            traceback.print_exc()
            return False
            
    def disable(self):
        """禁用数据存储管理器"""
        try:
            self.enabled = False
            
            # 停止异步写入线程
            if self.write_thread_running:
                self.write_thread_running = False
                if self.write_thread and self.write_thread.is_alive():
                    self.write_thread.join(timeout=5.0)
                    
            # 处理剩余的写入队列
            self._process_write_queue()
            
            # 关闭数据库连接
            if self.db_connection:
                self.db_connection.close()
                self.db_connection = None
                
            print("✓ 数据存储管理器已禁用")
            
        except Exception as e:
            print(f"✗ 数据存储管理器禁用失败: {e}")
            self.storage_stats["errors"] += 1
            import traceback
            traceback.print_exc()
            
    def finalize(self):
        """清理数据存储管理器资源"""
        try:
            # 禁用管理器
            if self.enabled:
                self.disable()
                
            # 清理缓存和回调
            with self.cache_lock:
                self.data_cache.clear()
            self.storage_callbacks.clear()
            
            self.initialized = False
            print("✓ 数据存储管理器资源已清理")
            
        except Exception as e:
            print(f"✗ 数据存储管理器资源清理失败: {e}")
            import traceback
            traceback.print_exc()
            
    def update(self, dt: float):
        """
        更新数据存储管理器状态
        
        Args:
            dt: 时间增量（秒）
        """
        try:
            if not self.enabled:
                return
                
            current_time = time.time()
            
            # 定期创建备份
            if (self.storage_config["enable_auto_backup"] and 
                current_time - self.last_backup > self.storage_config["backup_interval"]):
                self._create_backup()
                self.last_backup = current_time
                
        except Exception as e:
            print(f"✗ 数据存储管理器更新失败: {e}")
            self.storage_stats["errors"] += 1
            import traceback
            traceback.print_exc()
            
    def _create_backup(self):
        """创建数据库备份"""
        try:
            if not self.db_connection:
                return
                
            # 创建备份文件名
            backup_dir = os.path.dirname(self.storage_config["database_path"])
            backup_filename = f"backup_{int(time.time())}.db"
            backup_path = os.path.join(backup_dir, backup_filename)
            
            # 复制数据库文件
            import shutil
            shutil.copy2(self.storage_config["database_path"], backup_path)
            
            self.storage_stats["backups_created"] += 1
            
            # 清理旧备份
            self._cleanup_old_backups()
            
            # 触发备份创建回调
            self._trigger_storage_callback("backup_created", {
                "backup_path": backup_path,
                "timestamp": time.time()
            })
            
            print(f"✓ 数据库备份已创建: {backup_path}")
            
        except Exception as e:
            print(f"✗ 数据库备份创建失败: {e}")
            self.storage_stats["errors"] += 1
            
    def _cleanup_old_backups(self):
        """清理旧备份"""
        try:
            backup_dir = os.path.dirname(self.storage_config["database_path"])
            backup_files = []
            
            # 查找备份文件
            for filename in os.listdir(backup_dir):
                if filename.startswith("backup_") and filename.endswith(".db"):
                    filepath = os.path.join(backup_dir, filename)
                    backup_files.append((filepath, os.path.getmtime(filepath)))
                    
            # 按修改时间排序
            backup_files.sort(key=lambda x: x[1], reverse=True)
            
            # 删除多余的备份
            for filepath, _ in backup_files[self.storage_config["max_backups"]:]:
                try:
                    os.remove(filepath)
                    print(f"✓ 旧备份已删除: {filepath}")
                except Exception as e:
                    print(f"✗ 旧备份删除失败: {filepath} - {e}")
                    
        except Exception as e:
            print(f"✗ 旧备份清理失败: {e}")
            self.storage_stats["errors"] += 1
            
    def save_user(self, user_id: str, user_data: Dict[str, Any]) -> bool:
        """
        保存用户数据
        
        Args:
            user_id: 用户ID
            user_data: 用户数据
            
        Returns:
            是否保存成功
        """
        try:
            if not self.enabled:
                return False
                
            # 更新缓存
            if self.storage_config["enable_caching"]:
                with self.cache_lock:
                    self.data_cache[f"user_{user_id}"] = {
                        "data": user_data.copy(),
                        "timestamp": time.time()
                    }
                    
                    # 保持缓存大小
                    if len(self.data_cache) > self.storage_config["cache_size"]:
                        # 移除最旧的缓存项
                        oldest_key = min(self.data_cache.keys(), 
                                       key=lambda k: self.data_cache[k]["timestamp"])
                        del self.data_cache[oldest_key]
                        
            # 异步写入
            if self.storage_config["enable_async_writes"]:
                with self.write_queue_lock:
                    self.write_queue.append({
                        "operation": "save_user",
                        "user_id": user_id,
                        "user_data": user_data
                    })
                return True
            else:
                # 同步写入
                return self._save_user_internal(user_id, user_data)
                
        except Exception as e:
            print(f"✗ 保存用户数据失败: {e}")
            self.storage_stats["errors"] += 1
            return False
            
    def _save_user_internal(self, user_id: str, user_data: Dict[str, Any]) -> bool:
        """
        内部保存用户数据
        
        Args:
            user_id: 用户ID
            user_data: 用户数据
            
        Returns:
            是否保存成功
        """
        try:
            if not self.db_connection:
                return False
                
            cursor = self.db_connection.cursor()
            
            # 序列化用户数据
            user_data_json = json.dumps(user_data, ensure_ascii=False)
            
            # 插入或更新用户数据
            cursor.execute('''
                INSERT OR REPLACE INTO users 
                (user_id, username, email, password_hash, created_time, last_login, user_data)
                VALUES (?, ?, ?, ?, ?, ?, ?)
            ''', (
                user_id,
                user_data.get("username", ""),
                user_data.get("email", ""),
                user_data.get("password_hash", ""),
                user_data.get("created_time", time.time()),
                user_data.get("last_login", 0),
                user_data_json
            ))
            
            self.db_connection.commit()
            self.storage_stats["writes"] += 1
            self.last_write = time.time()
            
            # 触发数据保存回调
            self._trigger_storage_callback("data_saved", {
                "data_type": "user",
                "user_id": user_id,
                "timestamp": self.last_write
            })
            
            return True
            
        except Exception as e:
            print(f"✗ 内部保存用户数据失败: {e}")
            self.storage_stats["errors"] += 1
            return False
            
    def load_user(self, user_id: str) -> Optional[Dict[str, Any]]:
        """
        加载用户数据
        
        Args:
            user_id: 用户ID
            
        Returns:
            用户数据或None
        """
        try:
            if not self.enabled:
                return None
                
            # 检查缓存
            if self.storage_config["enable_caching"]:
                cache_key = f"user_{user_id}"
                with self.cache_lock:
                    if cache_key in self.data_cache:
                        self.storage_stats["cache_hits"] += 1
                        cached_data = self.data_cache[cache_key]
                        return cached_data["data"].copy()
                    else:
                        self.storage_stats["cache_misses"] += 1
                        
            # 从数据库加载
            if not self.db_connection:
                return None
                
            cursor = self.db_connection.cursor()
            cursor.execute('SELECT user_data FROM users WHERE user_id = ?', (user_id,))
            result = cursor.fetchone()
            
            if result:
                user_data = json.loads(result[0])
                self.storage_stats["reads"] += 1
                self.last_read = time.time()
                
                # 更新缓存
                if self.storage_config["enable_caching"]:
                    with self.cache_lock:
                        self.data_cache[f"user_{user_id}"] = {
                            "data": user_data,
                            "timestamp": self.last_read
                        }
                        
                # 触发数据加载回调
                self._trigger_storage_callback("data_loaded", {
                    "data_type": "user",
                    "user_id": user_id,
                    "timestamp": self.last_read
                })
                
                return user_data
            else:
                return None
                
        except Exception as e:
            print(f"✗ 加载用户数据失败: {e}")
            self.storage_stats["errors"] += 1
            return None
            
    def save_room(self, room_id: str, room_data: Dict[str, Any]) -> bool:
        """
        保存房间数据
        
        Args:
            room_id: 房间ID
            room_data: 房间数据
            
        Returns:
            是否保存成功
        """
        try:
            if not self.enabled:
                return False
                
            # 更新缓存
            if self.storage_config["enable_caching"]:
                with self.cache_lock:
                    self.data_cache[f"room_{room_id}"] = {
                        "data": room_data.copy(),
                        "timestamp": time.time()
                    }
                    
            # 异步写入
            if self.storage_config["enable_async_writes"]:
                with self.write_queue_lock:
                    self.write_queue.append({
                        "operation": "save_room",
                        "room_id": room_id,
                        "room_data": room_data
                    })
                return True
            else:
                # 同步写入
                return self._save_room_internal(room_id, room_data)
                
        except Exception as e:
            print(f"✗ 保存房间数据失败: {e}")
            self.storage_stats["errors"] += 1
            return False
            
    def _save_room_internal(self, room_id: str, room_data: Dict[str, Any]) -> bool:
        """
        内部保存房间数据
        
        Args:
            room_id: 房间ID
            room_data: 房间数据
            
        Returns:
            是否保存成功
        """
        try:
            if not self.db_connection:
                return False
                
            cursor = self.db_connection.cursor()
            
            # 序列化房间数据
            room_settings_json = json.dumps(room_data.get("settings", {}), ensure_ascii=False)
            room_state_json = json.dumps(room_data.get("state", {}), ensure_ascii=False)
            
            # 插入或更新房间数据
            cursor.execute('''
                INSERT OR REPLACE INTO rooms 
                (room_id, room_name, host_user_id, created_time, room_settings, room_state)
                VALUES (?, ?, ?, ?, ?, ?)
            ''', (
                room_id,
                room_data.get("room_name", ""),
                room_data.get("host_user_id"),
                room_data.get("created_time", time.time()),
                room_settings_json,
                room_state_json
            ))
            
            self.db_connection.commit()
            self.storage_stats["writes"] += 1
            self.last_write = time.time()
            
            # 触发数据保存回调
            self._trigger_storage_callback("data_saved", {
                "data_type": "room",
                "room_id": room_id,
                "timestamp": self.last_write
            })
            
            return True
            
        except Exception as e:
            print(f"✗ 内部保存房间数据失败: {e}")
            self.storage_stats["errors"] += 1
            return False
            
    def load_room(self, room_id: str) -> Optional[Dict[str, Any]]:
        """
        加载房间数据
        
        Args:
            room_id: 房间ID
            
        Returns:
            房间数据或None
        """
        try:
            if not self.enabled:
                return None
                
            # 检查缓存
            if self.storage_config["enable_caching"]:
                cache_key = f"room_{room_id}"
                with self.cache_lock:
                    if cache_key in self.data_cache:
                        self.storage_stats["cache_hits"] += 1
                        cached_data = self.data_cache[cache_key]
                        return cached_data["data"].copy()
                    else:
                        self.storage_stats["cache_misses"] += 1
                        
            # 从数据库加载
            if not self.db_connection:
                return None
                
            cursor = self.db_connection.cursor()
            cursor.execute('''
                SELECT room_name, host_user_id, created_time, room_settings, room_state 
                FROM rooms WHERE room_id = ?
            ''', (room_id,))
            result = cursor.fetchone()
            
            if result:
                room_data = {
                    "room_id": room_id,
                    "room_name": result[0],
                    "host_user_id": result[1],
                    "created_time": result[2],
                    "settings": json.loads(result[3]) if result[3] else {},
                    "state": json.loads(result[4]) if result[4] else {}
                }
                
                self.storage_stats["reads"] += 1
                self.last_read = time.time()
                
                # 更新缓存
                if self.storage_config["enable_caching"]:
                    with self.cache_lock:
                        self.data_cache[f"room_{room_id}"] = {
                            "data": room_data,
                            "timestamp": self.last_read
                        }
                        
                # 触发数据加载回调
                self._trigger_storage_callback("data_loaded", {
                    "data_type": "room",
                    "room_id": room_id,
                    "timestamp": self.last_read
                })
                
                return room_data
            else:
                return None
                
        except Exception as e:
            print(f"✗ 加载房间数据失败: {e}")
            self.storage_stats["errors"] += 1
            return None
            
    def save_game_state(self, state_id: str, state_data: Dict[str, Any]) -> bool:
        """
        保存游戏状态数据
        
        Args:
            state_id: 状态ID
            state_data: 游戏状态数据
            
        Returns:
            是否保存成功
        """
        try:
            if not self.enabled:
                return False
                
            # 异步写入
            if self.storage_config["enable_async_writes"]:
                with self.write_queue_lock:
                    self.write_queue.append({
                        "operation": "save_game_state",
                        "state_id": state_id,
                        "state_data": state_data
                    })
                return True
            else:
                # 同步写入
                return self._save_game_state_internal(state_id, state_data)
                
        except Exception as e:
            print(f"✗ 保存游戏状态数据失败: {e}")
            self.storage_stats["errors"] += 1
            return False
            
    def _save_game_state_internal(self, state_id: str, state_data: Dict[str, Any]) -> bool:
        """
        内部保存游戏状态数据
        
        Args:
            state_id: 状态ID
            state_data: 游戏状态数据
            
        Returns:
            是否保存成功
        """
        try:
            if not self.db_connection:
                return False
                
            cursor = self.db_connection.cursor()
            
            # 序列化游戏状态数据
            state_data_json = json.dumps(state_data, ensure_ascii=False)
            
            # 插入或更新游戏状态数据
            cursor.execute('''
                INSERT OR REPLACE INTO game_states 
                (state_id, room_id, state_data, timestamp)
                VALUES (?, ?, ?, ?)
            ''', (
                state_id,
                state_data.get("room_id"),
                state_data_json,
                state_data.get("timestamp", time.time())
            ))
            
            self.db_connection.commit()
            self.storage_stats["writes"] += 1
            self.last_write = time.time()
            
            # 触发数据保存回调
            self._trigger_storage_callback("data_saved", {
                "data_type": "game_state",
                "state_id": state_id,
                "timestamp": self.last_write
            })
            
            return True
            
        except Exception as e:
            print(f"✗ 内部保存游戏状态数据失败: {e}")
            self.storage_stats["errors"] += 1
            return False
            
    def load_game_state(self, state_id: str) -> Optional[Dict[str, Any]]:
        """
        加载游戏状态数据
        
        Args:
            state_id: 状态ID
            
        Returns:
            游戏状态数据或None
        """
        try:
            if not self.enabled:
                return None
                
            # 从数据库加载
            if not self.db_connection:
                return None
                
            cursor = self.db_connection.cursor()
            cursor.execute('SELECT room_id, state_data, timestamp FROM game_states WHERE state_id = ?', (state_id,))
            result = cursor.fetchone()
            
            if result:
                state_data = {
                    "state_id": state_id,
                    "room_id": result[0],
                    "data": json.loads(result[1]) if result[1] else {},
                    "timestamp": result[2]
                }
                
                self.storage_stats["reads"] += 1
                self.last_read = time.time()
                
                # 触发数据加载回调
                self._trigger_storage_callback("data_loaded", {
                    "data_type": "game_state",
                    "state_id": state_id,
                    "timestamp": self.last_read
                })
                
                return state_data
            else:
                return None
                
        except Exception as e:
            print(f"✗ 加载游戏状态数据失败: {e}")
            self.storage_stats["errors"] += 1
            return None
            
    def get_user_rooms(self, user_id: str) -> List[str]:
        """
        获取用户所在的房间列表
        
        Args:
            user_id: 用户ID
            
        Returns:
            房间ID列表
        """
        try:
            if not self.db_connection:
                return []
                
            cursor = self.db_connection.cursor()
            cursor.execute('SELECT room_id FROM user_rooms WHERE user_id = ?', (user_id,))
            results = cursor.fetchall()
            
            return [row[0] for row in results]
            
        except Exception as e:
            print(f"✗ 获取用户房间列表失败: {e}")
            self.storage_stats["errors"] += 1
            return []
            
    def add_user_to_room(self, user_id: str, room_id: str) -> bool:
        """
        添加用户到房间
        
        Args:
            user_id: 用户ID
            room_id: 房间ID
            
        Returns:
            是否添加成功
        """
        try:
            if not self.db_connection:
                return False
                
            cursor = self.db_connection.cursor()
            cursor.execute('''
                INSERT OR IGNORE INTO user_rooms (user_id, room_id, join_time)
                VALUES (?, ?, ?)
            ''', (user_id, room_id, time.time()))
            
            self.db_connection.commit()
            return True
            
        except Exception as e:
            print(f"✗ 添加用户到房间失败: {e}")
            self.storage_stats["errors"] += 1
            return False
            
    def remove_user_from_room(self, user_id: str, room_id: str) -> bool:
        """
        从房间移除用户
        
        Args:
            user_id: 用户ID
            room_id: 房间ID
            
        Returns:
            是否移除成功
        """
        try:
            if not self.db_connection:
                return False
                
            cursor = self.db_connection.cursor()
            cursor.execute('DELETE FROM user_rooms WHERE user_id = ? AND room_id = ?', (user_id, room_id))
            
            self.db_connection.commit()
            return True
            
        except Exception as e:
            print(f"✗ 从房间移除用户失败: {e}")
            self.storage_stats["errors"] += 1
            return False
            
    def save_system_config(self, config_key: str, config_value: Any) -> bool:
        """
        保存系统配置
        
        Args:
            config_key: 配置键
            config_value: 配置值
            
        Returns:
            是否保存成功
        """
        try:
            if not self.db_connection:
                return False
                
            cursor = self.db_connection.cursor()
            config_value_str = json.dumps(config_value, ensure_ascii=False)
            
            cursor.execute('''
                INSERT OR REPLACE INTO system_config (config_key, config_value, updated_time)
                VALUES (?, ?, ?)
            ''', (config_key, config_value_str, time.time()))
            
            self.db_connection.commit()
            self.storage_stats["writes"] += 1
            return True
            
        except Exception as e:
            print(f"✗ 保存系统配置失败: {e}")
            self.storage_stats["errors"] += 1
            return False
            
    def load_system_config(self, config_key: str, default_value: Any = None) -> Any:
        """
        加载系统配置
        
        Args:
            config_key: 配置键
            default_value: 默认值
            
        Returns:
            配置值或默认值
        """
        try:
            if not self.db_connection:
                return default_value
                
            cursor = self.db_connection.cursor()
            cursor.execute('SELECT config_value FROM system_config WHERE config_key = ?', (config_key,))
            result = cursor.fetchone()
            
            if result:
                return json.loads(result[0])
            else:
                return default_value
                
        except Exception as e:
            print(f"✗ 加载系统配置失败: {e}")
            self.storage_stats["errors"] += 1
            return default_value
            
    def add_log(self, log_level: str, log_message: str, user_id: str = None) -> bool:
        """
        添加日志
        
        Args:
            log_level: 日志级别
            log_message: 日志消息
            user_id: 用户ID（可选）
            
        Returns:
            是否添加成功
        """
        try:
            if not self.db_connection:
                return False
                
            cursor = self.db_connection.cursor()
            cursor.execute('''
                INSERT INTO logs (log_level, log_message, timestamp, user_id)
                VALUES (?, ?, ?, ?)
            ''', (log_level, log_message, time.time(), user_id))
            
            self.db_connection.commit()
            return True
            
        except Exception as e:
            print(f"✗ 添加日志失败: {e}")
            self.storage_stats["errors"] += 1
            return False
            
    def get_storage_stats(self) -> Dict[str, Any]:
        """
        获取存储统计信息
        
        Returns:
            存储统计字典
        """
        return {
            "stats": self.storage_stats.copy(),
            "config": self.storage_config.copy(),
            "cache_size": len(self.data_cache),
            "write_queue_size": len(self.write_queue)
        }
        
    def reset_stats(self):
        """重置存储统计信息"""
        try:
            self.storage_stats = {
                "reads": 0,
                "writes": 0,
                "cache_hits": 0,
                "cache_misses": 0,
                "backups_created": 0,
                "errors": 0,
                "bytes_read": 0,
                "bytes_written": 0
            }
            print("✓ 存储统计信息已重置")
        except Exception as e:
            print(f"✗ 存储统计信息重置失败: {e}")
            
    def set_storage_config(self, config: Dict[str, Any]) -> bool:
        """
        设置存储配置
        
        Args:
            config: 存储配置字典
            
        Returns:
            是否设置成功
        """
        try:
            old_async = self.storage_config["enable_async_writes"]
            new_async = config.get("enable_async_writes", old_async)
            
            # 如果异步写入设置发生变化，处理线程
            if old_async != new_async:
                if new_async and not self.write_thread_running:
                    self._start_write_thread()
                elif not new_async and self.write_thread_running:
                    self.write_thread_running = False
                    if self.write_thread and self.write_thread.is_alive():
                        self.write_thread.join(timeout=2.0)
                        
            self.storage_config.update(config)
            print(f"✓ 存储配置已更新: {self.storage_config}")
            return True
        except Exception as e:
            print(f"✗ 存储配置设置失败: {e}")
            return False
            
    def get_storage_config(self) -> Dict[str, Any]:
        """
        获取存储配置
        
        Returns:
            存储配置字典
        """
        return self.storage_config.copy()
        
    def clear_cache(self):
        """清空缓存"""
        try:
            with self.cache_lock:
                self.data_cache.clear()
            print("✓ 存储缓存已清空")
        except Exception as e:
            print(f"✗ 存储缓存清空失败: {e}")
            self.storage_stats["errors"] += 1
            
    def _trigger_storage_callback(self, callback_type: str, data: Dict[str, Any]):
        """
        触发存储回调
        
        Args:
            callback_type: 回调类型
            data: 回调数据
        """
        try:
            if callback_type in self.storage_callbacks:
                for callback in self.storage_callbacks[callback_type]:
                    try:
                        callback(data)
                    except Exception as e:
                        print(f"✗ 存储回调执行失败: {callback_type} - {e}")
        except Exception as e:
            print(f"✗ 存储回调触发失败: {e}")
            
    def register_storage_callback(self, callback_type: str, callback: callable):
        """
        注册存储回调
        
        Args:
            callback_type: 回调类型
            callback: 回调函数
        """
        try:
            if callback_type in self.storage_callbacks:
                self.storage_callbacks[callback_type].append(callback)
                print(f"✓ 存储回调已注册: {callback_type}")
            else:
                print(f"✗ 无效的回调类型: {callback_type}")
        except Exception as e:
            print(f"✗ 存储回调注册失败: {e}")
            
    def unregister_storage_callback(self, callback_type: str, callback: callable):
        """
        注销存储回调
        
        Args:
            callback_type: 回调类型
            callback: 回调函数
        """
        try:
            if callback_type in self.storage_callbacks:
                if callback in self.storage_callbacks[callback_type]:
                    self.storage_callbacks[callback_type].remove(callback)
                    print(f"✓ 存储回调已注销: {callback_type}")
            else:
                print(f"✗ 无效的回调类型: {callback_type}")
        except Exception as e:
            print(f"✗ 存储回调注销失败: {e}")

