iOS数据持久化深度解析：Core Data、SQLite与文件存储实战指南

@interface DataPersistenceArchitecture : NSObject

@property (nonatomic, strong) NSMutableDictionary *storageManagers;
@property (nonatomic, strong) NSMutableArray *performanceMetrics;
@property (nonatomic, assign) BOOL isMonitoringEnabled;

+ (instancetype)sharedArchitecture;

// 架构初始化
- (void)initializeDataPersistenceEnvironment;
- (void)configureStorageOptions;
- (void)setupPerformanceMonitoring;

// 存储管理器注册
- (void)registerStorageManager:(id)manager forType:(NSString *)type;
- (id)getStorageManagerForType:(NSString *)type;
- (NSArray *)getAllRegisteredManagers;

// 性能监控
- (void)recordOperation:(NSString *)operation
               duration:(NSTimeInterval)duration
            storageType:(NSString *)storageType;
- (NSDictionary *)getPerformanceReport;
- (void)analyzeStoragePerformance;

// 数据迁移
- (BOOL)migrateDataFromStorage:(NSString *)sourceType
                     toStorage:(NSString *)targetType
                    withOptions:(NSDictionary *)options;
- (void)validateDataIntegrity;

// 存储优化
- (void)optimizeStoragePerformance;
- (void)cleanupTemporaryData;
- (NSInteger)calculateStorageUsage;

@end

@implementation DataPersistenceArchitecture

+ (instancetype)sharedArchitecture {
    static DataPersistenceArchitecture *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[self alloc] init];
    });
    return sharedInstance;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        self.storageManagers = [NSMutableDictionary dictionary];
        self.performanceMetrics = [NSMutableArray array];
        self.isMonitoringEnabled = YES;
    }
    return self;
}

- (void)initializeDataPersistenceEnvironment {
    NSLog(@"=== 初始化数据持久化环境 ===");
    
    // 1. 检查存储权限
    [self checkStoragePermissions];
    
    // 2. 创建必要的目录结构
    [self createDirectoryStructure];
    
    // 3. 初始化各种存储管理器
    [self initializeStorageManagers];
    
    // 4. 设置性能监控
    [self setupPerformanceMonitoring];
    
    NSLog(@"数据持久化环境初始化完成");
}

- (void)checkStoragePermissions {
    NSLog(@"检查存储权限...");
    
    // 检查文档目录访问权限
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *documentsDirectory = [paths objectAtIndex:0];
    
    NSFileManager *fileManager = [NSFileManager defaultManager];
    BOOL isWritable = [fileManager isWritableFileAtPath:documentsDirectory];
    
    if (isWritable) {
        NSLog(@"文档目录访问权限正常: %@", documentsDirectory);
    } else {
        NSLog(@"警告: 文档目录访问权限受限");
    }
}

- (void)createDirectoryStructure {
    NSLog(@"创建目录结构...");
    
    NSFileManager *fileManager = [NSFileManager defaultManager];
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *documentsDirectory = [paths objectAtIndex:0];
    
    // 创建数据库目录
    NSString *databaseDirectory = [documentsDirectory stringByAppendingPathComponent:@"Database"];
    [fileManager createDirectoryAtPath:databaseDirectory withIntermediateDirectories:YES attributes:nil error:nil];
    
    // 创建文件存储目录
    NSString *filesDirectory = [documentsDirectory stringByAppendingPathComponent:@"Files"];
    [fileManager createDirectoryAtPath:filesDirectory withIntermediateDirectories:YES attributes:nil error:nil];
    
    // 创建缓存目录
    NSString *cacheDirectory = [documentsDirectory stringByAppendingPathComponent:@"Cache"];
    [fileManager createDirectoryAtPath:cacheDirectory withIntermediateDirectories:YES attributes:nil error:nil];
    
    // 创建临时目录
    NSString *tempDirectory = [documentsDirectory stringByAppendingPathComponent:@"Temp"];
    [fileManager createDirectoryAtPath:tempDirectory withIntermediateDirectories:YES attributes:nil error:nil];
    
    NSLog(@"目录结构创建完成");
}

- (void)initializeStorageManagers {
    NSLog(@"初始化存储管理器...");
    
    // 这里会在后续章节中注册具体的存储管理器
    // [self registerStorageManager:coreDataManager forType:@"CoreData"];
    // [self registerStorageManager:sqliteManager forType:@"SQLite"];
    // [self registerStorageManager:fileManager forType:@"File"];
    
    NSLog(@"存储管理器初始化完成");
}

- (void)configureStorageOptions {
    NSLog(@"配置存储选项...");
    
    // 获取设备信息
    NSInteger availableMemory = [self getAvailableMemory];
    NSInteger availableStorage = [self getAvailableStorage];
    
    NSLog(@"设备信息 - 可用内存: %ld MB, 可用存储: %ld MB", (long)availableMemory, (long)availableStorage);
    
    // 根据设备性能调整存储策略
    if (availableStorage < 1024) { // 小于1GB
        NSLog(@"存储空间不足，启用压缩存储模式");
        // 启用数据压缩
    } else if (availableStorage > 10240) { // 大于10GB
        NSLog(@"存储空间充足，启用高性能存储模式");
        // 启用缓存优化
    }
}

- (NSInteger)getAvailableMemory {
    // 获取可用内存（简化实现）
    return 2048; // 2GB
}

- (NSInteger)getAvailableStorage {
    NSError *error;
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSDictionary *dictionary = [[NSFileManager defaultManager] attributesOfFileSystemForPath:[paths lastObject] error:&error];
    
    if (dictionary) {
        NSNumber *freeFileSystemSizeInBytes = [dictionary objectForKey:NSFileSystemFreeSize];
        return [freeFileSystemSizeInBytes longLongValue] / 1024 / 1024; // 转换为MB
    }
    
    return 0;
}

- (void)setupPerformanceMonitoring {
    NSLog(@"设置性能监控...");
    
    self.isMonitoringEnabled = YES;
    
    // 定期清理性能指标
    dispatch_queue_t cleanupQueue = dispatch_queue_create("com.performance.cleanup", DISPATCH_QUEUE_SERIAL);
    
    dispatch_async(cleanupQueue, ^{
        while (self.isMonitoringEnabled) {
            [NSThread sleepForTimeInterval:300.0]; // 每5分钟清理一次
            
            @autoreleasepool {
                [self cleanupOldMetrics];
            }
        }
    });
}

- (void)cleanupOldMetrics {
    NSDate *cutoffDate = [NSDate dateWithTimeIntervalSinceNow:-3600]; // 保留1小时内的数据
    
    NSMutableArray *metricsToRemove = [NSMutableArray array];
    
    for (NSDictionary *metric in self.performanceMetrics) {
        NSDate *timestamp = metric[@"timestamp"];
        if ([timestamp compare:cutoffDate] == NSOrderedAscending) {
            [metricsToRemove addObject:metric];
        }
    }
    
    [self.performanceMetrics removeObjectsInArray:metricsToRemove];
    
    if (metricsToRemove.count > 0) {
        NSLog(@"清理了 %lu 条过期性能指标", (unsigned long)metricsToRemove.count);
    }
}

- (void)registerStorageManager:(id)manager forType:(NSString *)type {
    if (manager && type) {
        self.storageManagers[type] = manager;
        NSLog(@"注册存储管理器: %@", type);
    }
}

- (id)getStorageManagerForType:(NSString *)type {
    return self.storageManagers[type];
}

- (NSArray *)getAllRegisteredManagers {
    return [self.storageManagers allValues];
}

- (void)recordOperation:(NSString *)operation
               duration:(NSTimeInterval)duration
            storageType:(NSString *)storageType {
    
    if (!self.isMonitoringEnabled) return;
    
    NSDictionary *metric = @{
        @"operation": operation ?: @"unknown",
        @"duration": @(duration),
        @"storageType": storageType ?: @"unknown",
        @"timestamp": [NSDate date]
    };
    
    [self.performanceMetrics addObject:metric];
    
    // 如果操作耗时过长，记录警告
    if (duration > 1.0) {
        NSLog(@"警告: 存储操作耗时过长 - %@ (%.2f秒)", operation, duration);
    }
}

- (NSDictionary *)getPerformanceReport {
    NSMutableDictionary *report = [NSMutableDictionary dictionary];
    
    // 统计各种存储类型的性能
    NSMutableDictionary *storageStats = [NSMutableDictionary dictionary];
    
    for (NSDictionary *metric in self.performanceMetrics) {
        NSString *storageType = metric[@"storageType"];
        NSNumber *duration = metric[@"duration"];
        
        if (!storageStats[storageType]) {
            storageStats[storageType] = [NSMutableArray array];
        }
        
        [storageStats[storageType] addObject:duration];
    }
    
    // 计算平均值和统计信息
    for (NSString *storageType in storageStats) {
        NSArray *durations = storageStats[storageType];
        
        double totalDuration = 0;
        double maxDuration = 0;
        double minDuration = INFINITY;
        
        for (NSNumber *duration in durations) {
            double d = [duration doubleValue];
            totalDuration += d;
            maxDuration = MAX(maxDuration, d);
            minDuration = MIN(minDuration, d);
        }
        
        double averageDuration = totalDuration / durations.count;
        
        report[storageType] = @{
            @"operationCount": @(durations.count),
            @"averageDuration": @(averageDuration),
            @"maxDuration": @(maxDuration),
            @"minDuration": @(minDuration == INFINITY ? 0 : minDuration),
            @"totalDuration": @(totalDuration)
        };
    }
    
    report[@"totalOperations"] = @(self.performanceMetrics.count);
    report[@"reportTimestamp"] = [NSDate date];
    
    return report;
}

