25 · FileManager와 파일 I/O

let docs = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)
let caches = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)
let appSupport = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)
print("docs:", docs)
print("caches:", caches)
print("appSupport:", appSupport)

// 실행 결과 (비샌드박스 macOS — iOS 컨테이너와 매핑 루트만 다르다)
// docs: [file:///Users/xxx/Documents/]
// caches: [file:///Users/xxx/Library/Caches/]
// appSupport: [file:///Users/xxx/Library/Application%20Support/]

func offlineAssetDirectory() throws -> URL {
    let support = try FileManager.default.url(
        for: .applicationSupportDirectory, in: .userDomainMask,
        appropriateFor: nil, create: true)
    // 번들 ID로 이름 지어 시스템이 나중에 만들 폴더와 충돌을 피한다
    let dir = support.appendingPathComponent(
        Bundle.main.bundleIdentifier ?? "app", isDirectory: true)
    try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
    return dir
}

func thumbnailURL(for id: String) throws -> URL {
    let caches = try FileManager.default.url(
        for: .cachesDirectory, in: .userDomainMask,
        appropriateFor: nil, create: true)
    return caches.appendingPathComponent("\(id).thumb.jpg")
}

func loadThumbnail(for id: String) throws -> Data {
    let url = try thumbnailURL(for: id)
    if let cached = try? Data(contentsOf: url) { return cached }
    // 시스템이 퍼지했거나 처음 요청 — 원본에서 다시 만든다
    let regenerated = try regenerateThumbnail(for: id)
    try? regenerated.write(to: url)
    return regenerated
}

FileManager.default.createFile(atPath: f.path, contents: Data("v1".utf8),
    attributes: [.protectionKey: FileProtectionType.completeUnlessOpen])
try (f as NSURL).setResourceValue(true, forKey: .isExcludedFromBackupKey)

try Data("v2-atomic-overwrite".utf8).write(to: f, options: .atomic)

let after = try FileManager.default.attributesOfItem(atPath: f.path)[.protectionKey] as! FileProtectionType
print("atomic 후 protectionKey:", after.rawValue)
// atomic 후 protectionKey: NSFileProtectionCompleteUntilFirstUserAuthentication  (기본값으로 리셋됨)

let excludedAfter = try (f as NSURL).resourceValues(forKeys: [.isExcludedFromBackupKey])[.isExcludedFromBackupKey] as? Bool
print("atomic 후 isExcludedFromBackup:", excludedAfter as Any)
// atomic 후 isExcludedFromBackup: Optional(false)  (역시 리셋됨)

func safeReplace(original: URL, withContentsOf tempURL: URL) throws {
    // 생성일 · 권한 · Finder 라벨 · Spotlight 코멘트를 기본으로 보존한다
    // 단, original과 temp는 반드시 같은 볼륨에 있어야 한다
    _ = try FileManager.default.replaceItemAt(original, withItemAt: tempURL)
}

func writeProtectedAtomic(_ data: Data, to url: URL) throws {
    try data.write(to: url, options: .atomic)
    // .atomic은 새 파일을 만드는 구조라 보호 클래스·백업 제외 표시가
    // 기본값으로 되돌아간다 — 매번 다시 걸어야 한다
    try FileManager.default.setAttributes(
        [.protectionKey: FileProtectionType.completeUnlessOpen],
        ofItemAtPath: url.path)
    var mutableURL = url
    var values = URLResourceValues()
    values.isExcludedFromBackup = true
    try mutableURL.setResourceValues(values)
}

FileManager.default.createFile(atPath: f3.path, contents: Data("secret".utf8),
    attributes: [.protectionKey: FileProtectionType.completeUnlessOpen])
let attrs = try FileManager.default.attributesOfItem(atPath: f3.path)
print("protectionKey attr:", attrs[.protectionKey] as Any)
// protectionKey attr: Optional(NSFileProtectionCompleteUnlessOpen)

var url3 = f3
let prot = try url3.resourceValues(forKeys: [.fileProtectionKey])
print("URLResourceValues.fileProtection readback:", prot.fileProtection as Any)
// URLResourceValues.fileProtection readback: Optional(__C.NSURLFileProtectionType(_rawValue: NSURLFileProtectionCompleteUnlessOpen))

