import 'dart:convert';

import 'package:ainoval/models/editor_content.dart';
import 'package:ainoval/models/novel_structure.dart' as novel_models;
import 'package:ainoval/models/novel_summary.dart';
import 'package:ainoval/utils/logger.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:uuid/uuid.dart'; // Import uuid package
import 'package:hive/hive.dart';

import '../models/chat_models.dart';

/// 本地存储服务，用于缓存和获取小说数据
class LocalStorageService {
  SharedPreferences? _prefs;
  final Uuid _uuid = const Uuid(); // For generating unique local IDs

  // 添加小说缓存
  final Map<String, novel_models.Novel> _novelCache = {};
  final Map<String, DateTime> _novelCacheTimestamp = {};
  final Duration _cacheTTL = const Duration(minutes: 5); // 缓存有效期
  final Map<String, String> _wordCountCache = {}; // 场景字数缓存

  // 初始化
  Future<void> init() async {
    _prefs ??= await SharedPreferences.getInstance();
  }

  // 确保已初始化
  Future<SharedPreferences> _ensureInitialized() async {
    if (_prefs == null) {
      await init();
    }
    return _prefs!;
  }

  // 基础存储方法
  Future<String?> getString(String key) async {
    final prefs = await _ensureInitialized();
    return prefs.getString(key);
  }

  Future<bool> setString(String key, String value) async {
    final prefs = await _ensureInitialized();
    return await prefs.setString(key, value);
  }

  Future<bool> remove(String key) async {
    final prefs = await _ensureInitialized();
    return await prefs.remove(key);
  }

  // 存储键
  static const String _novelsKey = 'novels';
  static const String _currentNovelKey = 'current_novel';
  static const String _editorContentPrefix = 'editor_content_';
  static const String _editorSettingsKey = 'editor_settings';

  // --- New Key for Pending Messages ---
  static const String _pendingMessagesKey = 'pending_chat_messages';

  // 获取所有小说
  Future<List<novel_models.Novel>> getNovels() async {
    final prefs = await _ensureInitialized();
    final novelsJson = prefs.getStringList(_novelsKey) ?? [];
/*     AppLogger.d('LocalStorageService',
        'getNovels: Raw JSON list from prefs: $novelsJson');
 */
    try {
      final novels = novelsJson.map((json) {
        // AppLogger.v('LocalStorageService', 'getNovels: Parsing JSON: $json');
        final novel = novel_models.Novel.fromJson(jsonDecode(json));
        AppLogger.v('LocalStorageService',
            'getNovels: Parsed Novel: ID=${novel.id}, Title=${novel.title}, Acts=${novel.acts.length}');
        return novel;
      }).toList();
      AppLogger.i('LocalStorageService',
          'getNovels: Successfully parsed ${novels.length} novels.');
      return novels;
    } catch (e, stackTrace) {
      AppLogger.e('LocalStorageService',
          'getNovels: Failed to parse novels JSON.', e, stackTrace);
      return [];
    }
  }

  // 保存所有小说
  Future<void> saveNovels(List<novel_models.Novel> novels) async {
    final prefs = await _ensureInitialized();
    try {
      final novelsJson = novels.map((novel) {
        final jsonMap = novel.toJson();
        final jsonString = jsonEncode(jsonMap);
        AppLogger.v('LocalStorageService',
            'saveNovels: Serializing Novel ID=${novel.id}, Title=${novel.title}, Acts=${novel.acts.length}');
        return jsonString;
      }).toList();

/*       AppLogger.d('LocalStorageService',
          'saveNovels: Saving JSON list to prefs: $novelsJson'); */
      await prefs.setStringList(_novelsKey, novelsJson);
      AppLogger.i('LocalStorageService',
          'saveNovels: Successfully saved ${novels.length} novels.');
    } catch (e, stackTrace) {
      AppLogger.e('LocalStorageService', 'saveNovels: Failed to save  novels.',
          e, stackTrace);
    }
  }