- (void)analyzeStoragePerformance {
    NSLog(@"=== 分析存储性能 ===");
    
    NSDictionary *report = [self getPerformanceReport];
    
    for (NSString *storageType in report) {
        if ([storageType isEqualToString:@"totalOperations"] || [storageType isEqualToString:@"reportTimestamp"]) {
            continue;
        }
        
        NSDictionary *stats = report[storageType];
        NSLog(@"存储类型: %@", storageType);
        NSLog(@"  操作次数: %@", stats[@"operationCount"]);
        NSLog(@"  平均耗时: %.3f秒", [stats[@"averageDuration"] doubleValue]);
        NSLog(@"  最大耗时: %.3f秒", [stats[@"maxDuration"] doubleValue]);
        NSLog(@"  最小耗时: %.3f秒", [stats[@"minDuration"] doubleValue]);
    }
}

- (BOOL)migrateDataFromStorage:(NSString *)sourceType
                     toStorage:(NSString *)targetType
                    withOptions:(NSDictionary *)options {
    
    NSLog(@"开始数据迁移: %@ -> %@", sourceType, targetType);
    
    id sourceManager = [self getStorageManagerForType:sourceType];
    id targetManager = [self getStorageManagerForType:targetType];
    
    if (!sourceManager || !targetManager) {
        NSLog(@"错误: 找不到对应的存储管理器");
        return NO;
    }
    
    // 这里需要根据具体的存储管理器实现迁移逻辑
    // 实际实现会在具体的存储管理器中完成
    
    NSLog(@"数据迁移完成");
    return YES;
}

- (void)validateDataIntegrity {
    NSLog(@"验证数据完整性...");
    
    for (NSString *storageType in self.storageManagers) {
        id manager = self.storageManagers[storageType];
        
        // 调用各个存储管理器的数据完整性检查方法
        if ([manager respondsToSelector:@selector(validateDataIntegrity)]) {
            BOOL isValid = [manager validateDataIntegrity];
            NSLog(@"%@ 数据完整性: %@", storageType, isValid ? @"正常" : @"异常");
        }
    }
}

- (void)optimizeStoragePerformance {
    NSLog(@"优化存储性能...");
    
    // 分析性能报告
    NSDictionary *report = [self getPerformanceReport];
    
    for (NSString *storageType in report) {
        if ([storageType isEqualToString:@"totalOperations"] || [storageType isEqualToString:@"reportTimestamp"]) {
            continue;
        }
        
        NSDictionary *stats = report[storageType];
        double averageDuration = [stats[@"averageDuration"] doubleValue];
        
        // 如果平均耗时超过阈值，触发优化
        if (averageDuration > 0.5) {
            NSLog(@"触发 %@ 存储优化，平均耗时: %.3f秒", storageType, averageDuration);
            
            id manager = [self getStorageManagerForType:storageType];
            if ([manager respondsToSelector:@selector(optimizePerformance)]) {
                [manager optimizePerformance];
            }
        }
    }
}

- (void)cleanupTemporaryData {
    NSLog(@"清理临时数据...");
    
    NSFileManager *fileManager = [NSFileManager defaultManager];
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *documentsDirectory = [paths objectAtIndex:0];
    NSString *tempDirectory = [documentsDirectory stringByAppendingPathComponent:@"Temp"];
    
    NSError *error;
    NSArray *tempFiles = [fileManager contentsOfDirectoryAtPath:tempDirectory error:&error];
    
    NSInteger cleanedFiles = 0;
    NSInteger cleanedSize = 0;
    
    for (NSString *fileName in tempFiles) {
        NSString *filePath = [tempDirectory stringByAppendingPathComponent:fileName];
        
        NSDictionary *attributes = [fileManager attributesOfItemAtPath:filePath error:nil];
        NSDate *modificationDate = attributes[NSFileModificationDate];
        
        // 删除超过1小时的临时文件
        if ([[NSDate date] timeIntervalSinceDate:modificationDate] > 3600) {
            NSInteger fileSize = [attributes[NSFileSize] integerValue];
            
            if ([fileManager removeItemAtPath:filePath error:nil]) {
                cleanedFiles++;
                cleanedSize += fileSize;
            }
        }
    }
    
    NSLog(@"清理完成 - 文件数: %ld, 释放空间: %.2f MB", (long)cleanedFiles, cleanedSize / 1024.0 / 1024.0);
}

- (NSInteger)calculateStorageUsage {
    NSFileManager *fileManager = [NSFileManager defaultManager];
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *documentsDirectory = [paths objectAtIndex:0];
    
    NSInteger totalSize = 0;
    
    NSDirectoryEnumerator *enumerator = [fileManager enumeratorAtPath:documentsDirectory];
    NSString *fileName;
    
    while ((fileName = [enumerator nextObject])) {
        NSString *filePath = [documentsDirectory stringByAppendingPathComponent:fileName];
        NSDictionary *attributes = [fileManager attributesOfItemAtPath:filePath error:nil];
        
        if (attributes[NSFileSize]) {
            totalSize += [attributes[NSFileSize] integerValue];
        }
    }
    
    NSLog(@"总存储使用量: %.2f MB", totalSize / 1024.0 / 1024.0);
    return totalSize;
}

@end

@interface SQLiteManager : NSObject

@property (nonatomic, assign) sqlite3 *database;
@property (nonatomic, strong) NSString *databasePath;
@property (nonatomic, strong) NSMutableArray *performanceMetrics;
@property (nonatomic, strong) dispatch_queue_t databaseQueue;
@property (nonatomic, assign) BOOL isTransactionActive;

+ (instancetype)sharedManager;

// 数据库初始化
- (BOOL)initializeDatabaseWithName:(NSString *)databaseName;
- (BOOL)openDatabase;
- (void)closeDatabase;
- (BOOL)createTablesWithSchema:(NSArray *)tableSchemas;

// 基础操作
- (BOOL)executeSQL:(NSString *)sql;
- (BOOL)executeSQL:(NSString *)sql withParameters:(NSArray *)parameters;
- (NSArray *)executeQuery:(NSString *)sql;
- (NSArray *)executeQuery:(NSString *)sql withParameters:(NSArray *)parameters;

// 事务管理
- (BOOL)beginTransaction;
- (BOOL)commitTransaction;
- (BOOL)rollbackTransaction;
- (void)executeInTransaction:(void(^)(BOOL *rollback))block;

// 数据操作
- (BOOL)insertIntoTable:(NSString *)tableName values:(NSDictionary *)values;
- (BOOL)updateTable:(NSString *)tableName
                set:(NSDictionary *)values
              where:(NSString *)whereClause
         parameters:(NSArray *)parameters;
- (BOOL)deleteFromTable:(NSString *)tableName
                  where:(NSString *)whereClause
             parameters:(NSArray *)parameters;
- (NSArray *)selectFromTable:(NSString *)tableName
                     columns:(NSArray *)columns
                       where:(NSString *)whereClause
                  parameters:(NSArray *)parameters
                     orderBy:(NSString *)orderBy
                       limit:(NSInteger)limit;

// 批量操作
- (BOOL)batchInsert:(NSArray *)dataArray intoTable:(NSString *)tableName;
- (BOOL)batchUpdate:(NSArray *)updateData inTable:(NSString *)tableName;
- (BOOL)batchDelete:(NSArray *)conditions fromTable:(NSString *)tableName;

// 性能优化
- (void)optimizeDatabase;
- (void)analyzeDatabase;
- (void)vacuumDatabase;
- (void)createIndex:(NSString *)indexName onTable:(NSString *)tableName columns:(NSArray *)columns;

// 数据库维护
- (BOOL)backupDatabaseToPath:(NSString *)backupPath;
- (BOOL)restoreDatabaseFromPath:(NSString *)backupPath;
- (NSInteger)getDatabaseSize;
- (NSDictionary *)getDatabaseInfo;

// 性能监控
- (void)enablePerformanceMonitoring;
- (NSDictionary *)getPerformanceReport;
- (void)logSQLiteStatistics;

@end

@implementation SQLiteManager

+ (instancetype)sharedManager {
    static SQLiteManager *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[self alloc] init];
    });
    return sharedInstance;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        self.performanceMetrics = [NSMutableArray array];
        self.databaseQueue = dispatch_queue_create("com.sqlite.database", DISPATCH_QUEUE_SERIAL);
        self.isTransactionActive = NO;
    }
    return self;
}

- (BOOL)initializeDatabaseWithName:(NSString *)databaseName {
    NSLog(@"=== 初始化SQLite数据库: %@ ===", databaseName);
    
    // 获取数据库路径
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *documentsDirectory = [paths objectAtIndex:0];
    NSString *databaseDirectory = [documentsDirectory stringByAppendingPathComponent:@"Database"];
    self.databasePath = [databaseDirectory stringByAppendingPathComponent:[NSString stringWithFormat:@"%@.sqlite", databaseName]];
    
    NSLog(@"数据库路径: %@", self.databasePath);
    
    // 打开数据库
    if ([self openDatabase]) {
        NSLog(@"SQLite数据库初始化成功");
        [self enablePerformanceMonitoring];
        return YES;
    } else {
        NSLog(@"SQLite数据库初始化失败");
        return NO;
    }
}

