import Foundation

// 解压缩tar.gz文件的示例
func extractTarGz(from sourcePath: String, to destinationPath: String) -> Bool {
    // 创建解压缩句柄
    guard let archive = archive_read_new() else {
        print("无法创建archive读取句柄")
        return false
    }
    defer {
        archive_read_free(archive)
    }
    
    // 设置过滤器和格式
    archive_read_support_filter_all(archive)
    archive_read_support_format_all(archive)
    
    // 创建写入句柄
    guard let ext = archive_write_disk_new() else {
        print("无法创建archive写入句柄")
        return false
    }
    defer {
        archive_write_free(ext)
    }
    
    // 设置写入选项
    let flags = ARCHIVE_EXTRACT_TIME | ARCHIVE_EXTRACT_PERM | ARCHIVE_EXTRACT_ACL | ARCHIVE_EXTRACT_FFLAGS
    archive_write_disk_set_options(ext, Int32(flags))
    archive_write_disk_set_standard_lookup(ext)
    
    // 打开源文件
    if archive_read_open_filename(archive, sourcePath, 10240) != ARCHIVE_OK {
        print("无法打开源文件: \(String(cString: archive_error_string(archive)))")
        return false
    }
    
    // 解压文件
    var result = true
    var entry: OpaquePointer?
    
    while true {
        let readResult = archive_read_next_header(archive, &entry)
        if readResult == ARCHIVE_EOF {
            break
        }
        
        if readResult != ARCHIVE_OK {
            print("读取头信息失败: \(String(cString: archive_error_string(archive)))")
            result = false
            break
        }
        
        // 设置解压路径
        let entryPath = String(cString: archive_entry_pathname(entry))
        let fullPath = (destinationPath as NSString).appendingPathComponent(entryPath)
        archive_entry_set_pathname(entry, fullPath)
        
        // 写入磁盘
        if archive_write_header(ext, entry) != ARCHIVE_OK {
            print("写入头信息失败: \(String(cString: archive_error_string(ext)))")
            result = false
            break
        }
        
        // 复制数据
        if archive_entry_size(entry) > 0 {
            result = copyData(from: archive, to: ext)
            if !result {
                break
            }
        }
        
        // 完成写入
        if archive_write_finish_entry(ext) != ARCHIVE_OK {
            print("完成条目写入失败: \(String(cString: archive_error_string(ext)))")
            result = false
            break
        }
    }
    
    return result
}

// 从源复制数据到目标
private func copyData(from archive: OpaquePointer, to ext: OpaquePointer) -> Bool {
    var buffer: UnsafeRawPointer?
    var size: Int = 0
    var offset: Int64 = 0
    
    while true {
        let result = archive_read_data_block(archive, &buffer, &size, &offset)
        
        if result == ARCHIVE_EOF {
            return true
        }
        
        if result != ARCHIVE_OK {
            print("读取数据块失败: \(String(cString: archive_error_string(archive)))")
            return false
        }
        
        if archive_write_data_block(ext, buffer, size, offset) != ARCHIVE_OK {
            print("写入数据块失败: \(String(cString: archive_error_string(ext)))")
            return false
        }
    }
}

// 使用示例
func example() {
    let sourcePath = "/path/to/archive.tar.gz"
    let destinationPath = "/path/to/extract"
    
    if extractTarGz(from: sourcePath, to: destinationPath) {
        print("解压成功")
    } else {
        print("解压失败")
    }
}

import Foundation

// 创建tar.gz文件的示例
func createTarGz(from sourcePath: String, to destinationPath: String) -> Bool {
    // 创建写入句柄
    guard let archive = archive_write_new() else {
        print("无法创建archive写入句柄")
        return false
    }
    defer {
        archive_write_free(archive)
    }
    
    // 设置压缩格式和过滤器
    archive_write_add_filter_gzip(archive)
    archive_write_set_format_pax_restricted(archive)
    
    // 打开目标文件
    if archive_write_open_filename(archive, destinationPath) != ARCHIVE_OK {
        print("无法打开目标文件: \(String(cString: archive_error_string(archive)))")
        return false
    }
    
    // 添加文件到归档
    let fileManager = FileManager.default
    var isDir: ObjCBool = false
    
    if fileManager.fileExists(atPath: sourcePath, isDirectory: &isDir) {
        if isDir.boolValue {
            // 添加目录
            return addDirectoryToArchive(archive, path: sourcePath, basePath: (sourcePath as NSString).deletingLastPathComponent)
        } else {
            // 添加单个文件
            return addFileToArchive(archive, path: sourcePath, basePath: (sourcePath as NSString).deletingLastPathComponent)
        }
    }
    
    return false
}

// 添加目录到归档
private func addDirectoryToArchive(_ archive: OpaquePointer, path: String, basePath: String) -> Bool {
    let fileManager = FileManager.default
    
    do {
        let contents = try fileManager.contentsOfDirectory(atPath: path)
        
        for item in contents {
            let fullPath = (path as NSString).appendingPathComponent(item)
            var isDir: ObjCBool = false
            
            if fileManager.fileExists(atPath: fullPath, isDirectory: &isDir) {
                if isDir.boolValue {
                    // 递归添加子目录
                    if !addDirectoryToArchive(archive, path: fullPath, basePath: basePath) {
                        return false
                    }
                } else {
                    // 添加文件
                    if !addFileToArchive(archive, path: fullPath, basePath: basePath) {
                        return false
                    }
                }
            }
        }
        
        return true
    } catch {
        print("读取目录内容失败: \(error.localizedDescription)")
        return false
    }
}

// 添加文件到归档
private func addFileToArchive(_ archive: OpaquePointer, path: String, basePath: String) -> Bool {
    // 创建条目
    guard let entry = archive_entry_new() else {
        print("无法创建archive条目")
        return false
    }
    defer {
        archive_entry_free(entry)
    }
    
    // 获取文件信息
    var stat = stat()
    if lstat(path, &stat) != 0 {
        print("无法获取文件信息")
        return false
    }
    
    // 设置条目信息
    archive_entry_set_size(entry, Int64(stat.st_size))
    archive_entry_set_mode(entry, UInt32(stat.st_mode))
    archive_entry_set_mtime(entry, Int64(stat.st_mtime), 0)
    
    // 设置相对路径
    let relativePath = path.replacingOccurrences(of: basePath, with: "")
    let entryPath = relativePath.hasPrefix("/") ? String(relativePath.dropFirst()) : relativePath
    archive_entry_set_pathname(entry, entryPath)
    
    // 写入头信息
    if archive_write_header(archive, entry) != ARCHIVE_OK {
        print("写入头信息失败: \(String(cString: archive_error_string(archive)))")
        return false
    }
    
    // 写入文件内容
    if stat.st_size > 0 {
        guard let file = fopen(path, "rb") else {
            print("无法打开文件")
            return false
        }
        defer {
            fclose(file)
        }
        
        let bufferSize = 8192
        let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
        defer {
            buffer.deallocate()
        }
        
        while true {
            let bytesRead = fread(buffer, 1, bufferSize, file)
            if bytesRead == 0 {
                break
            }
            
            let bytesWritten = archive_write_data(archive, buffer, bytesRead)
            if bytesWritten < 0 || bytesWritten != bytesRead {
                print("写入数据失败")
                return false
            }
        }
    }
    
    return true
}

// 使用示例
func example() {
    let sourcePath = "/path/to/directory"
    let destinationPath = "/path/to/archive.tar.gz"
    
    if createTarGz(from: sourcePath, to: destinationPath) {
        print("创建归档成功")
    } else {
        print("创建归档失败")
    }
}