  // 保存小说摘要列表
  Future<void> saveNovelSummaries(List<NovelSummary> novels) async {
    final prefs = await _ensureInitialized();
    final novelsJson =
        novels.map((novel) => jsonEncode(novel.toJson())).toList();

    await prefs.setStringList('novel_summaries', novelsJson);
  }

  // 获取单个小说
  Future<novel_models.Novel?> getNovel(String id) async {
    AppLogger.d('LocalStorageService',
        'getNovel: Attempting to get novel with ID: $id');
    
    // 检查缓存是否存在且有效
    if (_novelCache.containsKey(id)) {
      final cacheTime = _novelCacheTimestamp[id];
      if (cacheTime != null && DateTime.now().difference(cacheTime) < _cacheTTL) {
        AppLogger.i('LocalStorageService',
            'getNovel: Using cached novel: ID=$id, Title=${_novelCache[id]!.title}, Acts=${_novelCache[id]!.acts.length}');
        return _novelCache[id];
      }
    }
    
    // 缓存不存在或已过期，从存储获取
    final novels = await getNovels();
    try {
      final novel = novels.firstWhere(
        (novel) => novel.id == id,
      );
      
      // 更新缓存
      _novelCache[id] = novel;
      _novelCacheTimestamp[id] = DateTime.now();
      
      AppLogger.i('LocalStorageService',
          'getNovel: Found novel: ID=${novel.id}, Title=${novel.title}, Acts=${novel.acts.length}');
      return novel;
    } catch (e) {
      AppLogger.w(
          'LocalStorageService', 'getNovel: Novel with ID $id not found.', e);
      return null;
    }
  }

  // 保存单个小说
  Future<void> saveNovel(novel_models.Novel novel) async {
    //AppLogger.d('LocalStorageService',
    //    'saveNovel: Attempting to save novel ID=${novel.id}, Title=${novel.title}, Acts=${novel.acts.length}');
    
    // 检查上次保存时间，如果短时间内多次保存同一个小说，可以合并为一次操作
    final cacheTime = _novelCacheTimestamp[novel.id];
    final now = DateTime.now();
    if (cacheTime != null && now.difference(cacheTime).inMilliseconds < 500) {
      // 如果500毫秒内有多次保存，只更新缓存，延迟实际的存储操作
      _novelCache[novel.id] = novel;
      _novelCacheTimestamp[novel.id] = now;
      //AppLogger.i('LocalStorageService',
      //    'saveNovel: Multiple saves detected within 500ms, delaying actual storage operation for novel ID=${novel.id}');
      return;
    }
    
    // 更新缓存
    _novelCache[novel.id] = novel;
    _novelCacheTimestamp[novel.id] = now;
    
    try {
      final novels = await getNovels();
      final index = novels.indexWhere((n) => n.id == novel.id);

      if (index >= 0) {
        AppLogger.d('LocalStorageService',
            'saveNovel: Updating existing novel at index $index.');
        novels[index] = novel;
      } else {
        AppLogger.d('LocalStorageService', 'saveNovel: Adding new novel.');
        novels.add(novel);
      }

      await saveNovels(novels);
      AppLogger.i('LocalStorageService',
          'saveNovel: Completed saving process for novel ID=${novel.id}.');
    } catch (e) {
      AppLogger.e('LocalStorageService', 'saveNovel: Failed to save novel', e);
      // 从缓存中移除，以便下次重新加载
      _novelCache.remove(novel.id);
      _novelCacheTimestamp.remove(novel.id);
      throw Exception('保存小说失败: $e');
    }
  }

  // 删除小说
  Future<void> deleteNovel(String id) async {
    final novels = await getNovels();
    novels.removeWhere((novel) => novel.id == id);
    await saveNovels(novels);
  }

  // 获取当前正在编辑的小说ID
  Future<String?> getCurrentNovelId() async {
    final prefs = await _ensureInitialized();
    return prefs.getString(_currentNovelKey);
  }