- (BOOL)openDatabase {
    if (sqlite3_open([self.databasePath UTF8String], &_database) == SQLITE_OK) {
        NSLog(@"数据库打开成功");
        
        // 设置数据库配置
        [self configureDatabaseSettings];
        
        return YES;
    } else {
        NSLog(@"数据库打开失败: %s", sqlite3_errmsg(_database));
        return NO;
    }
}

- (void)configureDatabaseSettings {
    NSLog(@"配置数据库设置...");
    
    // 启用外键约束
    [self executeSQL:@"PRAGMA foreign_keys = ON;"];
    
    // 设置日志模式为WAL（Write-Ahead Logging）
    [self executeSQL:@"PRAGMA journal_mode = WAL;"];
    
    // 设置同步模式
    [self executeSQL:@"PRAGMA synchronous = NORMAL;"];
    
    // 设置缓存大小（页数）
    [self executeSQL:@"PRAGMA cache_size = 10000;"];
    
    // 设置临时存储为内存
    [self executeSQL:@"PRAGMA temp_store = MEMORY;"];
    
    NSLog(@"数据库设置配置完成");
}

- (void)closeDatabase {
    if (_database) {
        sqlite3_close(_database);
        _database = NULL;
        NSLog(@"数据库已关闭");
    }
}

- (BOOL)createTablesWithSchema:(NSArray *)tableSchemas {
    NSLog(@"创建数据表...");
    
    BOOL success = YES;
    
    for (NSString *schema in tableSchemas) {
        if (![self executeSQL:schema]) {
            NSLog(@"创建表失败: %@", schema);
            success = NO;
        }
    }
    
    if (success) {
        NSLog(@"所有数据表创建成功");
    }
    
    return success;
}

- (BOOL)executeSQL:(NSString *)sql {
    return [self executeSQL:sql withParameters:nil];
}

- (BOOL)executeSQL:(NSString *)sql withParameters:(NSArray *)parameters {
    NSDate *startTime = [NSDate date];
    
    __block BOOL success = NO;
    
    dispatch_sync(self.databaseQueue, ^{
        sqlite3_stmt *statement;
        
        if (sqlite3_prepare_v2(self.database, [sql UTF8String], -1, &statement, NULL) == SQLITE_OK) {
            
            // 绑定参数
            if (parameters) {
                [self bindParameters:parameters toStatement:statement];
            }
            
            if (sqlite3_step(statement) == SQLITE_DONE) {
                success = YES;
            } else {
                NSLog(@"SQL执行失败: %s", sqlite3_errmsg(self.database));
            }
            
            sqlite3_finalize(statement);
        } else {
            NSLog(@"SQL准备失败: %s", sqlite3_errmsg(self.database));
        }
    });
    
    // 记录性能指标
    NSTimeInterval duration = [[NSDate date] timeIntervalSinceDate:startTime];
    [self recordOperation:@"execute" duration:duration success:success];
    
    return success;
}

- (NSArray *)executeQuery:(NSString *)sql {
    return [self executeQuery:sql withParameters:nil];
}

- (NSArray *)executeQuery:(NSString *)sql withParameters:(NSArray *)parameters {
    NSDate *startTime = [NSDate date];
    
    __block NSMutableArray *results = [NSMutableArray array];
    
    dispatch_sync(self.databaseQueue, ^{
        sqlite3_stmt *statement;
        
        if (sqlite3_prepare_v2(self.database, [sql UTF8String], -1, &statement, NULL) == SQLITE_OK) {
            
            // 绑定参数
            if (parameters) {
                [self bindParameters:parameters toStatement:statement];
            }
            
            // 获取列信息
            int columnCount = sqlite3_column_count(statement);
            NSMutableArray *columnNames = [NSMutableArray array];
            
            for (int i = 0; i < columnCount; i++) {
                const char *columnName = sqlite3_column_name(statement, i);
                [columnNames addObject:[NSString stringWithUTF8String:columnName]];
            }
            
            // 读取数据
            while (sqlite3_step(statement) == SQLITE_ROW) {
                NSMutableDictionary *row = [NSMutableDictionary dictionary];
                
                for (int i = 0; i < columnCount; i++) {
                    NSString *columnName = columnNames[i];
                    id value = [self getColumnValue:statement atIndex:i];
                    
                    if (value) {
                        row[columnName] = value;
                    }
                }
                
                [results addObject:row];
            }
            
            sqlite3_finalize(statement);
        } else {
            NSLog(@"查询准备失败: %s", sqlite3_errmsg(self.database));
        }
    });
    
    // 记录性能指标
    NSTimeInterval duration = [[NSDate date] timeIntervalSinceDate:startTime];
    [self recordOperation:@"query" duration:duration success:YES];
    
    NSLog(@"查询完成，返回 %lu 条记录，耗时: %.3f秒", (unsigned long)results.count, duration);
    
    return results;
}

- (void)bindParameters:(NSArray *)parameters toStatement:(sqlite3_stmt *)statement {
    for (int i = 0; i < parameters.count; i++) {
        id parameter = parameters[i];
        int index = i + 1; // SQLite参数索引从1开始
        
        if ([parameter isKindOfClass:[NSString class]]) {
            sqlite3_bind_text(statement, index, [parameter UTF8String], -1, SQLITE_TRANSIENT);
        } else if ([parameter isKindOfClass:[NSNumber class]]) {
            NSNumber *number = (NSNumber *)parameter;
            const char *type = [number objCType];
            
            if (strcmp(type, @encode(int)) == 0 || strcmp(type, @encode(long)) == 0) {
                sqlite3_bind_int64(statement, index, [number longLongValue]);
            } else if (strcmp(type, @encode(float)) == 0 || strcmp(type, @encode(double)) == 0) {
                sqlite3_bind_double(statement, index, [number doubleValue]);
            } else {
                sqlite3_bind_int(statement, index, [number intValue]);
            }
        } else if ([parameter isKindOfClass:[NSData class]]) {
            NSData *data = (NSData *)parameter;
            sqlite3_bind_blob(statement, index, [data bytes], (int)[data length], SQLITE_TRANSIENT);
        } else if ([parameter isKindOfClass:[NSNull class]]) {
            sqlite3_bind_null(statement, index);
        } else {
            // 默认转换为字符串
            NSString *stringValue = [parameter description];
            sqlite3_bind_text(statement, index, [stringValue UTF8String], -1, SQLITE_TRANSIENT);
        }
    }
}

- (id)getColumnValue:(sqlite3_stmt *)statement atIndex:(int)index {
    int columnType = sqlite3_column_type(statement, index);
    
    switch (columnType) {
        case SQLITE_INTEGER:
            return @(sqlite3_column_int64(statement, index));
            
        case SQLITE_FLOAT:
            return @(sqlite3_column_double(statement, index));
            
        case SQLITE_TEXT: {
            const char *text = (const char *)sqlite3_column_text(statement, index);
            return text ? [NSString stringWithUTF8String:text] : @"";
        }
            
        case SQLITE_BLOB: {
            const void *blob = sqlite3_column_blob(statement, index);
            int blobSize = sqlite3_column_bytes(statement, index);
            return blob ? [NSData dataWithBytes:blob length:blobSize] : [NSData data];
        }
            
        case SQLITE_NULL:
        default:
            return [NSNull null];
    }
}

- (BOOL)beginTransaction {
    if (self.isTransactionActive) {
        NSLog(@"警告: 事务已经处于活动状态");
        return NO;
    }
    
    BOOL success = [self executeSQL:@"BEGIN TRANSACTION;"];
    if (success) {
        self.isTransactionActive = YES;
        NSLog(@"事务开始");
    }
    
    return success;
}

- (BOOL)commitTransaction {
    if (!self.isTransactionActive) {
        NSLog(@"警告: 没有活动的事务可提交");
        return NO;
    }
    
    BOOL success = [self executeSQL:@"COMMIT TRANSACTION;"];
    if (success) {
        self.isTransactionActive = NO;
        NSLog(@"事务提交成功");
    }
    
    return success;
}

- (BOOL)rollbackTransaction {
    if (!self.isTransactionActive) {
        NSLog(@"警告: 没有活动的事务可回滚");
        return NO;
    }
    
    BOOL success = [self executeSQL:@"ROLLBACK TRANSACTION;"];
    if (success) {
        self.isTransactionActive = NO;
        NSLog(@"事务回滚成功");
    }
    
    return success;
}

- (void)executeInTransaction:(void(^)(BOOL *rollback))block {
    if ([self beginTransaction]) {
        BOOL rollback = NO;
        
        @try {
            if (block) {
                block(&rollback);
            }
        } @catch (NSException *exception) {
            NSLog(@"事务执行异常: %@", exception.reason);
            rollback = YES;
        }
        
        if (rollback) {
            [self rollbackTransaction];
        } else {
            [self commitTransaction];
        }
    }
}

- (BOOL)insertIntoTable:(NSString *)tableName values:(NSDictionary *)values {
    if (!values || values.count == 0) {
        return NO;
    }
    
    NSArray *columns = [values allKeys];
    NSArray *valueArray = [values allValues];
    
    NSString *columnsString = [columns componentsJoinedByString:@", "];
    NSString *placeholders = [[@"" stringByPaddingToLength:columns.count * 3 - 2 withString:@"?, " startingAtIndex:0] substringToIndex:columns.count * 3 - 2];
    
    NSString *sql = [NSString stringWithFormat:@"INSERT INTO %@ (%@) VALUES (%@);", tableName, columnsString, placeholders];
    
    return [self executeSQL:sql withParameters:valueArray];
}