try FileManager.default.setAttributes(
    [.protectionKey: FileProtectionType.completeUnlessOpen],
    ofItemAtPath: backgroundCacheURL.path)
// 트레이드오프: 파일이 열려 있는 동안엔 보호가 약해진다.
// 그래도 완전 무보호(.none)보다는 낫다 — 닫혀 있을 때는 여전히 암호화된다.

func readSensitiveFileIfUnlocked(at url: URL) -> Data? {
    do {
        return try Data(contentsOf: url)
    } catch {
        // 재부팅 직후 언락 전이면 여기로 떨어진다 — 크래시 대신 스킵하고
        // 다음 백그라운드 실행 기회(또는 포그라운드 진입)에 다시 시도한다
        return nil
    }
}

let reader = try FileHandle(forReadingFrom: bigFile)
let chunkSize = 64 * 1024
var totalRead = 0, chunkCount = 0
while let chunk = try reader.read(upToCount: chunkSize), !chunk.isEmpty {
    totalRead += chunk.count
    chunkCount += 1
}
print("totalRead:", totalRead, "chunkCount:", chunkCount)
// file size: 10485760
// totalRead: 10485760 chunkCount: 160   (10,485,760 / 65,536 = 160, 정확히 맞아떨어짐)

while true {
    let chunk = try reader.read(upToCount: 30)
    print("chunk:", chunk.map { "\($0.count) bytes" } ?? "nil")
    if chunk == nil { break }
}
// chunk: 30 bytes
// chunk: 30 bytes
// chunk: 30 bytes
// chunk: 10 bytes   (마지막 자투리)
// chunk: nil        ← 문서의 "빈 NSData"가 아니라 nil이 EOF 신호다

func streamingByteSum(of url: URL, chunkSize: Int = 64 * 1024) throws -> Int {
    let handle = try FileHandle(forReadingFrom: url)
    defer { try? handle.close() }
    var sum = 0
    // chunk == nil 이 진짜 EOF — 빈 Data와 혼동하지 않는다
    while let chunk = try handle.read(upToCount: chunkSize), !chunk.isEmpty {
        for byte in chunk { sum = (sum &+ Int(byte)) &+ 1 }
    }
    return sum
}

let queue = DispatchQueue(label: "io.chunked-reader")
let fd = open(url.path, O_RDONLY)
let channel = DispatchIO(type: .stream, fileDescriptor: fd, queue: queue) { _ in close(fd) }
channel.setLimit(lowWater: 64 * 1024)   // 이만큼 모이기 전엔 핸들러를 안 부른다 — 백프레셔

channel.read(offset: 0, length: Int.max, queue: queue) { done, data, error in
    guard error == 0 else { return }
    // data가 채워질 때마다 이 큐에서 호출된다 — 런루프도, 델리게이트도 필요 없다
    if done { /* 스트림 종료 처리 */ }
}

var url1 = f1
var values = URLResourceValues()
values.isExcludedFromBackup = true
try url1.setResourceValues(values)
let readBack = try url1.resourceValues(forKeys: [.isExcludedFromBackupKey])
print("isExcludedFromBackup readback:", readBack.isExcludedFromBackup as Any)
// isExcludedFromBackup readback: Optional(true)

func makeExcludedSupportDirectory() throws -> URL {
    let library = try FileManager.default.url(
        for: .libraryDirectory, in: .userDomainMask,
        appropriateFor: nil, create: true)
    var dir = library.appendingPathComponent(
        Bundle.main.bundleIdentifier ?? "app", isDirectory: true)
    try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
    var values = URLResourceValues()
    values.isExcludedFromBackup = true
    try dir.setResourceValues(values)
    return dir
}

func saveExcludingFromBackup(_ data: Data, to url: URL) throws {
    try data.write(to: url)
    var mutableURL = url
    var values = URLResourceValues()
    values.isExcludedFromBackup = true
    // 파일 연산 후엔 리셋될 수 있으므로 저장 경로 안에서 항상 다시 건다 (Q2 참고)
    try mutableURL.setResourceValues(values)
}