  // 设置当前正在编辑的小说ID
  Future<void> setCurrentNovelId(String id) async {
    final prefs = await _ensureInitialized();
    final previousId = prefs.getString(_currentNovelKey);
    
    // 如果前一个小说ID存在且与新ID不同，清理前一个小说的同步标记
    if (previousId != null && previousId.isNotEmpty && previousId != id) {
      AppLogger.i('LocalStorageService', '小说ID切换: $previousId -> $id');
      
      // 如果是设置为空ID（特殊情况，如app关闭），不触发清理
      if (id.isNotEmpty) {
        await clearNovelSyncFlags(previousId);
      }
    }
    
    await prefs.setString(_currentNovelKey, id);
    AppLogger.i('LocalStorageService', '当前小说ID已设置为: $id');
  }

  // 获取章节内容
  Future<EditorContent?> getChapterContent(
      String novelId, String chapterId) async {
    final prefs = await _ensureInitialized();
    final key = _getContentKey(novelId, chapterId);
    final jsonString = prefs.getString(key);

    if (jsonString == null) {
      return null;
    }

    try {
      final json = jsonDecode(jsonString);
      return EditorContent.fromJson(json);
    } catch (e) {
      AppLogger.e('LocalStorageService', '解析章节内容失败', e);
      return null;
    }
  }

  // 保存章节内容
  Future<void> saveChapterContent(
      String novelId, String chapterId, EditorContent content) async {
    final prefs = await _ensureInitialized();
    final key = _getContentKey(novelId, chapterId);
    final jsonString = jsonEncode(content.toJson());

    await prefs.setString(key, jsonString);
  }

  // 获取编辑器内容
  Future<EditorContent?> getEditorContent(
      String novelId, String chapterId, String sceneId) async {
    return getChapterContent(novelId, chapterId);
  }

  // 保存编辑器内容
  Future<void> saveEditorContent(EditorContent content) async {
    final parts = content.id.split('-');
    if (parts.length == 3) {
      final novelId = parts[0];
      final chapterId = parts[1];
      final sceneId = parts[2];
      await saveChapterContent(novelId, chapterId, content);
    } else if (parts.length == 2) {
      // 兼容旧格式
      final novelId = parts[0];
      final chapterId = parts[1];
      await saveChapterContent(novelId, chapterId, content);
    }
  }

  // 获取编辑器设置
  Future<Map<String, dynamic>> getEditorSettings() async {
    try {
      final prefs = await _ensureInitialized();
      final settingsJson = prefs.getString('editor_settings');

      if (settingsJson != null) {
        return jsonDecode(settingsJson) as Map<String, dynamic>;
      }

      // 返回默认设置
      return {
        'fontSize': 16.0,
        'lineHeight': 1.5,
        'fontFamily': 'Roboto',
        'theme': 'light',
        'autoSave': true,
      };
    } catch (e) {
      AppLogger.e('LocalStorageService', '获取编辑器设置失败', e);
      // 返回默认设置
      return {
        'fontSize': 16.0,
        'lineHeight': 1.5,
        'fontFamily': 'Roboto',
        'theme': 'light',
        'autoSave': true,
      };
    }
  }

  // 保存编辑器设置
  Future<void> saveEditorSettings(Map<String, dynamic> settings) async {
    try {
      final prefs = await _ensureInitialized();
      await prefs.setString('editor_settings', jsonEncode(settings));
    } catch (e) {
      AppLogger.e('LocalStorageService', '保存编辑器设置失败', e);
      throw Exception('保存编辑器设置失败: $e');
    }
  }

  // 生成内容存储键
  String _getContentKey(String novelId, String chapterId) {
    return '$_editorContentPrefix${novelId}_$chapterId';
  }