- (BOOL)updateTable:(NSString *)tableName
                set:(NSDictionary *)values
              where:(NSString *)whereClause
         parameters:(NSArray *)parameters {
    
    if (!values || values.count == 0) {
        return NO;
    }
    
    NSMutableArray *setParts = [NSMutableArray array];
    NSMutableArray *allParameters = [NSMutableArray array];
    
    for (NSString *column in values) {
        [setParts addObject:[NSString stringWithFormat:@"%@ = ?", column]];
        [allParameters addObject:values[column]];
    }
    
    if (parameters) {
        [allParameters addObjectsFromArray:parameters];
    }
    
    NSString *setClause = [setParts componentsJoinedByString:@", "];
    NSString *sql = [NSString stringWithFormat:@"UPDATE %@ SET %@", tableName, setClause];
    
    if (whereClause && whereClause.length > 0) {
        sql = [sql stringByAppendingFormat:@" WHERE %@", whereClause];
    }
    
    sql = [sql stringByAppendingString:@";"];
    
    return [self executeSQL:sql withParameters:allParameters];
}

- (BOOL)deleteFromTable:(NSString *)tableName
                  where:(NSString *)whereClause
             parameters:(NSArray *)parameters {
    
    NSString *sql = [NSString stringWithFormat:@"DELETE FROM %@", tableName];
    
    if (whereClause && whereClause.length > 0) {
        sql = [sql stringByAppendingFormat:@" WHERE %@", whereClause];
    }
    
    sql = [sql stringByAppendingString:@";"];
    
    return [self executeSQL:sql withParameters:parameters];
}

- (NSArray *)selectFromTable:(NSString *)tableName
                     columns:(NSArray *)columns
                       where:(NSString *)whereClause
                  parameters:(NSArray *)parameters
                     orderBy:(NSString *)orderBy
                       limit:(NSInteger)limit {
    
    NSString *columnsString = columns && columns.count > 0 ? [columns componentsJoinedByString:@", "] : @"*";
    NSString *sql = [NSString stringWithFormat:@"SELECT %@ FROM %@", columnsString, tableName];
    
    if (whereClause && whereClause.length > 0) {
        sql = [sql stringByAppendingFormat:@" WHERE %@", whereClause];
    }
    
    if (orderBy && orderBy.length > 0) {
        sql = [sql stringByAppendingFormat:@" ORDER BY %@", orderBy];
    }
    
    if (limit > 0) {
        sql = [sql stringByAppendingFormat:@" LIMIT %ld", (long)limit];
    }
    
    sql = [sql stringByAppendingString:@";"];
    
    return [self executeQuery:sql withParameters:parameters];
}

- (BOOL)batchInsert:(NSArray *)dataArray intoTable:(NSString *)tableName {
    if (!dataArray || dataArray.count == 0) {
        return YES;
    }
    
    __block BOOL success = YES;
    
    [self executeInTransaction:^(BOOL *rollback) {
        for (NSDictionary *data in dataArray) {
            if (![self insertIntoTable:tableName values:data]) {
                success = NO;
                *rollback = YES;
                break;
            }
        }
    }];
    
    NSLog(@"批量插入 %lu 条记录%@", (unsigned long)dataArray.count, success ? @"成功" : @"失败");
    return success;
}

- (BOOL)batchUpdate:(NSArray *)updateData inTable:(NSString *)tableName {
    if (!updateData || updateData.count == 0) {
        return YES;
    }
    
    __block BOOL success = YES;
    
    [self executeInTransaction:^(BOOL *rollback) {
        for (NSDictionary *data in updateData) {
            NSDictionary *values = data[@"values"];
            NSString *whereClause = data[@"where"];
            NSArray *parameters = data[@"parameters"];
            
            if (![self updateTable:tableName set:values where:whereClause parameters:parameters]) {
                success = NO;
                *rollback = YES;
                break;
            }
        }
    }];
    
    NSLog(@"批量更新 %lu 条记录%@", (unsigned long)updateData.count, success ? @"成功" : @"失败");
    return success;
}

- (BOOL)batchDelete:(NSArray *)conditions fromTable:(NSString *)tableName {
    if (!conditions || conditions.count == 0) {
        return YES;
    }
    
    __block BOOL success = YES;
    
    [self executeInTransaction:^(BOOL *rollback) {
        for (NSDictionary *condition in conditions) {
            NSString *whereClause = condition[@"where"];
            NSArray *parameters = condition[@"parameters"];
            
            if (![self deleteFromTable:tableName where:whereClause parameters:parameters]) {
                success = NO;
                *rollback = YES;
                break;
            }
        }
    }];
    
    NSLog(@"批量删除 %lu 条记录%@", (unsigned long)conditions.count, success ? @"成功" : @"失败");
    return success;
}

- (void)optimizeDatabase {
    NSLog(@"=== 优化数据库性能 ===");
    
    [self analyzeDatabase];
    [self vacuumDatabase];
    
    NSLog(@"数据库优化完成");
}

- (void)analyzeDatabase {
    NSLog(@"分析数据库...");
    
    [self executeSQL:@"ANALYZE;"];
    
    NSLog(@"数据库分析完成");
}

- (void)vacuumDatabase {
    NSLog(@"压缩数据库...");
    
    [self executeSQL:@"VACUUM;"];
    
    NSLog(@"数据库压缩完成");
}

- (void)createIndex:(NSString *)indexName onTable:(NSString *)tableName columns:(NSArray *)columns {
    NSString *columnsString = [columns componentsJoinedByString:@", "];
    NSString *sql = [NSString stringWithFormat:@"CREATE INDEX IF NOT EXISTS %@ ON %@ (%@);", indexName, tableName, columnsString];
    
    if ([self executeSQL:sql]) {
        NSLog(@"索引创建成功: %@", indexName);
    } else {
        NSLog(@"索引创建失败: %@", indexName);
    }
}

- (BOOL)backupDatabaseToPath:(NSString *)backupPath {
    NSLog(@"备份数据库到: %@", backupPath);
    
    NSFileManager *fileManager = [NSFileManager defaultManager];
    NSError *error;
    
    // 确保备份目录存在
    NSString *backupDirectory = [backupPath stringByDeletingLastPathComponent];
    [fileManager createDirectoryAtPath:backupDirectory withIntermediateDirectories:YES attributes:nil error:nil];
    
    // 复制数据库文件
    BOOL success = [fileManager copyItemAtPath:self.databasePath toPath:backupPath error:&error];
    
    if (success) {
        NSLog(@"数据库备份成功");
    } else {
        NSLog(@"数据库备份失败: %@", error.localizedDescription);
    }
    
    return success;
}

- (BOOL)restoreDatabaseFromPath:(NSString *)backupPath {
    NSLog(@"从备份恢复数据库: %@", backupPath);
    
    NSFileManager *fileManager = [NSFileManager defaultManager];
    
    if (![fileManager fileExistsAtPath:backupPath]) {
        NSLog(@"备份文件不存在: %@", backupPath);
        return NO;
    }
    
    // 关闭当前数据库
    [self closeDatabase];
    
    // 删除当前数据库文件
    NSError *error;
    [fileManager removeItemAtPath:self.databasePath error:&error];
    
    // 复制备份文件
    BOOL success = [fileManager copyItemAtPath:backupPath toPath:self.databasePath error:&error];
    
    if (success) {
        NSLog(@"数据库恢复成功");
        // 重新打开数据库
        [self openDatabase];
    } else {
        NSLog(@"数据库恢复失败: %@", error.localizedDescription);
    }
    
    return success;
}

- (NSInteger)getDatabaseSize {
    NSFileManager *fileManager = [NSFileManager defaultManager];
    NSDictionary *attributes = [fileManager attributesOfItemAtPath:self.databasePath error:nil];
    
    if (attributes) {
        NSInteger size = [attributes[NSFileSize] integerValue];
        NSLog(@"数据库大小: %.2f MB", size / 1024.0 / 1024.0);
        return size;
    }
    
    return 0;
}

- (NSDictionary *)getDatabaseInfo {
    NSMutableDictionary *info = [NSMutableDictionary dictionary];
    
    // 数据库大小
    info[@"size"] = @([self getDatabaseSize]);
    
    // 数据库路径
    info[@"path"] = self.databasePath;
    
    // 获取表信息
    NSArray *tables = [self executeQuery:@"SELECT name FROM sqlite_master WHERE type='table';"];
    info[@"tables"] = tables;
    
    // 获取索引信息
    NSArray *indexes = [self executeQuery:@"SELECT name FROM sqlite_master WHERE type='index';"];
    info[@"indexes"] = indexes;
    
    // 数据库版本
    NSArray *versionResult = [self executeQuery:@"PRAGMA user_version;"];
    if (versionResult.count > 0) {
        info[@"version"] = versionResult[0][@"user_version"];
    }
    
    return info;
}

- (void)recordOperation:(NSString *)operation duration:(NSTimeInterval)duration success:(BOOL)success {
    NSDictionary *metric = @{
        @"operation": operation,
        @"duration": @(duration),
        @"success": @(success),
        @"timestamp": [NSDate date]
    };
    
    [self.performanceMetrics addObject:metric];
    
    // 保持最近1000条记录
    if (self.performanceMetrics.count > 1000) {
        [self.performanceMetrics removeObjectAtIndex:0];
    }
}

- (void)enablePerformanceMonitoring {
    NSLog(@"启用SQLite性能监控...");
    
    // 这里可以添加更多的监控逻辑
    
    NSLog(@"SQLite性能监控启用完成");
}

