完善2

lib/utils/webdav_service.dart

@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 import 'package:http/http.dart' as http;
@@ -5,6 +6,9 @@ import 'package:path_provider/path_provider.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 import 'package:sqflite/sqflite.dart';
 import 'package:path/path.dart' as p;
+import 'package:archive/archive.dart';
+import 'package:archive/archive_io.dart';
+import 'database_helper.dart';
 
 /// WebDAV 同步结果
 class SyncResult {
@@ -15,7 +19,7 @@ class SyncResult {
   final int downloadedFiles;
   final int uploadedImages;
   final int downloadedImages;
-  final bool needReload; // 是否需要重新加载数据
+  final bool needReload;
   
   SyncResult({
     required this.success,
@@ -43,7 +47,7 @@ class _ImageSyncResult {
   _ImageSyncResult({required this.uploaded, required this.downloaded});
 }
 
-/// WebDAV 服务类
+/// WebDAV 服务类 - 支持自动定时备份
 class WebDAVService {
   static final WebDAVService _instance = WebDAVService._internal();
   static WebDAVService get instance => _instance;
@@ -52,8 +56,15 @@ class WebDAVService {
   
   static const String _configKey = 'webdav_config';
   static const String _lastSyncKey = 'webdav_last_sync';
+  static const String _autoSyncKey = 'webdav_auto_sync';
+  static const String _backupListKey = 'webdav_backup_list';
+  
+  static const int _maxBackupCount = 10; // 保留最近10条备份
+  static const Duration _autoSyncInterval = Duration(minutes: 2); // 每2分钟自动备份
   
   Map<String, String>? _cachedConfig;
+  Timer? _autoSyncTimer;
+  bool _isAutoSyncEnabled = false;
   
   /// 获取配置
   Future<Map<String, String>?> getConfig() async {
@@ -99,7 +110,10 @@ class WebDAVService {
     final prefs = await SharedPreferences.getInstance();
     await prefs.remove(_configKey);
     await prefs.remove(_lastSyncKey);
+    await prefs.remove(_autoSyncKey);
+    await prefs.remove(_backupListKey);
     _cachedConfig = null;
+    stopAutoSync();
   }
   
   /// 测试连接
@@ -110,13 +124,11 @@ class WebDAVService {
     required String path,
   }) async {
     try {
-      // 构建 WebDAV URL
       final baseUrl = url.endsWith('/') ? url.substring(0, url.length - 1) : url;
       var davUrl = '$baseUrl$path';
       
       print('WebDAV: Testing connection to $davUrl');
       
-      // 先尝试 PROPFIND 请求（更通用的测试方式）
       final client = http.Client();
       try {
         var propfindRequest = http.Request('PROPFIND', Uri.parse(davUrl));
@@ -132,15 +144,12 @@ class WebDAVService {
         var propfindResponse = await client.send(propfindRequest);
         print('WebDAV: PROPFIND status ${propfindResponse.statusCode}');
         
-        // 处理重定向 (301, 302, 307, 308)
         if (propfindResponse.statusCode == 301 || 
             propfindResponse.statusCode == 302 ||
             propfindResponse.statusCode == 307 ||
             propfindResponse.statusCode == 308) {
           final location = propfindResponse.headers['location'];
           if (location != null) {
-            print('WebDAV: Redirecting to $location');
-            // 使用重定向后的 URL 重新请求
             davUrl = location;
             propfindRequest = http.Request('PROPFIND', Uri.parse(davUrl));
             propfindRequest.headers['Authorization'] = _basicAuth(username, password);
@@ -152,7 +161,6 @@ class WebDAVService {
   </D:prop>
 </D:propfind>''';
             propfindResponse = await client.send(propfindRequest);
-            print('WebDAV: PROPFIND after redirect status ${propfindResponse.statusCode}');
           }
         }
         
@@ -161,13 +169,7 @@ class WebDAVService {
         } else if (propfindResponse.statusCode == 401) {
           return {'success': false, 'message': '认证失败，请检查用户名和密码'};
         } else if (propfindResponse.statusCode == 404) {
-          // 目录不存在，尝试创建
           print('WebDAV: Directory not found, trying to create...');
-        } else if (propfindResponse.statusCode == 301 || 
-                   propfindResponse.statusCode == 302 ||
-                   propfindResponse.statusCode == 307 ||
-                   propfindResponse.statusCode == 308) {
-          return {'success': false, 'message': '服务器重定向，请尝试使用 ${propfindResponse.headers["location"] ?? "其他地址"}'};
         } else {
           return {'success': false, 'message': '服务器返回错误: ${propfindResponse.statusCode}'};
         }
@@ -175,7 +177,6 @@ class WebDAVService {
         print('WebDAV: PROPFIND error: $e');
       }
       
-      // 尝试创建目录
       try {
         final mkcolRequest = http.Request('MKCOL', Uri.parse(davUrl));
         mkcolRequest.headers['Authorization'] = _basicAuth(username, password);
@@ -206,7 +207,7 @@ class WebDAVService {
     }
   }
   
-  /// 同步数据（双向同步）
+  /// 同步数据（保留原有方法用于手动同步）
   Future<SyncResult> syncData({SyncDirection direction = SyncDirection.bidirectional}) async {
     final config = await getConfig();
     if (config == null) {
@@ -219,17 +220,13 @@ class WebDAVService {
       final password = config['password']!;
       final path = config['path']!;
       
-      // 获取本地数据库文件路径
       final dbPath = await getDatabasesPath();
       final dbFile = File(p.join(dbPath, 'mooknote.db'));
       
-      print('WebDAV: Looking for database at ${dbFile.path}');
-      
       if (!await dbFile.exists()) {
         return SyncResult(success: false, message: '本地数据库不存在');
       }
       
-      // 构建 WebDAV URL
       final baseUrl = url.endsWith('/') ? url.substring(0, url.length - 1) : url;
       var davUrl = '$baseUrl$path/mooknote.db';
       final davImagesUrl = '$baseUrl$path/images';
@@ -241,37 +238,32 @@ class WebDAVService {
       int downloadedImages = 0;
       
       try {
-        // 1. 检查远程数据库是否存在
         final remoteDbInfo = await _getRemoteFileInfo(client, davUrl, username, password);
         
         if (direction == SyncDirection.upload) {
-          // 仅上传模式
           print('WebDAV: Upload only mode');
           final result = await _uploadFile(client, davUrl, username, password, dbFile);
           if (result) {
             uploadedFiles++;
-            // 同步图片
             final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.upload);
             uploadedImages = imageResult.uploaded;
-            downloadedImages = imageResult.downloaded;
           }
         } else if (direction == SyncDirection.download) {
-          // 仅下载模式
           print('WebDAV: Download only mode');
           if (remoteDbInfo != null) {
             final result = await _downloadFile(client, davUrl, username, password, dbFile);
             if (result) {
               downloadedFiles++;
-              // 同步图片
+              // 重新打开数据库以应用新数据
+              await DatabaseHelper.instance.reopenDatabase();
               final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.download);
-              uploadedImages = imageResult.uploaded;
               downloadedImages = imageResult.downloaded;
             }
           } else {
             return SyncResult(success: false, message: '远程数据库不存在');
           }
-        } else {
-          // 双向同步模式
+        } else if (direction == SyncDirection.bidirectional) {
+          // 双向同步：比较时间戳决定上传还是下载
           print('WebDAV: Bidirectional sync mode');
           
           if (remoteDbInfo == null) {
@@ -280,7 +272,6 @@ class WebDAVService {
             final result = await _uploadFile(client, davUrl, username, password, dbFile);
             if (result) {
               uploadedFiles++;
-              // 上传所有图片
               final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.upload);
               uploadedImages = imageResult.uploaded;
             }
@@ -300,10 +291,8 @@ class WebDAVService {
               final result = await _uploadFile(client, davUrl, username, password, dbFile);
               if (result) {
                 uploadedFiles++;
-                // 同步图片
-                final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.bidirectional);
+                final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.upload);
                 uploadedImages = imageResult.uploaded;
-                downloadedImages = imageResult.downloaded;
               }
             } else if (timeDiff < -10) {
               // 远程较新，下载
@@ -311,13 +300,13 @@ class WebDAVService {
               final result = await _downloadFile(client, davUrl, username, password, dbFile);
               if (result) {
                 downloadedFiles++;
-                // 同步图片
-                final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.bidirectional);
-                uploadedImages = imageResult.uploaded;
+                // 重新打开数据库以应用新数据
+                await DatabaseHelper.instance.reopenDatabase();
+                final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.download);
                 downloadedImages = imageResult.downloaded;
               }
             } else {
-              // 时间相近，视为相同
+              // 时间相近，仅同步图片
               print('WebDAV: Local and remote are similar, syncing images only...');
               final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.bidirectional);
               uploadedImages = imageResult.uploaded;
@@ -326,11 +315,9 @@ class WebDAVService {
           }
         }
         
-        // 保存同步时间
         final prefs = await SharedPreferences.getInstance();
         await prefs.setString(_lastSyncKey, DateTime.now().toIso8601String());
         
-        // 如果下载了数据库文件，需要重新加载
         final needReload = downloadedFiles > 0;
         
         return SyncResult(
@@ -366,7 +353,6 @@ class WebDAVService {
       
       var response = await client.send(request);
       
-      // 处理重定向
       if (response.statusCode == 301 || response.statusCode == 302 ||
           response.statusCode == 307 || response.statusCode == 308) {
         final location = response.headers['location'];
@@ -380,9 +366,7 @@ class WebDAVService {
       }
       
       if (response.statusCode == 207) {
-        // 解析 PROPFIND 响应获取修改时间
         final body = await response.stream.bytesToString();
-        // 简单解析，提取 getlastmodified
         final modifiedMatch = RegExp(r'<d:getlastmodified>([^<]+)</d:getlastmodified>', caseSensitive: false)
             .firstMatch(body);
         if (modifiedMatch != null) {
@@ -399,6 +383,493 @@ class WebDAVService {
     }
   }
   
+  /// 启动自动同步
+  Future<void> startAutoSync() async {
+    if (_autoSyncTimer != null) {
+      _autoSyncTimer!.cancel();
+    }
+    
+    final prefs = await SharedPreferences.getInstance();
+    _isAutoSyncEnabled = true;
+    await prefs.setBool(_autoSyncKey, true);
+    
+    // 立即执行一次备份
+    await performTimedBackup();
+    
+    // 设置定时器，每5分钟执行一次
+    _autoSyncTimer = Timer.periodic(_autoSyncInterval, (timer) async {
+      if (_isAutoSyncEnabled) {
+        await performTimedBackup();
+      }
+    });
+    
+    print('WebDAV: 自动备份已启动，每2分钟执行一次');
+  }
+  
+  /// 停止自动同步
+  Future<void> stopAutoSync() async {
+    _autoSyncTimer?.cancel();
+    _autoSyncTimer = null;
+    _isAutoSyncEnabled = false;
+    
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_autoSyncKey, false);
+    
+    print('WebDAV: 自动备份已停止');
+  }
+  
+  /// 检查自动同步状态
+  Future<bool> isAutoSyncEnabled() async {
+    if (_autoSyncTimer != null) {
+      return _isAutoSyncEnabled;
+    }
+    
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_autoSyncKey) ?? false;
+  }
+  
+  /// 执行定时备份（按时间命名，保留最近10条）
+  Future<SyncResult> performTimedBackup() async {
+    final config = await getConfig();
+    if (config == null) {
+      return SyncResult(success: false, message: '未配置 WebDAV');
+    }
+    
+    try {
+      final url = config['url']!;
+      final username = config['username']!;
+      final password = config['password']!;
+      final basePath = config['path']!;
+      
+      // 获取本地数据库文件路径
+      final dbPath = await getDatabasesPath();
+      final dbFile = File(p.join(dbPath, 'mooknote.db'));
+      
+      if (!await dbFile.exists()) {
+        return SyncResult(success: false, message: '本地数据库不存在');
+      }
+      
+      // 构建 WebDAV URL（使用时间戳命名）
+      final baseUrl = url.endsWith('/') ? url.substring(0, url.length - 1) : url;
+      final timestamp = _formatTimestamp(DateTime.now());
+      final backupFileName = 'mooknote_$timestamp.zip';
+      final davUrl = '$baseUrl$basePath/$backupFileName';
+      final davImagesUrl = '$baseUrl$basePath/images';
+      
+      print('WebDAV: 开始定时备份到 $davUrl');
+      
+      final client = http.Client();
+      int uploadedImages = 0;
+      
+      try {
+        // 1. 创建完整的备份 ZIP（包含数据库和图片）
+        final zipBytes = await _createFullBackupZip(dbFile);
+        if (zipBytes == null) {
+          return SyncResult(success: false, message: '创建备份文件失败');
+        }
+        
+        // 2. 上传备份文件
+        final success = await _uploadBytes(client, davUrl, username, password, zipBytes);
+        if (!success) {
+          return SyncResult(success: false, message: '上传备份文件失败');
+        }
+        
+        // 3. 同步图片到 images 目录
+        final imageResult = await _syncImages(client, davImagesUrl, username, password, SyncDirection.upload);
+        uploadedImages = imageResult.uploaded;
+        
+        // 4. 更新备份列表并清理旧备份
+        await _updateBackupListAndCleanup(client, baseUrl, basePath, username, password, backupFileName);
+        
+        // 5. 保存同步时间
+        final prefs = await SharedPreferences.getInstance();
+        await prefs.setString(_lastSyncKey, DateTime.now().toIso8601String());
+        
+        print('WebDAV: 定时备份完成 - $backupFileName');
+        
+        return SyncResult(
+          success: true,
+          message: '备份完成: $backupFileName',
+          lastSyncTime: DateTime.now(),
+          uploadedFiles: 1,
+          uploadedImages: uploadedImages,
+          needReload: false,
+        );
+      } finally {
+        client.close();
+      }
+    } catch (e) {
+      print('WebDAV: 定时备份错误: $e');
+      return SyncResult(success: false, message: '备份失败: $e');
+    }
+  }
+  
+  /// 创建完整的备份 ZIP（包含数据库和所有图片）
+  /// 支持新的图片存储结构：images/movies/{id}/、images/books/{id}/、images/notes/{id}/
+  Future<List<int>?> _createFullBackupZip(File dbFile) async {
+    try {
+      final archive = Archive();
+      
+      // 添加数据库文件
+      final dbBytes = await dbFile.readAsBytes();
+      archive.addFile(ArchiveFile('mooknote.db', dbBytes.length, dbBytes));
+      
+      // 添加所有图片（递归遍历子目录）
+      final appDir = await getApplicationDocumentsDirectory();
+      final imagesDir = Directory('${appDir.path}/images');
+      
+      if (await imagesDir.exists()) {
+        await _addImagesToArchive(archive, imagesDir, 'images');
+      }
+      
+      // 添加备份信息
+      final backupInfo = {
+        'version': 2,
+        'backupTime': DateTime.now().toIso8601String(),
+        'appName': 'MookNote',
+        'type': 'timed_backup',
+        'structure': 'hierarchical', // 标记为分层结构
+      };
+      final infoJson = jsonEncode(backupInfo);
+      final infoBytes = utf8.encode(infoJson);
+      archive.addFile(ArchiveFile('backup_info.json', infoBytes.length, infoBytes));
+      
+      // 压缩
+      final zipEncoder = ZipEncoder();
+      return zipEncoder.encode(archive);
+    } catch (e) {
+      print('WebDAV: 创建备份 ZIP 失败: $e');
+      return null;
+    }
+  }
+  
+  /// 递归添加图片到归档
+  Future<void> _addImagesToArchive(Archive archive, Directory dir, String relativePath) async {
+    await for (final entity in dir.list()) {
+      if (entity is File) {
+        final fileName = p.basename(entity.path);
+        final bytes = await entity.readAsBytes();
+        final archivePath = '$relativePath/$fileName';
+        archive.addFile(ArchiveFile(archivePath, bytes.length, bytes));
+        print('WebDAV: 添加文件到备份 - $archivePath');
+      } else if (entity is Directory) {
+        final dirName = p.basename(entity.path);
+        await _addImagesToArchive(archive, entity, '$relativePath/$dirName');
+      }
+    }
+  }
+  
+  /// 更新备份列表并清理旧备份
+  Future<void> _updateBackupListAndCleanup(
+    http.Client client,
+    String baseUrl,
+    String basePath,
+    String username,
+    String password,
+    String newBackupName,
+  ) async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      
+      // 获取现有备份列表
+      List<String> backupList = [];
+      final listJson = prefs.getString(_backupListKey);
+      if (listJson != null) {
+        backupList = List<String>.from(jsonDecode(listJson));
+      }
+      
+      // 添加新备份
+      backupList.add(newBackupName);
+      
+      // 如果超过10条，删除最旧的备份
+      while (backupList.length > _maxBackupCount) {
+        final oldBackup = backupList.removeAt(0);
+        final deleteUrl = '$baseUrl$basePath/$oldBackup';
+        await _deleteFile(client, deleteUrl, username, password);
+        print('WebDAV: 删除旧备份 $oldBackup');
+      }
+      
+      // 保存更新后的列表
+      await prefs.setString(_backupListKey, jsonEncode(backupList));
+      
+      print('WebDAV: 备份列表已更新，当前 ${backupList.length} 个备份');
+    } catch (e) {
+      print('WebDAV: 更新备份列表失败: $e');
+    }
+  }
+  
+  /// 删除远程文件
+  Future<void> _deleteFile(
+    http.Client client,
+    String url,
+    String username,
+    String password,
+  ) async {
+    try {
+      var request = http.Request('DELETE', Uri.parse(url));
+      request.headers['Authorization'] = _basicAuth(username, password);
+      
+      var response = await client.send(request);
+      
+      // 处理重定向
+      if (response.statusCode == 301 || response.statusCode == 302 ||
+          response.statusCode == 307 || response.statusCode == 308) {
+        final location = response.headers['location'];
+        if (location != null) {
+          request = http.Request('DELETE', Uri.parse(location));
+          request.headers['Authorization'] = _basicAuth(username, password);
+          response = await client.send(request);
+        }
+      }
+    } catch (e) {
+      print('WebDAV: 删除文件失败: $e');
+    }
+  }
+  
+  /// 上传字节数据
+  Future<bool> _uploadBytes(
+    http.Client client,
+    String url,
+    String username,
+    String password,
+    List<int> bytes,
+  ) async {
+    try {
+      var request = http.Request('PUT', Uri.parse(url));
+      request.headers['Authorization'] = _basicAuth(username, password);
+      request.headers['Content-Type'] = 'application/zip';
+      request.bodyBytes = bytes;
+      
+      var response = await client.send(request);
+      
+      // 处理重定向
+      if (response.statusCode == 301 || response.statusCode == 302 ||
+          response.statusCode == 307 || response.statusCode == 308) {
+        final location = response.headers['location'];
+        if (location != null) {
+          request = http.Request('PUT', Uri.parse(location));
+          request.headers['Authorization'] = _basicAuth(username, password);
+          request.headers['Content-Type'] = 'application/zip';
+          request.bodyBytes = bytes;
+          response = await client.send(request);
+        }
+      }
+      
+      return response.statusCode == 201 || response.statusCode == 204;
+    } catch (e) {
+      print('WebDAV: 上传失败: $e');
+      return false;
+    }
+  }
+  
+  /// 格式化时间戳用于文件名
+  String _formatTimestamp(DateTime dateTime) {
+    return '${dateTime.year}${_pad(dateTime.month)}${_pad(dateTime.day)}_${_pad(dateTime.hour)}${_pad(dateTime.minute)}${_pad(dateTime.second)}';
+  }
+  
+  String _pad(int number) {
+    return number.toString().padLeft(2, '0');
+  }
+  
+  /// 同步图片（支持新的目录结构）
+  /// 同步 images/movies/{id}/、images/books/{id}/、images/notes/{id}/ 下的所有图片
+  Future<_ImageSyncResult> _syncImages(
+    http.Client client,
+    String imagesUrl,
+    String username,
+    String password,
+    SyncDirection direction,
+  ) async {
+    int uploaded = 0;
+    int downloaded = 0;
+    
+    try {
+      // 获取本地图片目录
+      final appDir = await getApplicationDocumentsDirectory();
+      final localImagesDir = Directory('${appDir.path}/images');
+      
+      if (!await localImagesDir.exists()) {
+        await localImagesDir.create(recursive: true);
+      }
+      
+      // 递归获取本地所有图片文件（包含子目录）
+      final localImages = <String, File>{}; // 相对路径 -> 文件
+      await _collectLocalImages(localImagesDir, localImages, '');
+      
+      print('WebDAV: Local images: ${localImages.length}');
+      
+      // 递归获取远程所有图片文件
+      final remoteImages = await _listRemoteImagesRecursive(client, imagesUrl, username, password, '');
+      print('WebDAV: Remote images: ${remoteImages.length}');
+      
+      if (direction == SyncDirection.upload) {
+        // 仅上传：上传所有本地图片
+        for (final entry in localImages.entries) {
+          final relativePath = entry.key;
+          final remoteUrl = '$imagesUrl/$relativePath';
+          
+          // 确保远程父目录存在
+          final parentPath = p.dirname(relativePath);
+          if (parentPath != '.' && parentPath.isNotEmpty) {
+            final parentUrl = '$imagesUrl/$parentPath';
+            await _ensureRemoteDir(client, parentUrl, username, password);
+          }
+          
+          final success = await _uploadFile(client, remoteUrl, username, password, entry.value);
+          if (success) uploaded++;
+        }
+      } else if (direction == SyncDirection.download) {
+        // 仅下载：下载所有远程图片
+        for (final relativePath in remoteImages) {
+          final remoteUrl = '$imagesUrl/$relativePath';
+          final localFile = File('${localImagesDir.path}/$relativePath');
+          // 确保父目录存在
+          await localFile.parent.create(recursive: true);
+          final success = await _downloadFile(client, remoteUrl, username, password, localFile);
+          if (success) downloaded++;
+        }
+      }
+    } catch (e) {
+      print('WebDAV: Sync images error: $e');
+    }
+    
+    return _ImageSyncResult(uploaded: uploaded, downloaded: downloaded);
+  }
+  
+  /// 递归收集本地图片文件
+  Future<void> _collectLocalImages(Directory dir, Map<String, File> result, String relativePath) async {
+    await for (final entity in dir.list()) {
+      if (entity is File) {
+        final fileName = p.basename(entity.path);
+        final path = relativePath.isEmpty ? fileName : '$relativePath/$fileName';
+        result[path] = entity;
+      } else if (entity is Directory) {
+        final dirName = p.basename(entity.path);
+        final newRelativePath = relativePath.isEmpty ? dirName : '$relativePath/$dirName';
+        await _collectLocalImages(entity, result, newRelativePath);
+      }
+    }
+  }
+  
+  /// 获取远程图片列表（递归获取所有子目录中的图片）
+  Future<List<String>> _listRemoteImagesRecursive(
+    http.Client client,
+    String imagesUrl,
+    String username,
+    String password,
+    String relativePath,
+  ) async {
+    final images = <String>[];
+    final currentUrl = relativePath.isEmpty ? imagesUrl : '$imagesUrl/$relativePath';
+    
+    try {
+      // 创建图片目录（如果不存在）
+      final mkcolRequest = http.Request('MKCOL', Uri.parse(currentUrl));
+      mkcolRequest.headers['Authorization'] = _basicAuth(username, password);
+      await client.send(mkcolRequest);
+      
+      // 列出目录内容
+      var request = http.Request('PROPFIND', Uri.parse(currentUrl));
+      request.headers['Authorization'] = _basicAuth(username, password);
+      request.headers['Depth'] = '1';
+      
+      var response = await client.send(request);
+      
+      // 处理重定向
+      if (response.statusCode == 301 || response.statusCode == 302 ||
+          response.statusCode == 307 || response.statusCode == 308) {
+        final location = response.headers['location'];
+        if (location != null) {
+          final newUrl = location;
+          request = http.Request('PROPFIND', Uri.parse(newUrl));
+          request.headers['Authorization'] = _basicAuth(username, password);
+          request.headers['Depth'] = '1';
+          response = await client.send(request);
+        }
+      }
+      
+      if (response.statusCode == 207) {
+        final body = await response.stream.bytesToString();
+        // 解析响应，提取文件和目录
+        final hrefMatches = RegExp(r'<d:href>([^<]+)</d:href>', caseSensitive: false)
+            .allMatches(body);
+        
+        for (final match in hrefMatches) {
+          final href = match.group(1)!;
+          final name = p.basename(href);
+          
+          // 跳过当前目录自身
+          if (name.isEmpty) continue;
+          if (relativePath.isEmpty && name == 'images') continue;
+          
+          // 检查是文件还是目录
+          final isDirectory = body.substring(
+            match.start,
+            match.end + 200 < body.length ? match.end + 200 : body.length,
+          ).contains('<d:collection');
+          
+          if (isDirectory) {
+            // 递归获取子目录中的图片
+            final newRelativePath = relativePath.isEmpty ? name : '$relativePath/$name';
+            final subImages = await _listRemoteImagesRecursive(
+              client, imagesUrl, username, password, newRelativePath,
+            );
+            images.addAll(subImages);
+          } else {
+            // 是文件，添加到列表
+            final filePath = relativePath.isEmpty ? name : '$relativePath/$name';
+            images.add(filePath);
+          }
+        }
+      }
+    } catch (e) {
+      print('WebDAV: List remote images error: $e');
+    }
+    
+    return images;
+  }
+  
+  /// 确保远程目录存在
+  Future<void> _ensureRemoteDir(
+    http.Client client,
+    String dirUrl,
+    String username,
+    String password,
+  ) async {
+    try {
+      var request = http.Request('MKCOL', Uri.parse(dirUrl));
+      request.headers['Authorization'] = _basicAuth(username, password);
+      
+      var response = await client.send(request);
+      
+      // 处理重定向
+      if (response.statusCode == 301 || response.statusCode == 302 ||
+          response.statusCode == 307 || response.statusCode == 308) {
+        final location = response.headers['location'];
+        if (location != null) {
+          request = http.Request('MKCOL', Uri.parse(location));
+          request.headers['Authorization'] = _basicAuth(username, password);
+          response = await client.send(request);
+        }
+      }
+      
+      // 201 = 创建成功, 405 = 目录已存在, 409 = 父目录不存在需要先创建
+      if (response.statusCode == 409) {
+        // 需要创建父目录
+        final parentPath = p.dirname(dirUrl);
+        if (parentPath != dirUrl) {
+          await _ensureRemoteDir(client, parentPath, username, password);
+          // 再次尝试创建当前目录
+          request = http.Request('MKCOL', Uri.parse(dirUrl));
+          request.headers['Authorization'] = _basicAuth(username, password);
+          await client.send(request);
+        }
+      }
+    } catch (e) {
+      print('WebDAV: 创建目录失败: $e');
+    }
+  }
+  
   /// 上传文件
   Future<bool> _uploadFile(
     http.Client client,
@@ -474,155 +945,6 @@ class WebDAVService {
     }
   }
   
-  /// 同步图片
-  Future<_ImageSyncResult> _syncImages(
-    http.Client client,
-    String imagesUrl,
-    String username,
-    String password,
-    SyncDirection direction,
-  ) async {
-    int uploaded = 0;
-    int downloaded = 0;
-    
-    try {
-      // 获取本地图片目录
-      final appDir = await getApplicationDocumentsDirectory();
-      final localImagesDir = Directory('${appDir.path}/images');
-      
-      if (!await localImagesDir.exists()) {
-        await localImagesDir.create(recursive: true);
-      }
-      
-      // 获取本地图片列表
-      final localImages = <String, File>{};
-      if (await localImagesDir.exists()) {
-        await for (final entity in localImagesDir.list()) {
-          if (entity is File) {
-            final name = p.basename(entity.path);
-            localImages[name] = entity;
-          }
-        }
-      }
-      
-      print('WebDAV: Local images: ${localImages.length}');
-      
-      // 获取远程图片列表
-      final remoteImages = await _listRemoteImages(client, imagesUrl, username, password);
-      print('WebDAV: Remote images: ${remoteImages.length}');
-      
-      if (direction == SyncDirection.upload) {
-        // 仅上传：上传所有本地图片
-        for (final entry in localImages.entries) {
-          final remoteUrl = '$imagesUrl/${entry.key}';
-          final success = await _uploadFile(client, remoteUrl, username, password, entry.value);
-          if (success) uploaded++;
-        }
-      } else if (direction == SyncDirection.download) {
-        // 仅下载：下载所有远程图片
-        for (final name in remoteImages) {
-          final remoteUrl = '$imagesUrl/$name';
-          final localFile = File('${localImagesDir.path}/$name');
-          final success = await _downloadFile(client, remoteUrl, username, password, localFile);
-          if (success) downloaded++;
-        }
-      } else {
-        // 双向同步：比较时间戳
-        // 上传本地有但远程没有的
-        for (final entry in localImages.entries) {
-          if (!remoteImages.contains(entry.key)) {
-            final remoteUrl = '$imagesUrl/${entry.key}';
-            final success = await _uploadFile(client, remoteUrl, username, password, entry.value);
-            if (success) uploaded++;
-          }
-        }
-        
-        // 下载远程有但本地没有的
-        for (final name in remoteImages) {
-          if (!localImages.containsKey(name)) {
-            final remoteUrl = '$imagesUrl/$name';
-            final localFile = File('${localImagesDir.path}/$name');
-            final success = await _downloadFile(client, remoteUrl, username, password, localFile);
-            if (success) downloaded++;
-          }
-        }
-      }
-    } catch (e) {
-      print('WebDAV: Sync images error: $e');
-    }
-    
-    return _ImageSyncResult(uploaded: uploaded, downloaded: downloaded);
-  }
-  
-  /// 获取远程图片列表
-  Future<List<String>> _listRemoteImages(
-    http.Client client,
-    String imagesUrl,
-    String username,
-    String password,
-  ) async {
-    final images = <String>[];
-    
-    try {
-      // 创建图片目录（如果不存在）
-      final mkcolRequest = http.Request('MKCOL', Uri.parse(imagesUrl));
-      mkcolRequest.headers['Authorization'] = _basicAuth(username, password);
-      await client.send(mkcolRequest);
-      
-      // 列出目录内容
-      var request = http.Request('PROPFIND', Uri.parse(imagesUrl));
-      request.headers['Authorization'] = _basicAuth(username, password);
-      request.headers['Depth'] = '1';
-      
-      var response = await client.send(request);
-      
-      // 处理重定向
-      if (response.statusCode == 301 || response.statusCode == 302 ||
-          response.statusCode == 307 || response.statusCode == 308) {
-        final location = response.headers['location'];
-        if (location != null) {
-          imagesUrl = location;
-          request = http.Request('PROPFIND', Uri.parse(imagesUrl));
-          request.headers['Authorization'] = _basicAuth(username, password);
-          request.headers['Depth'] = '1';
-          response = await client.send(request);
-        }
-      }
-      
-      if (response.statusCode == 207) {
-        final body = await response.stream.bytesToString();
-        // 解析响应，提取文件名
-        final hrefMatches = RegExp(r'<d:href>([^<]+)</d:href>', caseSensitive: false)
-            .allMatches(body);
-        for (final match in hrefMatches) {
-          final href = match.group(1)!;
-          final name = p.basename(href);
-          if (name.isNotEmpty && name != 'images') {
-            images.add(name);
-          }
-        }
-      }
-    } catch (e) {
-      print('WebDAV: List remote images error: $e');
-    }
-    
-    return images;
-  }
-  
-  /// 获取上次同步时间
-  Future<DateTime?> getLastSyncTime() async {
-    final prefs = await SharedPreferences.getInstance();
-    final timeStr = prefs.getString(_lastSyncKey);
-    if (timeStr != null) {
-      try {
-        return DateTime.parse(timeStr);
-      } catch (e) {
-        return null;
-      }
-    }
-    return null;
-  }
-  
   /// Basic Auth 编码
   String _basicAuth(String username, String password) {
     final credentials = base64Encode(utf8.encode('$username:$password'));