  /// 获取场景内容
  Future<novel_models.Scene?> getSceneContent(
      String novelId, String actId, String chapterId, String sceneId) async {
    try {
      final novel = await getNovel(novelId);
      if (novel == null) return null;

      final act = novel.acts.firstWhere((a) => a.id == actId);
      final chapter = act.chapters.firstWhere((c) => c.id == chapterId);

      if (chapter.scenes.isEmpty) return null;

      // 查找特定场景
      try {
        return chapter.scenes.firstWhere((s) => s.id == sceneId);
      } catch (e) {
        // 如果找不到特定场景，返回第一个场景
        return chapter.scenes.first;
      }
    } catch (e) {
      return null;
    }
  }

  /// 保存场景内容
  Future<void> saveSceneContent(String novelId, String actId, String chapterId,
      String sceneId, novel_models.Scene scene) async {
    try {
      // 生成场景缓存键
      final sceneKey = '${novelId}_${actId}_${chapterId}_$sceneId';
      
      // 如果缓存中有小说，则直接更新缓存中的场景内容
      if (_novelCache.containsKey(novelId)) {
        final novel = _novelCache[novelId]!;
        bool sceneUpdated = false;
        
        // 查找并更新缓存中的场景
        final updatedActs = novel.acts.map((act) {
          if (act.id == actId) {
            final updatedChapters = act.chapters.map((chapter) {
              if (chapter.id == chapterId) {
                final sceneIndex = chapter.scenes.indexWhere((s) => s.id == sceneId);
                if (sceneIndex >= 0) {
                  // 更新现有场景
                  final updatedScenes = List<novel_models.Scene>.from(chapter.scenes);
                  updatedScenes[sceneIndex] = scene;
                  sceneUpdated = true;
                  return chapter.copyWith(scenes: updatedScenes);
                } else {
                  // 添加新场景
                  sceneUpdated = true;
                  return chapter.copyWith(
                    scenes: [...chapter.scenes, scene],
                  );
                }
              }
              return chapter;
            }).toList();
            
            if (sceneUpdated) {
              return act.copyWith(chapters: updatedChapters);
            }
          }
          return act;
        }).toList();
        
        if (sceneUpdated) {
          // 更新缓存中的小说
          final updatedNovel = novel.copyWith(
            acts: updatedActs,
            updatedAt: DateTime.now(),
          );
          
          _novelCache[novelId] = updatedNovel;
          _novelCacheTimestamp[novelId] = DateTime.now();
          
          // 更新字数缓存
          _updateWordCountCache(sceneKey, scene.content, scene.wordCount);
          
          AppLogger.i('LocalStorageService',
              'saveSceneContent: Updated scene in cached novel: $sceneKey');
        }
      }

      // 正常保存场景到存储
      final novel = await getNovel(novelId);
      if (novel == null) return;

      final acts = novel.acts.map((act) {
        if (act.id == actId) {
          final chapters = act.chapters.map((chapter) {
            if (chapter.id == chapterId) {
              // 查找特定场景
              final sceneIndex =
                  chapter.scenes.indexWhere((s) => s.id == sceneId);
              List<novel_models.Scene> updatedScenes;

              if (sceneIndex >= 0) {
                // 更新现有场景
                updatedScenes = List.from(chapter.scenes);
                updatedScenes[sceneIndex] = scene;
              } else {
                // 添加新场景
                updatedScenes = List.from(chapter.scenes)..add(scene);
              }

              return chapter.copyWith(scenes: updatedScenes);
            }
            return chapter;
          }).toList();

          return act.copyWith(chapters: chapters);
        }
        return act;
      }).toList();

      final updatedNovel = novel.copyWith(
        acts: acts,
        updatedAt: DateTime.now(),
      );

      await saveNovel(updatedNovel);
      
      // 更新字数缓存
      _updateWordCountCache(sceneKey, scene.content, scene.wordCount);
    } catch (e) {
      AppLogger.e('LocalStorageService', '保存场景内容失败', e);
    }
  }