- (NSDictionary *)getPerformanceReport {
    NSMutableDictionary *report = [NSMutableDictionary dictionary];
    
    // 统计各种操作的性能
    NSMutableDictionary *operationStats = [NSMutableDictionary dictionary];
    
    for (NSDictionary *metric in self.performanceMetrics) {
        NSString *operation = metric[@"operation"];
        NSNumber *duration = metric[@"duration"];
        NSNumber *success = metric[@"success"];
        
        if (!operationStats[operation]) {
            operationStats[operation] = [NSMutableDictionary dictionary];
            operationStats[operation][@"durations"] = [NSMutableArray array];
            operationStats[operation][@"successCount"] = @0;
            operationStats[operation][@"totalCount"] = @0;
        }
        
        [operationStats[operation][@"durations"] addObject:duration];
        operationStats[operation][@"totalCount"] = @([operationStats[operation][@"totalCount"] integerValue] + 1);
        
        if ([success boolValue]) {
            operationStats[operation][@"successCount"] = @([operationStats[operation][@"successCount"] integerValue] + 1);
        }
    }
    
    // 计算统计信息
    for (NSString *operation in operationStats) {
        NSArray *durations = operationStats[operation][@"durations"];
        NSInteger successCount = [operationStats[operation][@"successCount"] integerValue];
        NSInteger totalCount = [operationStats[operation][@"totalCount"] integerValue];
        
        double totalDuration = 0;
        double maxDuration = 0;
        double minDuration = INFINITY;
        
        for (NSNumber *duration in durations) {
            double d = [duration doubleValue];
            totalDuration += d;
            maxDuration = MAX(maxDuration, d);
            minDuration = MIN(minDuration, d);
        }
        
        double averageDuration = totalDuration / durations.count;
        double successRate = (double)successCount / totalCount;
        
        report[operation] = @{
            @"operationCount": @(totalCount),
            @"successRate": @(successRate),
            @"averageDuration": @(averageDuration),
            @"maxDuration": @(maxDuration),
            @"minDuration": @(minDuration == INFINITY ? 0 : minDuration),
            @"totalDuration": @(totalDuration)
        };
    }
    
    report[@"totalOperations"] = @(self.performanceMetrics.count);
    report[@"reportTimestamp"] = [NSDate date];
    
    return report;
}

- (void)logSQLiteStatistics {
    NSLog(@"=== SQLite统计信息 ===");
    
    NSDictionary *report = [self getPerformanceReport];
    
    for (NSString *operation in report) {
        if ([operation isEqualToString:@"totalOperations"] || [operation isEqualToString:@"reportTimestamp"]) {
            continue;
        }
        
        NSDictionary *stats = report[operation];
        NSLog(@"操作类型: %@", operation);
        NSLog(@"  操作次数: %@", stats[@"operationCount"]);
        NSLog(@"  成功率: %.1f%%", [stats[@"successRate"] doubleValue] * 100);
        NSLog(@"  平均耗时: %.3f秒", [stats[@"averageDuration"] doubleValue]);
        NSLog(@"  最大耗时: %.3f秒", [stats[@"maxDuration"] doubleValue]);
    }
    
    // 数据库信息
    NSDictionary *dbInfo = [self getDatabaseInfo];
    NSLog(@"数据库大小: %.2f MB", [dbInfo[@"size"] doubleValue] / 1024.0 / 1024.0);
    NSLog(@"表数量: %lu", (unsigned long)[dbInfo[@"tables"] count]);
    NSLog(@"索引数量: %lu", (unsigned long)[dbInfo[@"indexes"] count]);
}

- (void)dealloc {
    [self closeDatabase];
}

@end

@interface FileStorageManager : NSObject

@property (nonatomic, strong) NSString *documentsPath;
@property (nonatomic, strong) NSString *cachesPath;
@property (nonatomic, strong) NSString *temporaryPath;
@property (nonatomic, strong) NSMutableDictionary *storageMetrics;
@property (nonatomic, strong) dispatch_queue_t fileQueue;
@property (nonatomic, strong) NSFileManager *fileManager;

+ (instancetype)sharedManager;

// 初始化和配置
- (void)initializeStorageDirectories;
- (void)configureStorageSettings;
- (NSString *)getStoragePathForType:(NSString *)storageType;

// 文件操作
- (BOOL)writeData:(NSData *)data toFile:(NSString *)fileName inDirectory:(NSString *)directory;
- (NSData *)readDataFromFile:(NSString *)fileName inDirectory:(NSString *)directory;
- (BOOL)deleteFile:(NSString *)fileName inDirectory:(NSString *)directory;
- (BOOL)fileExists:(NSString *)fileName inDirectory:(NSString *)directory;
- (NSString *)getFullPathForFile:(NSString *)fileName inDirectory:(NSString *)directory;

// 对象序列化
- (BOOL)saveObject:(id<NSCoding>)object toFile:(NSString *)fileName inDirectory:(NSString *)directory;
- (id)loadObjectFromFile:(NSString *)fileName inDirectory:(NSString *)directory;
- (BOOL)saveJSONObject:(id)object toFile:(NSString *)fileName inDirectory:(NSString *)directory;
- (id)loadJSONObjectFromFile:(NSString *)fileName inDirectory:(NSString *)directory;

// 批量操作
- (BOOL)batchWriteFiles:(NSArray *)fileDataArray toDirectory:(NSString *)directory;
- (NSArray *)batchReadFiles:(NSArray *)fileNames fromDirectory:(NSString *)directory;
- (BOOL)batchDeleteFiles:(NSArray *)fileNames fromDirectory:(NSString *)directory;

// 目录管理
- (BOOL)createDirectory:(NSString *)directoryName;
- (BOOL)deleteDirectory:(NSString *)directoryName;
- (NSArray *)listFilesInDirectory:(NSString *)directory;
- (NSArray *)listDirectories;
- (NSDictionary *)getDirectoryInfo:(NSString *)directory;

// 文件属性
- (NSDictionary *)getFileAttributes:(NSString *)fileName inDirectory:(NSString *)directory;
- (NSDate *)getFileModificationDate:(NSString *)fileName inDirectory:(NSString *)directory;
- (NSInteger)getFileSize:(NSString *)fileName inDirectory:(NSString *)directory;

// 存储优化
- (void)cleanupTemporaryFiles;
- (void)cleanupCacheFiles;
- (void)compressFile:(NSString *)fileName inDirectory:(NSString *)directory;
- (void)decompressFile:(NSString *)fileName inDirectory:(NSString *)directory;

// 存储监控
- (void)enableStorageMonitoring;
- (NSDictionary *)getStorageReport;
- (void)logStorageStatistics;
- (NSInteger)getTotalStorageSize;
- (NSInteger)getAvailableStorageSpace;

// 数据迁移
- (BOOL)migrateDataFromDirectory:(NSString *)sourceDirectory toDirectory:(NSString *)targetDirectory;
- (BOOL)backupDirectory:(NSString *)directory toPath:(NSString *)backupPath;
- (BOOL)restoreDirectoryFromBackup:(NSString *)backupPath toDirectory:(NSString *)directory;

@end

@implementation FileStorageManager

+ (instancetype)sharedManager {
    static FileStorageManager *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[self alloc] init];
    });
    return sharedInstance;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        self.fileManager = [NSFileManager defaultManager];
        self.storageMetrics = [NSMutableDictionary dictionary];
        self.fileQueue = dispatch_queue_create("com.filestorage.queue", DISPATCH_QUEUE_CONCURRENT);
        
        [self initializeStorageDirectories];
        [self configureStorageSettings];
    }
    return self;
}

- (void)initializeStorageDirectories {
    NSLog(@"=== 初始化文件存储目录 ===");
    
    // 获取标准目录路径
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    self.documentsPath = [paths firstObject];
    
    paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
    self.cachesPath = [paths firstObject];
    
    self.temporaryPath = NSTemporaryDirectory();
    
    NSLog(@"Documents目录: %@", self.documentsPath);
    NSLog(@"Caches目录: %@", self.cachesPath);
    NSLog(@"Temporary目录: %@", self.temporaryPath);
    
    // 创建自定义子目录
    [self createDirectory:@"UserData"];
    [self createDirectory:@"AppData"];
    [self createDirectory:@"Backups"];
    
    NSLog(@"文件存储目录初始化完成");
}

- (void)configureStorageSettings {
    NSLog(@"配置文件存储设置...");
    
    // 启用存储监控
    [self enableStorageMonitoring];
    
    // 清理临时文件
    [self cleanupTemporaryFiles];
    
    NSLog(@"文件存储设置配置完成");
}

- (NSString *)getStoragePathForType:(NSString *)storageType {
    if ([storageType isEqualToString:@"documents"]) {
        return self.documentsPath;
    } else if ([storageType isEqualToString:@"caches"]) {
        return self.cachesPath;
    } else if ([storageType isEqualToString:@"temporary"]) {
        return self.temporaryPath;
    }
    
    return self.documentsPath; // 默认返回Documents目录
}

- (BOOL)writeData:(NSData *)data toFile:(NSString *)fileName inDirectory:(NSString *)directory {
    NSDate *startTime = [NSDate date];
    
    __block BOOL success = NO;
    
    dispatch_barrier_sync(self.fileQueue, ^{
        NSString *fullPath = [self getFullPathForFile:fileName inDirectory:directory];
        
        // 确保目录存在
        NSString *directoryPath = [fullPath stringByDeletingLastPathComponent];
        [self.fileManager createDirectoryAtPath:directoryPath withIntermediateDirectories:YES attributes:nil error:nil];
        
        success = [data writeToFile:fullPath atomically:YES];
        
        if (success) {
            NSLog(@"文件写入成功: %@", fileName);
        } else {
            NSLog(@"文件写入失败: %@", fileName);
        }
    });
    
    // 记录性能指标
    NSTimeInterval duration = [[NSDate date] timeIntervalSinceDate:startTime];
    [self recordOperation:@"write" fileName:fileName duration:duration success:success dataSize:data.length];
    
    return success;
}

