HBStorage

let storage = HBStorage()
// or
let storage = HBStorage(config: .default)

let storage = HBStorage()

let storage = HBStorage(config: HBStorageConfig(
    backend: .supabase(
        url: "https://xxx.supabase.co",
        anonKey: "eyJ..."
    ),
    syncStrategy: .onSave,
    compression: .balanced
))

public func save(_ space: HBSpace) async throws

let worldMap = try await arSession.currentWorldMap
let space = try HBSpace(name: "Living Room", worldMap: worldMap)
try await storage.save(space)

public func loadSpace(id: UUID) async throws -> HBSpace?

if let space = try await storage.loadSpace(id: savedId) {
    let worldMap = try space.arWorldMap()
    // Use worldMap for relocalization
}

public func loadAllSpaces() async throws -> [HBSpace]

let spaces = try await storage.loadAllSpaces()
let mostRecent = spaces.max(by: { $0.updatedAt < $1.updatedAt })

public func deleteSpace(id: UUID) async throws

public func save(_ anchor: HBAnchor) async throws

let anchor = HBAnchor(
    spaceId: space.id,
    transform: entity.transform.matrix,
    metadata: ["text": .string("Hello")]
)
try await storage.save(anchor)

public func loadAnchors(spaceId: UUID, includeDeleted: Bool = false) async throws -> [HBAnchor]

// Active anchors only
let anchors = try await storage.loadAnchors(spaceId: space.id)

// Include soft-deleted anchors
let allAnchors = try await storage.loadAnchors(spaceId: space.id, includeDeleted: true)

public func loadAnchor(id: UUID) async throws -> HBAnchor?

public func deleteAnchor(id: UUID) async throws

public func purgeDeletedAnchors(before: Date) async throws

// Permanently remove anchors deleted more than 30 days ago
let cutoff = Calendar.current.date(byAdding: .day, value: -30, to: Date())!
try await storage.purgeDeletedAnchors(before: cutoff)

public func sync() async throws

do {
    try await storage.sync()
    print("Sync complete")
} catch HBStorageError.cloudNotConfigured {
    print("Cloud not configured")
}

// Check if cloud is configured
public var isCloudEnabled: Bool

// Number of pending operations
public var pendingOperationCount: Int

public func timeline(spaceId: UUID) async throws -> HBTimeline

let timeline = try await storage.timeline(spaceId: space.id)
print("Events: \(timeline.events.count)")
print("Time span: \(timeline.startDate) to \(timeline.endDate)")

public func anchorsAt(spaceId: UUID, date: Date) async throws -> [HBAnchor]

let yesterday = Calendar.current.date(byAdding: .day, value: -1, to: Date())!
let pastAnchors = try await storage.anchorsAt(spaceId: space.id, date: yesterday)

public func diff(spaceId: UUID, from: Date, to: Date) async throws -> HBDiff

let oneWeekAgo = Calendar.current.date(byAdding: .day, value: -7, to: Date())!
let diff = try await storage.diff(spaceId: space.id, from: oneWeekAgo, to: Date())
print(diff.summary) // "3 added, 1 removed"

public func history(anchorId: UUID) async throws -> [HBAnchorEvent]

let events = try await storage.history(anchorId: anchor.id)
for event in events {
    print("v\(event.version): \(event.type) at \(event.timestamp)")
}

@discardableResult
public func rollback(anchorId: UUID, toVersion: Int) async throws -> HBAnchor

// Restore to version 2
let restored = try await storage.rollback(anchorId: anchor.id, toVersion: 2)

public func clearLocalStorage() throws

public func localStorageSize() throws -> Int

func checkStorageHealth() throws {
    let size = try storage.localStorageSize()
    let sizeInMB = Double(size) / 1_000_000

    print("Storage: \(String(format: "%.1f", sizeInMB)) MB")

    if sizeInMB > 100 {
        print("Consider cleaning up old spaces")
    }
}

// Remove anchors deleted more than 30 days ago
let cutoff = Calendar.current.date(byAdding: .day, value: -30, to: Date())!
try await storage.purgeDeletedAnchors(before: cutoff)

let ninetyDaysAgo = Calendar.current.date(byAdding: .day, value: -90, to: Date())!

for space in try await storage.loadAllSpaces() {
    if space.updatedAt < ninetyDaysAgo {
        // Check if it has any active anchors
        let anchors = try await storage.loadAnchors(spaceId: space.id)
        if anchors.isEmpty {
            try await storage.deleteSpace(id: space.id)
            print("Deleted unused space: \(space.name ?? space.id.uuidString)")
        }
    }
}

func performMaintenanceIfNeeded() async throws {
    let lastCleanup = UserDefaults.standard.object(forKey: "lastCleanup") as? Date
    let oneWeekAgo = Calendar.current.date(byAdding: .day, value: -7, to: Date())!

    guard lastCleanup == nil || lastCleanup! < oneWeekAgo else { return }

    // Purge old deleted anchors
    let thirtyDaysAgo = Calendar.current.date(byAdding: .day, value: -30, to: Date())!
    try await storage.purgeDeletedAnchors(before: thirtyDaysAgo)

    UserDefaults.standard.set(Date(), forKey: "lastCleanup")
}

struct StorageManagementView: View {
    @State private var storageSize: Int = 0
    @State private var spaces: [HBSpace] = []

    var body: some View {
        List {
            Section("Storage Used") {
                Text(ByteCountFormatter.string(
                    fromByteCount: Int64(storageSize),
                    countStyle: .file
                ))
            }

            Section("Saved Spaces") {
                ForEach(spaces) { space in
                    HStack {
                        Text(space.name ?? "Unnamed")
                        Spacer()
                        Text(space.worldMapSizeFormatted)
                            .foregroundColor(.secondary)
                    }
                }
                .onDelete(perform: deleteSpaces)
            }
        }
    }
}