  /// 保存摘要内容
  Future<void> saveSummary(String novelId, String actId, String chapterId,
      String sceneId, novel_models.Summary summary) async {
    try {
      final novel = await getNovel(novelId);
      if (novel == null) return;

      final acts = novel.acts.map((act) {
        if (act.id == actId) {
          final chapters = act.chapters.map((chapter) {
            if (chapter.id == chapterId) {
              // 查找特定场景
              final sceneIndex =
                  chapter.scenes.indexWhere((s) => s.id == sceneId);
              List<novel_models.Scene> updatedScenes;

              if (sceneIndex >= 0) {
                // 更新现有场景
                updatedScenes = List.from(chapter.scenes);
                updatedScenes[sceneIndex] =
                    updatedScenes[sceneIndex].copyWith(summary: summary);
              } else {
                // 如果场景不存在，不做任何操作
                updatedScenes = chapter.scenes;
              }

              return chapter.copyWith(scenes: updatedScenes);
            }
            return chapter;
          }).toList();

          return act.copyWith(chapters: chapters);
        }
        return act;
      }).toList();

      final updatedNovel = novel.copyWith(
        acts: acts,
        updatedAt: DateTime.now(),
      );

      await saveNovel(updatedNovel);
    } catch (e) {
      AppLogger.e('LocalStorageService', '保存摘要内容失败', e);
    }
  }

  // 标记需要同步的内容（按类型）
  Future<void> markForSyncByType(String id, String type) async {
    try {
      final prefs = await _ensureInitialized();
      final syncKey = 'syncList_$type';
      final syncList = prefs.getStringList(syncKey) ?? [];

      if (!syncList.contains(id)) {
        syncList.add(id);
        await prefs.setStringList(syncKey, syncList);
        AppLogger.i('LocalStorageService', '已标记 $type: $id 需要同步');
      }
    } catch (e) {
      AppLogger.e('LocalStorageService', '标记同步失败', e);
    }
  }

  // 获取需要同步的内容列表（按类型）
  Future<List<String>> getSyncList(String type) async {
    try {
      final prefs = await _ensureInitialized();
      final syncKey = 'syncList_$type';
      return prefs.getStringList(syncKey) ?? [];
    } catch (e) {
      AppLogger.e('LocalStorageService', '获取同步列表失败', e);
      return [];
    }
  }

  // 清除同步标记（按类型和ID）
  Future<void> clearSyncFlagByType(String type, String id) async {
    try {
      final prefs = await _ensureInitialized();
      final syncKey = 'syncList_$type';
      final syncList = prefs.getStringList(syncKey) ?? [];

      if (syncList.contains(id)) {
        syncList.remove(id);
        await prefs.setStringList(syncKey, syncList);
        AppLogger.i('LocalStorageService', '已清除 $type: $id 的同步标记');
      }
    } catch (e) {
      AppLogger.e('LocalStorageService', '清除同步标记失败', e);
    }
  }

  // 保存聊天会话列表
  Future<void> saveChatSessions(
      String novelId, List<ChatSession> sessions) async {
    final key = 'chat_sessions_$novelId';
    final jsonList =
        sessions.map((session) => jsonEncode(session.toJson())).toList();
    final prefs = await _ensureInitialized();
    await prefs.setStringList(key, jsonList);
  }

  // 获取聊天会话列表
  Future<List<ChatSession>> getChatSessions(String novelId) async {
    final key = 'chat_sessions_$novelId';
    final prefs = await _ensureInitialized();
    final jsonList = prefs.getStringList(key) ?? [];

    return jsonList
        .map((json) => ChatSession.fromJson(jsonDecode(json)))
        .toList();
  }

  // 添加聊天会话
  Future<void> addChatSession(String novelId, ChatSession session,
      {bool needsSync = false}) async {
    final sessions = await getChatSessions(novelId);
    sessions.add(session);

    await saveChatSessions(novelId, sessions);

    await updateChatSession(session, needsSync: needsSync);
  }