- (NSData *)readDataFromFile:(NSString *)fileName inDirectory:(NSString *)directory {
    NSDate *startTime = [NSDate date];
    
    __block NSData *data = nil;
    
    dispatch_sync(self.fileQueue, ^{
        NSString *fullPath = [self getFullPathForFile:fileName inDirectory:directory];
        
        if ([self.fileManager fileExistsAtPath:fullPath]) {
            data = [NSData dataWithContentsOfFile:fullPath];
            
            if (data) {
                NSLog(@"文件读取成功: %@, 大小: %lu bytes", fileName, (unsigned long)data.length);
            } else {
                NSLog(@"文件读取失败: %@", fileName);
            }
        } else {
            NSLog(@"文件不存在: %@", fileName);
        }
    });
    
    // 记录性能指标
    NSTimeInterval duration = [[NSDate date] timeIntervalSinceDate:startTime];
    [self recordOperation:@"read" fileName:fileName duration:duration success:(data != nil) dataSize:data.length];
    
    return data;
}

- (BOOL)deleteFile:(NSString *)fileName inDirectory:(NSString *)directory {
    __block BOOL success = NO;
    
    dispatch_barrier_sync(self.fileQueue, ^{
        NSString *fullPath = [self getFullPathForFile:fileName inDirectory:directory];
        
        if ([self.fileManager fileExistsAtPath:fullPath]) {
            NSError *error;
            success = [self.fileManager removeItemAtPath:fullPath error:&error];
            
            if (success) {
                NSLog(@"文件删除成功: %@", fileName);
            } else {
                NSLog(@"文件删除失败: %@, 错误: %@", fileName, error.localizedDescription);
            }
        } else {
            NSLog(@"文件不存在，无需删除: %@", fileName);
            success = YES; // 文件不存在也算删除成功
        }
    });
    
    return success;
}

- (BOOL)fileExists:(NSString *)fileName inDirectory:(NSString *)directory {
    NSString *fullPath = [self getFullPathForFile:fileName inDirectory:directory];
    return [self.fileManager fileExistsAtPath:fullPath];
}

- (NSString *)getFullPathForFile:(NSString *)fileName inDirectory:(NSString *)directory {
    NSString *basePath = [self getStoragePathForType:@"documents"];
    
    if (directory && directory.length > 0) {
        basePath = [basePath stringByAppendingPathComponent:directory];
    }
    
    return [basePath stringByAppendingPathComponent:fileName];
}

- (BOOL)saveObject:(id<NSCoding>)object toFile:(NSString *)fileName inDirectory:(NSString *)directory {
    if (!object) {
        NSLog(@"对象为空，无法保存");
        return NO;
    }
    
    NSDate *startTime = [NSDate date];
    
    @try {
        NSData *data = [NSKeyedArchiver archivedDataWithRootObject:object requiringSecureCoding:NO error:nil];
        
        if (data) {
            BOOL success = [self writeData:data toFile:fileName inDirectory:directory];
            
            NSTimeInterval duration = [[NSDate date] timeIntervalSinceDate:startTime];
            NSLog(@"对象序列化保存%@: %@, 耗时: %.3f秒", success ? @"成功" : @"失败", fileName, duration);
            
            return success;
        } else {
            NSLog(@"对象序列化失败: %@", fileName);
            return NO;
        }
    } @catch (NSException *exception) {
        NSLog(@"对象保存异常: %@, 异常: %@", fileName, exception.reason);
        return NO;
    }
}

- (id)loadObjectFromFile:(NSString *)fileName inDirectory:(NSString *)directory {
    NSDate *startTime = [NSDate date];
    
    NSData *data = [self readDataFromFile:fileName inDirectory:directory];
    
    if (!data) {
        return nil;
    }
    
    @try {
        id object = [NSKeyedUnarchiver unarchiveObjectWithData:data];
        
        NSTimeInterval duration = [[NSDate date] timeIntervalSinceDate:startTime];
        NSLog(@"对象反序列化%@: %@, 耗时: %.3f秒", object ? @"成功" : @"失败", fileName, duration);
        
        return object;
    } @catch (NSException *exception) {
        NSLog(@"对象加载异常: %@, 异常: %@", fileName, exception.reason);
        return nil;
    }
}

- (BOOL)saveJSONObject:(id)object toFile:(NSString *)fileName inDirectory:(NSString *)directory {
    if (!object) {
        NSLog(@"JSON对象为空，无法保存");
        return NO;
    }
    
    NSDate *startTime = [NSDate date];
    
    @try {
        NSError *error;
        NSData *jsonData = [NSJSONSerialization dataWithJSONObject:object options:NSJSONWritingPrettyPrinted error:&error];
        
        if (jsonData && !error) {
            BOOL success = [self writeData:jsonData toFile:fileName inDirectory:directory];
            
            NSTimeInterval duration = [[NSDate date] timeIntervalSinceDate:startTime];
            NSLog(@"JSON对象保存%@: %@, 耗时: %.3f秒", success ? @"成功" : @"失败", fileName, duration);
            
            return success;
        } else {
            NSLog(@"JSON序列化失败: %@, 错误: %@", fileName, error.localizedDescription);
            return NO;
        }
    } @catch (NSException *exception) {
        NSLog(@"JSON保存异常: %@, 异常: %@", fileName, exception.reason);
        return NO;
    }
}

- (id)loadJSONObjectFromFile:(NSString *)fileName inDirectory:(NSString *)directory {
    NSDate *startTime = [NSDate date];
    
    NSData *data = [self readDataFromFile:fileName inDirectory:directory];
    
    if (!data) {
        return nil;
    }
    
    @try {
        NSError *error;
        id object = [NSJSONSerialization JSONObjectWithData:data options:NSJSONReadingMutableContainers error:&error];
        
        if (object && !error) {
            NSTimeInterval duration = [[NSDate date] timeIntervalSinceDate:startTime];
            NSLog(@"JSON对象加载成功: %@, 耗时: %.3f秒", fileName, duration);
            return object;
        } else {
            NSLog(@"JSON反序列化失败: %@, 错误: %@", fileName, error.localizedDescription);
            return nil;
        }
    } @catch (NSException *exception) {
        NSLog(@"JSON加载异常: %@, 异常: %@", fileName, exception.reason);
        return nil;
    }
}

- (BOOL)batchWriteFiles:(NSArray *)fileDataArray toDirectory:(NSString *)directory {
    NSDate *startTime = [NSDate date];
    
    __block BOOL allSuccess = YES;
    __block NSInteger successCount = 0;
    
    dispatch_apply(fileDataArray.count, self.fileQueue, ^(size_t index) {
        NSDictionary *fileData = fileDataArray[index];
        NSString *fileName = fileData[@"fileName"];
        NSData *data = fileData[@"data"];
        
        if ([self writeData:data toFile:fileName inDirectory:directory]) {
            @synchronized(self) {
                successCount++;
            }
        } else {
            allSuccess = NO;
        }
    });
    
    NSTimeInterval duration = [[NSDate date] timeIntervalSinceDate:startTime];
    NSLog(@"批量写入文件完成: %ld/%lu 成功, 耗时: %.3f秒", (long)successCount, (unsigned long)fileDataArray.count, duration);
    
    return allSuccess;
}

- (NSArray *)batchReadFiles:(NSArray *)fileNames fromDirectory:(NSString *)directory {
    NSDate *startTime = [NSDate date];
    
    NSMutableArray *results = [NSMutableArray arrayWithCapacity:fileNames.count];
    
    // 初始化结果数组
    for (NSInteger i = 0; i < fileNames.count; i++) {
        [results addObject:[NSNull null]];
    }
    
    dispatch_apply(fileNames.count, self.fileQueue, ^(size_t index) {
        NSString *fileName = fileNames[index];
        NSData *data = [self readDataFromFile:fileName inDirectory:directory];
        
        @synchronized(results) {
            if (data) {
                results[index] = data;
            }
        }
    });
    
    NSTimeInterval duration = [[NSDate date] timeIntervalSinceDate:startTime];
    NSLog(@"批量读取文件完成: %lu 个文件, 耗时: %.3f秒", (unsigned long)fileNames.count, duration);
    
    return results;
}

- (BOOL)batchDeleteFiles:(NSArray *)fileNames fromDirectory:(NSString *)directory {
    NSDate *startTime = [NSDate date];
    
    __block BOOL allSuccess = YES;
    __block NSInteger successCount = 0;
    
    dispatch_apply(fileNames.count, self.fileQueue, ^(size_t index) {
        NSString *fileName = fileNames[index];
        
        if ([self deleteFile:fileName inDirectory:directory]) {
            @synchronized(self) {
                successCount++;
            }
        } else {
            allSuccess = NO;
        }
    });
    
    NSTimeInterval duration = [[NSDate date] timeIntervalSinceDate:startTime];
    NSLog(@"批量删除文件完成: %ld/%lu 成功, 耗时: %.3f秒", (long)successCount, (unsigned long)fileNames.count, duration);
    
    return allSuccess;
}

