// SPDX-License-Identifier: GPL-3.0-or-later import Foundation import Combine // Catalog releases are immutable reference data. This independent, atomic file // retains personal choices across catalog replacements, including IDs absent // from a later catalog. Installation receipts are reconciled into it without editing SQLite. @MainActor final class SoftwareLibraryState: ObservableObject { struct Installation: Codable, Equatable, Sendable { let releaseID: String let packageSHA256: String let installedAt: Date let workingDirectory: URL } private struct Document: Codable, Sendable { var version = 1 var favoriteTitleIDs: Set = [] var preferredReleaseIDs: [String: String] = [:] var installedReleases: [String: Installation] = [:] } @Published private(set) var favoriteTitleIDs: Set = [] @Published private(set) var preferredReleaseIDs: [String: String] = [:] @Published private(set) var installedReleases: [String: Installation] = [:] @Published private(set) var saveError: String? let directory: URL private let fileURL: URL private let queue = DispatchQueue(label: "com.brianholman.vccplus.library-state", qos: .utility) private var companion: (any CompanionLibraryAccess)? private var remoteSave: Task? private var maySave = true private var revision = 0 init(directory: URL) { self.directory = directory fileURL = directory.appendingPathComponent("LibraryState.json") do { guard FileManager.default.fileExists(atPath: fileURL.path) else { return } let file = try FileHandle(forReadingFrom: fileURL) defer { try? file.close() } let data = try file.read(upToCount: 1_048_577) ?? Data() guard data.count <= 1_048_576 else { throw StateFailure.invalid } let document = try JSONDecoder().decode(Document.self, from: data) guard document.version == 1, document.favoriteTitleIDs.allSatisfy(Self.validID), document.preferredReleaseIDs.allSatisfy({ Self.validID($0.key) && Self.validID($0.value) }), document.installedReleases.allSatisfy({ key, entry in key == entry.releaseID && Self.validID(key) && entry.packageSHA256.count == 64 && entry.packageSHA256.allSatisfy(\.isHexDigit) && entry.workingDirectory.isFileURL }) else { throw StateFailure.invalid } favoriteTitleIDs = document.favoriteTitleIDs preferredReleaseIDs = document.preferredReleaseIDs installedReleases = document.installedReleases } catch { maySave = false // Preserve unreadable/newer state rather than overwriting it. saveError = "Your saved Library choices could not be read. The original file has been preserved at \(fileURL.path). \(error.localizedDescription)" } } /// In-memory presentation only. All persistence stays in VCC Plus. init(companion: any CompanionLibraryAccess) { self.companion = companion directory = FileManager.default.temporaryDirectory.appendingPathComponent("VCCCompanionPresentation", isDirectory: true) fileURL = directory.appendingPathComponent("Unused.json") } func applyRemoteSnapshot(_ snapshot: CompanionLibrarySnapshot) { let visible = snapshot.catalog.companionDisksOnly let titles = Set(visible.titles.map(\.id)), releases = Set(visible.releases.map(\.id)) favoriteTitleIDs = snapshot.favorites.intersection(titles) preferredReleaseIDs = snapshot.preferredReleaseIDs.filter { titles.contains($0.key) && releases.contains($0.value) } installedReleases = Dictionary(snapshot.installations.filter { releases.contains($0.releaseID) }.map { ($0.releaseID, $0) }, uniquingKeysWith: { _, last in last }) saveError = nil } private func sendRemote(_ request: CompanionLibraryRequest) { guard let companion else { return } revision += 1 let revision = revision, previous = remoteSave remoteSave = Task { [weak self] in await previous?.value do { let response = try await companion.libraryRequest(request) if let message = response.errorMessage { throw CompanionLibraryFailure(message: message) } guard let self, self.revision == revision else { return } if let snapshot = response.snapshot { self.applyRemoteSnapshot(snapshot) } } catch { guard let self, self.revision == revision else { return } self.saveError = error.localizedDescription } } } func isFavorite(_ titleID: String) -> Bool { favoriteTitleIDs.contains(titleID) } func preferredReleaseID(for titleID: String) -> String? { preferredReleaseIDs[titleID] } func toggleFavorite(_ titleID: String) { guard maySave, Self.validID(titleID) else { return } if favoriteTitleIDs.contains(titleID) { favoriteTitleIDs.remove(titleID) } else { favoriteTitleIDs.insert(titleID) } if companion != nil { sendRemote(.init(operation: .setFavorite, titleID: titleID, enabled: favoriteTitleIDs.contains(titleID))) } else { save() } } func selectRelease(_ releaseID: String, for titleID: String) { guard maySave, Self.validID(titleID), Self.validID(releaseID), preferredReleaseIDs[titleID] != releaseID else { return } preferredReleaseIDs[titleID] = releaseID if companion != nil { sendRemote(.init(operation: .setPreferredRelease, releaseID: releaseID, titleID: titleID)) } else { save() } } // Receipts are the authoritative installation record; personal choices stay separate. func replaceInstallations(_ installations: [Installation]) { let entries = Dictionary(installations.map { ($0.releaseID, $0) }, uniquingKeysWith: { _, latest in latest }) guard entries != installedReleases else { return } installedReleases = entries if maySave && companion == nil { save() } } // Used at shutdown/testing to await all already-enqueued atomic writes. func flush() async { await remoteSave?.value await withCheckedContinuation { continuation in queue.async { continuation.resume() } } } private static func validID(_ id: String) -> Bool { !id.isEmpty && id.utf8.count <= 256 && !id.unicodeScalars.contains(where: CharacterSet.controlCharacters.contains) } private func save() { let document = Document(favoriteTitleIDs: favoriteTitleIDs, preferredReleaseIDs: preferredReleaseIDs, installedReleases: installedReleases) revision += 1 let revision = revision, destination = fileURL queue.async { [weak self] in let failure: String? do { let encoder = JSONEncoder(); encoder.outputFormatting = [.sortedKeys] let data = try encoder.encode(document) guard data.count <= 1_048_576 else { throw StateFailure.invalid } try FileManager.default.createDirectory(at: destination.deletingLastPathComponent(), withIntermediateDirectories: true) try data.write(to: destination, options: .atomic) failure = nil } catch { failure = "Library choices could not be saved: \(error.localizedDescription)" } Task { @MainActor [weak self] in guard let self, self.revision == revision else { return } self.saveError = failure } } } private enum StateFailure: LocalizedError { case invalid var errorDescription: String? { "The Library choices file is damaged or uses an unsupported version." } } }