  // 获取特定会话
  Future<ChatSession?> getChatSession(String sessionId) async {
    final key = 'chat_session_detail_$sessionId';
    final prefs = await _ensureInitialized();
    final json = prefs.getString(key);

    if (json == null) {
      return null;
    }

    return ChatSession.fromJson(jsonDecode(json));
  }

  // 更新会话 - 同时处理标记同步
  Future<void> updateChatSession(ChatSession session,
      {bool needsSync = false}) async {
    final key = 'chat_session_detail_${session.id}';
    final prefs = await _ensureInitialized();
    await prefs.setString(key, jsonEncode(session.toJson()));

    if (needsSync) {
      await markForSyncByType(session.id, 'chat_session');
    }
  }

  // 删除会话
  Future<void> deleteChatSession(String sessionId) async {
    final key = 'chat_session_detail_$sessionId';
    final prefs = await _ensureInitialized();
    await prefs.remove(key);

    await clearSyncFlagByType('chat_session', sessionId);
  }

  // 获取需要同步的所有会话
  Future<List<ChatSession>> getSessionsToSync() async {
    final syncList = await getSyncList('chat_session');
    final sessions = <ChatSession>[];

    for (final sessionId in syncList) {
      final session = await getChatSession(sessionId);
      if (session != null) {
        sessions.add(session);
      } else {
        AppLogger.w('LocalStorageService',
            'getSessionsToSync: 未找到标记为同步的会话详情: $sessionId。考虑清除此标记。');
      }
    }

    return sessions;
  }

  // 清除所有数据
  Future<void> clearAll() async {
    final prefs = await _ensureInitialized();
    await prefs.clear();
  }

  /// 获取会话的消息列表（用于显示历史记录）
  Future<List<ChatMessage>?> getMessagesForSession(String sessionId) async {
    final prefs = await _ensureInitialized();
    final key = 'chat_messages_$sessionId'; // Key for storing full history
    final jsonList = prefs.getStringList(key);
    if (jsonList == null) return null;
    try {
      // Sort messages by timestamp after parsing
      final messages = jsonList
          .map((json) => ChatMessage.fromJson(jsonDecode(json)))
          .toList();
      messages.sort((a, b) => a.timestamp.compareTo(b.timestamp));
      return messages;
    } catch (e, stackTrace) {
      AppLogger.e(
          'LocalStorageService', '解析会话 $sessionId 的消息失败', e, stackTrace);
      return null;
    }
  }

  /// 保存会话的消息列表（用于缓存历史记录）
  Future<void> saveMessagesForSession(
      String sessionId, List<ChatMessage> messages) async {
    final prefs = await _ensureInitialized();
    final key = 'chat_messages_$sessionId'; // Key for storing full history
    // Sort messages by timestamp before saving
    messages.sort((a, b) => a.timestamp.compareTo(b.timestamp));
    final jsonList = messages.map((msg) => jsonEncode(msg.toJson())).toList();
    await prefs.setStringList(key, jsonList);
  }

  /// 添加单条消息到会话历史（例如，收到新消息或发送成功后）
  Future<void> addMessageToSessionHistory(
      String sessionId, ChatMessage message) async {
    final messages = await getMessagesForSession(sessionId) ?? [];
    // Avoid duplicates if message already exists
    if (!messages.any((m) => m.id == message.id)) {
      messages.add(message);
      await saveMessagesForSession(sessionId, messages);
    }
  }

  /// 添加待发送消息到队列
  Future<String> addPendingMessage({
    required String userId,
    required String sessionId,
    required String content,
    required Map<String, dynamic>? metadata,
  }) async {
    final prefs = await _ensureInitialized();
    final pendingList = prefs.getStringList(_pendingMessagesKey) ?? [];
    final localId = _uuid.v4(); // Generate unique local ID

    final pendingMessageData = {
      'localId': localId, // Unique ID for removal later
      'userId': userId,
      'sessionId': sessionId,
      'content': content,
      'metadata': metadata,
      'timestamp':
          DateTime.now().toIso8601String(), // Store time added to queue
    };

    pendingList.add(jsonEncode(pendingMessageData));
    await prefs.setStringList(_pendingMessagesKey, pendingList);
    AppLogger.i('LocalStorageService',
        '添加待发送消息到队列: sessionId=$sessionId, localId=$localId');
    return localId; // Return localId in case UI needs it
  }