- (BOOL)createDirectory:(NSString *)directoryName {
    NSString *directoryPath = [self.documentsPath stringByAppendingPathComponent:directoryName];
    
    NSError *error;
    BOOL success = [self.fileManager createDirectoryAtPath:directoryPath withIntermediateDirectories:YES attributes:nil error:&error];
    
    if (success) {
        NSLog(@"目录创建成功: %@", directoryName);
    } else {
        NSLog(@"目录创建失败: %@, 错误: %@", directoryName, error.localizedDescription);
    }
    
    return success;
}

- (BOOL)deleteDirectory:(NSString *)directoryName {
    NSString *directoryPath = [self.documentsPath stringByAppendingPathComponent:directoryName];
    
    if ([self.fileManager fileExistsAtPath:directoryPath]) {
        NSError *error;
        BOOL success = [self.fileManager removeItemAtPath:directoryPath error:&error];
        
        if (success) {
            NSLog(@"目录删除成功: %@", directoryName);
        } else {
            NSLog(@"目录删除失败: %@, 错误: %@", directoryName, error.localizedDescription);
        }
        
        return success;
    } else {
        NSLog(@"目录不存在，无需删除: %@", directoryName);
        return YES;
    }
}

- (NSArray *)listFilesInDirectory:(NSString *)directory {
    NSString *directoryPath = directory ? [self.documentsPath stringByAppendingPathComponent:directory] : self.documentsPath;
    
    NSError *error;
    NSArray *contents = [self.fileManager contentsOfDirectoryAtPath:directoryPath error:&error];
    
    if (contents) {
        // 过滤出文件（排除目录）
        NSMutableArray *files = [NSMutableArray array];
        
        for (NSString *item in contents) {
            NSString *itemPath = [directoryPath stringByAppendingPathComponent:item];
            BOOL isDirectory;
            
            if ([self.fileManager fileExistsAtPath:itemPath isDirectory:&isDirectory] && !isDirectory) {
                [files addObject:item];
            }
        }
        
        NSLog(@"目录 %@ 包含 %lu 个文件", directory ?: @"根目录", (unsigned long)files.count);
        return files;
    } else {
        NSLog(@"列出文件失败: %@, 错误: %@", directory, error.localizedDescription);
        return @[];
    }
}

- (NSArray *)listDirectories {
    NSError *error;
    NSArray *contents = [self.fileManager contentsOfDirectoryAtPath:self.documentsPath error:&error];
    
    if (contents) {
        NSMutableArray *directories = [NSMutableArray array];
        
        for (NSString *item in contents) {
            NSString *itemPath = [self.documentsPath stringByAppendingPathComponent:item];
            BOOL isDirectory;
            
            if ([self.fileManager fileExistsAtPath:itemPath isDirectory:&isDirectory] && isDirectory) {
                [directories addObject:item];
            }
        }
        
        NSLog(@"根目录包含 %lu 个子目录", (unsigned long)directories.count);
        return directories;
    } else {
        NSLog(@"列出目录失败, 错误: %@", error.localizedDescription);
        return @[];
    }
}

- (NSDictionary *)getDirectoryInfo:(NSString *)directory {
    NSString *directoryPath = directory ? [self.documentsPath stringByAppendingPathComponent:directory] : self.documentsPath;
    
    NSMutableDictionary *info = [NSMutableDictionary dictionary];
    
    // 基本信息
    info[@"path"] = directoryPath;
    info[@"name"] = directory ?: @"根目录";
    
    // 文件和目录数量
    NSArray *files = [self listFilesInDirectory:directory];
    NSArray *subdirectories = directory ? @[] : [self listDirectories]; // 简化处理
    
    info[@"fileCount"] = @(files.count);
    info[@"directoryCount"] = @(subdirectories.count);
    
    // 计算总大小
    NSInteger totalSize = 0;
    for (NSString *fileName in files) {
        totalSize += [self getFileSize:fileName inDirectory:directory];
    }
    
    info[@"totalSize"] = @(totalSize);
    info[@"totalSizeMB"] = @(totalSize / 1024.0 / 1024.0);
    
    return info;
}

- (NSDictionary *)getFileAttributes:(NSString *)fileName inDirectory:(NSString *)directory {
    NSString *fullPath = [self getFullPathForFile:fileName inDirectory:directory];
    
    NSError *error;
    NSDictionary *attributes = [self.fileManager attributesOfItemAtPath:fullPath error:&error];
    
    if (attributes) {
        return attributes;
    } else {
        NSLog(@"获取文件属性失败: %@, 错误: %@", fileName, error.localizedDescription);
        return @{};
    }
}

- (NSDate *)getFileModificationDate:(NSString *)fileName inDirectory:(NSString *)directory {
    NSDictionary *attributes = [self getFileAttributes:fileName inDirectory:directory];
    return attributes[NSFileModificationDate];
}

- (NSInteger)getFileSize:(NSString *)fileName inDirectory:(NSString *)directory {
    NSDictionary *attributes = [self getFileAttributes:fileName inDirectory:directory];
    return [attributes[NSFileSize] integerValue];
}

- (void)cleanupTemporaryFiles {
    NSLog(@"清理临时文件...");
    
    NSError *error;
    NSArray *tempFiles = [self.fileManager contentsOfDirectoryAtPath:self.temporaryPath error:&error];
    
    NSInteger deletedCount = 0;
    NSInteger deletedSize = 0;
    
    for (NSString *fileName in tempFiles) {
        NSString *filePath = [self.temporaryPath stringByAppendingPathComponent:fileName];
        
        // 获取文件大小
        NSDictionary *attributes = [self.fileManager attributesOfItemAtPath:filePath error:nil];
        NSInteger fileSize = [attributes[NSFileSize] integerValue];
        
        if ([self.fileManager removeItemAtPath:filePath error:nil]) {
            deletedCount++;
            deletedSize += fileSize;
        }
    }
    
    NSLog(@"临时文件清理完成: 删除 %ld 个文件, 释放 %.2f MB", (long)deletedCount, deletedSize / 1024.0 / 1024.0);
}

- (void)cleanupCacheFiles {
    NSLog(@"清理缓存文件...");
    
    NSError *error;
    NSArray *cacheFiles = [self.fileManager contentsOfDirectoryAtPath:self.cachesPath error:&error];
    
    NSInteger deletedCount = 0;
    NSInteger deletedSize = 0;
    NSDate *cutoffDate = [NSDate dateWithTimeIntervalSinceNow:-7 * 24 * 60 * 60]; // 7天前
    
    for (NSString *fileName in cacheFiles) {
        NSString *filePath = [self.cachesPath stringByAppendingPathComponent:fileName];
        
        NSDictionary *attributes = [self.fileManager attributesOfItemAtPath:filePath error:nil];
        NSDate *modificationDate = attributes[NSFileModificationDate];
        NSInteger fileSize = [attributes[NSFileSize] integerValue];
        
        // 删除7天前的缓存文件
        if ([modificationDate compare:cutoffDate] == NSOrderedAscending) {
            if ([self.fileManager removeItemAtPath:filePath error:nil]) {
                deletedCount++;
                deletedSize += fileSize;
            }
        }
    }
    
    NSLog(@"缓存文件清理完成: 删除 %ld 个文件, 释放 %.2f MB", (long)deletedCount, deletedSize / 1024.0 / 1024.0);
}

- (void)compressFile:(NSString *)fileName inDirectory:(NSString *)directory {
    NSLog(@"压缩文件: %@", fileName);
    
    NSData *originalData = [self readDataFromFile:fileName inDirectory:directory];
    
    if (originalData) {
        NSData *compressedData = [originalData compressedDataUsingAlgorithm:NSDataCompressionAlgorithmZlib error:nil];
        
        if (compressedData) {
            NSString *compressedFileName = [fileName stringByAppendingString:@".compressed"];
            
            if ([self writeData:compressedData toFile:compressedFileName inDirectory:directory]) {
                double compressionRatio = (double)compressedData.length / originalData.length;
                NSLog(@"文件压缩成功: %@, 压缩率: %.1f%%", fileName, compressionRatio * 100);
            }
        }
    }
}

- (void)decompressFile:(NSString *)fileName inDirectory:(NSString *)directory {
    NSLog(@"解压缩文件: %@", fileName);
    
    NSData *compressedData = [self readDataFromFile:fileName inDirectory:directory];
    
    if (compressedData) {
        NSData *decompressedData = [compressedData decompressedDataUsingAlgorithm:NSDataCompressionAlgorithmZlib error:nil];
        
        if (decompressedData) {
            NSString *decompressedFileName = [fileName stringByReplacingOccurrencesOfString:@".compressed" withString:@""];
            
            if ([self writeData:decompressedData toFile:decompressedFileName inDirectory:directory]) {
                NSLog(@"文件解压缩成功: %@", fileName);
            }
        }
    }
}

- (void)recordOperation:(NSString *)operation fileName:(NSString *)fileName duration:(NSTimeInterval)duration success:(BOOL)success dataSize:(NSInteger)dataSize {
    NSDictionary *metric = @{
        @"operation": operation,
        @"fileName": fileName ?: @"",
        @"duration": @(duration),
        @"success": @(success),
        @"dataSize": @(dataSize),
        @"timestamp": [NSDate date]
    };
    
    @synchronized(self.storageMetrics) {
        if (!self.storageMetrics[@"operations"]) {
            self.storageMetrics[@"operations"] = [NSMutableArray array];
        }
        
        [self.storageMetrics[@"operations"] addObject:metric];
        
        // 保持最近1000条记录
        NSMutableArray *operations = self.storageMetrics[@"operations"];
        if (operations.count > 1000) {
            [operations removeObjectAtIndex:0];
        }
    }
}

- (void)enableStorageMonitoring {
    NSLog(@"启用文件存储监控...");
    
    // 初始化监控数据
    self.storageMetrics[@"startTime"] = [NSDate date];
    self.storageMetrics[@"operations"] = [NSMutableArray array];
    
    NSLog(@"文件存储监控启用完成");
}

- (NSDictionary *)getStorageReport {
    NSMutableDictionary *report = [NSMutableDictionary dictionary];
    
    @synchronized(self.storageMetrics) {
        NSArray *operations = self.storageMetrics[@"operations"];
        
        // 统计各种操作的性能
        NSMutableDictionary *operationStats = [NSMutableDictionary dictionary];
        
        for (NSDictionary *metric in operations) {
            NSString *operation = metric[@"operation"];
            NSNumber *duration = metric[@"duration"];
            NSNumber *success = metric[@"success"];
            NSNumber *dataSize = metric[@"dataSize"];
            
            if (!operationStats[operation]) {
                operationStats[operation] = [NSMutableDictionary dictionary];
                operationStats[operation][@"durations"] = [NSMutableArray array];
                operationStats[operation][@"dataSizes"] = [NSMutableArray array];
                operationStats[operation][@"successCount"] = @0;
                operationStats[operation][@"totalCount"] = @0;
            }
            
            [operationStats[operation][@"durations"] addObject:duration];
            [operationStats[operation][@"dataSizes"] addObject:dataSize];
            operationStats[operation][@"totalCount"] = @([operationStats[operation][@"totalCount"] integerValue] + 1);
            
            if ([success boolValue]) {
                operationStats[operation][@"successCount"] = @([operationStats[operation][@"successCount"] integerValue] + 1);
            }
        }
        
        // 计算统计信息
        for (NSString *operation in operationStats) {
            NSArray *durations = operationStats[operation][@"durations"];
            NSArray *dataSizes = operationStats[operation][@"dataSizes"];
            NSInteger successCount = [operationStats[operation][@"successCount"] integerValue];
            NSInteger totalCount = [operationStats[operation][@"totalCount"] integerValue];
            
            double totalDuration = 0;
            double maxDuration = 0;
            double minDuration = INFINITY;
            
            NSInteger totalDataSize = 0;
            
            for (NSNumber *duration in durations) {
                double d = [duration doubleValue];
                totalDuration += d;
                maxDuration = MAX(maxDuration, d);
                minDuration = MIN(minDuration, d);
            }
            
            for (NSNumber *dataSize in dataSizes) {
                totalDataSize += [dataSize integerValue];
            }
            
            double averageDuration = totalDuration / durations.count;
            double successRate = (double)successCount / totalCount;
            double averageDataSize = (double)totalDataSize / dataSizes.count;
            
            report[operation] = @{
                @"operationCount": @(totalCount),
                @"successRate": @(successRate),
                @"averageDuration": @(averageDuration),
                @"maxDuration": @(maxDuration),
                @"minDuration": @(minDuration == INFINITY ? 0 : minDuration),
                @"totalDuration": @(totalDuration),
                @"totalDataSize": @(totalDataSize),
                @"averageDataSize": @(averageDataSize)
            };
        }
        
        report[@"totalOperations"] = @(operations.count);
        report[@"reportTimestamp"] = [NSDate date];
        report[@"monitoringStartTime"] = self.storageMetrics[@"startTime"];
    }
    
    // 添加存储空间信息
    report[@"storageInfo"] = @{
        @"totalStorageSize": @([self getTotalStorageSize]),
        @"availableSpace": @([self getAvailableStorageSpace]),
        @"documentsSize": @([[self getDirectoryInfo:nil][@"totalSize"] integerValue]),
        @"cachesSize": @([[self getDirectoryInfo:@"../Caches"][@"totalSize"] integerValue])
    };
    
    return report;
}

- (void)logStorageStatistics {
    NSLog(@"=== 文件存储统计信息 ===");
    
    NSDictionary *report = [self getStorageReport];
    
    // 操作统计
    for (NSString *operation in report) {
        if ([operation isEqualToString:@"totalOperations"] || 
            [operation isEqualToString:@"reportTimestamp"] ||
            [operation isEqualToString:@"monitoringStartTime"] ||
            [operation isEqualToString:@"storageInfo"]) {
            continue;
        }
        
        NSDictionary *stats = report[operation];
        NSLog(@"操作类型: %@", operation);
        NSLog(@"  操作次数: %@", stats[@"operationCount"]);
        NSLog(@"  成功率: %.1f%%", [stats[@"successRate"] doubleValue] * 100);
        NSLog(@"  平均耗时: %.3f秒", [stats[@"averageDuration"] doubleValue]);
        NSLog(@"  平均数据大小: %.2f KB", [stats[@"averageDataSize"] doubleValue] / 1024.0);
    }
    
    // 存储空间统计
    NSDictionary *storageInfo = report[@"storageInfo"];
    NSLog(@"存储空间信息:");
    NSLog(@"  总存储大小: %.2f GB", [storageInfo[@"totalStorageSize"] doubleValue] / 1024.0 / 1024.0 / 1024.0);
    NSLog(@"  可用空间: %.2f GB", [storageInfo[@"availableSpace"] doubleValue] / 1024.0 / 1024.0 / 1024.0);
    NSLog(@"  Documents大小: %.2f MB", [storageInfo[@"documentsSize"] doubleValue] / 1024.0 / 1024.0);
    NSLog(@"  Caches大小: %.2f MB", [storageInfo[@"cachesSize"] doubleValue] / 1024.0 / 1024.0);
}

- (NSInteger)getTotalStorageSize {
    NSError *error;
    NSDictionary *attributes = [self.fileManager attributesOfFileSystemForPath:self.documentsPath error:&error];
    
    if (attributes) {
        return [attributes[NSFileSystemSize] integerValue];
    }
    
    return 0;
}

- (NSInteger)getAvailableStorageSpace {
    NSError *error;
    NSDictionary *attributes = [self.fileManager attributesOfFileSystemForPath:self.documentsPath error:&error];
    
    if (attributes) {
        return [attributes[NSFileSystemFreeSize] integerValue];
    }
    
    return 0;
}

- (BOOL)migrateDataFromDirectory:(NSString *)sourceDirectory toDirectory:(NSString *)targetDirectory {
    NSLog(@"数据迁移: %@ -> %@", sourceDirectory, targetDirectory);
    
    NSString *sourcePath = [self.documentsPath stringByAppendingPathComponent:sourceDirectory];
    NSString *targetPath = [self.documentsPath stringByAppendingPathComponent:targetDirectory];
    
    // 创建目标目录
    [self createDirectory:targetDirectory];
    
    // 获取源目录中的所有文件
    NSArray *files = [self listFilesInDirectory:sourceDirectory];
    
    NSInteger successCount = 0;
    
    for (NSString *fileName in files) {
        NSString *sourceFilePath = [sourcePath stringByAppendingPathComponent:fileName];
        NSString *targetFilePath = [targetPath stringByAppendingPathComponent:fileName];
        
        NSError *error;
        if ([self.fileManager copyItemAtPath:sourceFilePath toPath:targetFilePath error:&error]) {
            successCount++;
        } else {
            NSLog(@"文件迁移失败: %@, 错误: %@", fileName, error.localizedDescription);
        }
    }
    
    BOOL success = (successCount == files.count);
    NSLog(@"数据迁移%@: %ld/%lu 文件成功", success ? @"成功" : @"部分成功", (long)successCount, (unsigned long)files.count);
    
    return success;
}

- (BOOL)backupDirectory:(NSString *)directory toPath:(NSString *)backupPath {
    NSLog(@"备份目录: %@ -> %@", directory, backupPath);
    
    NSString *sourcePath = directory ? [self.documentsPath stringByAppendingPathComponent:directory] : self.documentsPath;
    
    NSError *error;
    
    // 确保备份目录的父目录存在
    NSString *backupParentDirectory = [backupPath stringByDeletingLastPathComponent];
    [self.fileManager createDirectoryAtPath:backupParentDirectory withIntermediateDirectories:YES attributes:nil error:nil];
    
    // 复制整个目录
    BOOL success = [self.fileManager copyItemAtPath:sourcePath toPath:backupPath error:&error];
    
    if (success) {
        NSLog(@"目录备份成功");
    } else {
        NSLog(@"目录备份失败: %@", error.localizedDescription);
    }
    
    return success;
}

- (BOOL)restoreDirectoryFromBackup:(NSString *)backupPath toDirectory:(NSString *)directory {
    NSLog(@"从备份恢复目录: %@ -> %@", backupPath, directory);
    
    if (![self.fileManager fileExistsAtPath:backupPath]) {
        NSLog(@"备份路径不存在: %@", backupPath);
        return NO;
    }
    
    NSString *targetPath = directory ? [self.documentsPath stringByAppendingPathComponent:directory] : self.documentsPath;
    
    // 删除现有目录
    if ([self.fileManager fileExistsAtPath:targetPath]) {
        [self.fileManager removeItemAtPath:targetPath error:nil];
    }
    
    // 从备份恢复
    NSError *error;
    BOOL success = [self.fileManager copyItemAtPath:backupPath toPath:targetPath error:&error];
    
    if (success) {
        NSLog(@"目录恢复成功");
    } else {
        NSLog(@"目录恢复失败: %@", error.localizedDescription);
    }
    
    return success;
}

@end