  /// 获取所有待发送消息
  Future<List<Map<String, dynamic>>> getPendingMessages() async {
    final prefs = await _ensureInitialized();
    final jsonList = prefs.getStringList(_pendingMessagesKey) ?? [];
    try {
      return jsonList
          .map((json) => jsonDecode(json) as Map<String, dynamic>)
          .toList();
    } catch (e, stackTrace) {
      AppLogger.e('LocalStorageService', '解析待发送消息队列失败', e, stackTrace);
      // Optionally clear the corrupted queue
      // await prefs.remove(_pendingMessagesKey);
      return [];
    }
  }

  /// 从队列中移除已发送的消息 (通过 localId)
  Future<void> removePendingMessage(String localId) async {
    final prefs = await _ensureInitialized();
    final pendingList = prefs.getStringList(_pendingMessagesKey) ?? [];
    final updatedList = <String>[];
    bool removed = false;

    for (final jsonString in pendingList) {
      try {
        final data = jsonDecode(jsonString) as Map<String, dynamic>;
        if (data['localId'] != localId) {
          updatedList.add(jsonString);
        } else {
          removed = true;
        }
      } catch (e) {
        // Skip corrupted entry
        AppLogger.w('LocalStorageService', '移除待发送消息时跳过损坏条目: $e');
      }
    }

    if (removed) {
      await prefs.setStringList(_pendingMessagesKey, updatedList);
      AppLogger.i('LocalStorageService', '从队列移除待发送消息: localId=$localId');
    } else {
      AppLogger.w('LocalStorageService', '尝试移除待发送消息，但未找到: localId=$localId');
    }
  }

  // 清理所有同步标记
  Future<void> clearAllSyncFlags() async {
    final prefs = await _ensureInitialized();
    final syncTypes = ['novel', 'scene', 'editor', 'chat_session'];
    
    for (final type in syncTypes) {
      final syncKey = 'syncList_$type';
      await prefs.remove(syncKey);
    }
    
    AppLogger.i('LocalStorageService', '已清理所有同步标记');
  }
  
  // 清理指定小说的同步标记
  Future<void> clearNovelSyncFlags(String novelId) async {
    if (novelId.isEmpty) return;
    
    final prefs = await _ensureInitialized();
    
    // 清理小说本身的同步标记
    const novelSyncKey = 'syncList_novel';
    final novelSyncList = prefs.getStringList(novelSyncKey) ?? [];
    if (novelSyncList.contains(novelId)) {
      novelSyncList.remove(novelId);
      await prefs.setStringList(novelSyncKey, novelSyncList);
      AppLogger.i('LocalStorageService', '已清理小说同步标记: $novelId');
    }
    
    // 清理场景同步标记
    const sceneSyncKey = 'syncList_scene';
    final sceneSyncList = prefs.getStringList(sceneSyncKey) ?? [];
    final updatedSceneSyncList = sceneSyncList.where((sceneKey) {
      final parts = sceneKey.split('_');
      return parts.isEmpty || parts[0] != novelId;
    }).toList();
    
    if (updatedSceneSyncList.length != sceneSyncList.length) {
      await prefs.setStringList(sceneSyncKey, updatedSceneSyncList);
      AppLogger.i('LocalStorageService', 
        '已清理场景同步标记: ${sceneSyncList.length - updatedSceneSyncList.length} 个场景，小说ID: $novelId');
    }
    
    // 清理编辑器内容同步标记
    const editorSyncKey = 'syncList_editor';
    final editorSyncList = prefs.getStringList(editorSyncKey) ?? [];
    final updatedEditorSyncList = editorSyncList.where((contentKey) {
      final parts = contentKey.split('_');
      return parts.isEmpty || parts[0] != novelId;
    }).toList();
    
    if (updatedEditorSyncList.length != editorSyncList.length) {
      await prefs.setStringList(editorSyncKey, updatedEditorSyncList);
      AppLogger.i('LocalStorageService', 
        '已清理编辑器内容同步标记: ${editorSyncList.length - updatedEditorSyncList.length} 个内容，小说ID: $novelId');
    }
    
    // 清理聊天会话同步标记
    // 注意：这需要先获取所有会话，然后检查它们的metadata中的novelId
    final sessions = await getSessionsToSync();
    final sessionsToRemove = sessions.where((session) => 
      session.metadata != null && session.metadata!['novelId'] == novelId).toList();
    
    for (final session in sessionsToRemove) {
      await clearSyncFlagByType('chat_session', session.id);
      AppLogger.i('LocalStorageService', '已清理聊天会话同步标记: ${session.id}，小说ID: $novelId');
    }
  }

  /// 获取指定章节的所有场景键
  Future<List<String>> getSceneKeysForChapter(
    String novelId,
    String actId,
    String chapterId,
  ) async {
    try {
      final box = await Hive.openBox('scenes');
      final prefix = '${novelId}_${actId}_${chapterId}_';
      
      // 过滤出所有属于该章节的场景键
      final List<String> sceneKeys = [];
      for (final key in box.keys) {
        if (key is String && key.startsWith(prefix)) {
          // 从键中提取场景ID
          final sceneId = key.substring(prefix.length);
          sceneKeys.add(sceneId);
        }
      }
      
      return sceneKeys;
    } catch (e) {
      AppLogger.e('LocalStorageService', '获取章节场景键失败', e);
      return [];
    }
  }

  /// 删除场景内容
  Future<void> deleteSceneContent(
    String novelId,
    String actId,
    String chapterId,
    String sceneId,
  ) async {
    final sceneKey = '${novelId}_${actId}_${chapterId}_$sceneId';
    try {
      // 使用SharedPreferences删除场景内容
      final prefs = await _ensureInitialized();
      await prefs.remove('scene_$sceneKey');
      
      // 从场景索引中移除
      final indexKey = 'scenes_index_${novelId}_${actId}_$chapterId';
      final sceneIds = prefs.getStringList(indexKey) ?? [];
      if (sceneIds.contains(sceneId)) {
        sceneIds.remove(sceneId);
        await prefs.setStringList(indexKey, sceneIds);
      }
      
      AppLogger.i('LocalStorageService', '本地场景内容已删除: $sceneKey');
    } catch (e) {
      AppLogger.e('LocalStorageService', '删除场景内容失败: $sceneKey', e);
      throw Exception('删除场景内容失败: $e');
    }
  }

  // 优化的字数统计缓存
  void _updateWordCountCache(String sceneKey, String content, int wordCount) {
    final contentHash = content.hashCode.toString();
    final cacheKey = '${sceneKey}_$contentHash';
    _wordCountCache[cacheKey] = wordCount.toString();
  }
  
  // 从缓存获取字数统计
  int? getWordCountFromCache(String sceneKey, String content) {
    final contentHash = content.hashCode.toString();
    final cacheKey = '${sceneKey}_$contentHash';
    final cachedCount = _wordCountCache[cacheKey];
    if (cachedCount != null) {
      return int.tryParse(cachedCount);
    }
    return null;
  }
  
  // 清除指定小说的缓存
  Future<void> clearNovelCache(String novelId) async {
    AppLogger.i('LocalStorageService', '清除小说缓存: $novelId');
    _novelCache.remove(novelId);
    _novelCacheTimestamp.remove(novelId);
  }

  // 清除所有小说缓存
  Future<void> clearAllNovelCache() async {
    AppLogger.i('LocalStorageService', '清除所有小说缓存');
    _novelCache.clear();
    _novelCacheTimestamp.clear();
  }
}
