Troubleshooting

// 1. Verify world map was saved
let spaces = try await storage.loadAllSpaces()
print("Saved spaces: \(spaces.count)")

// 2. Check relocalization status
func session(_ session: ARSession, cameraDidChangeTrackingState camera: ARCamera) {
    switch camera.trackingState {
    case .normal:
        print("Relocalized! Now load anchors")
        Task { await loadAnchors() }
    case .limited(let reason):
        print("Limited tracking: \(reason)")
    case .notAvailable:
        print("Tracking not available")
    }
}

// 3. Help user understand what's happening
if camera.trackingState == .limited(.relocalizing) {
    showMessage("Move your phone around to help recognize the space")
}

// Wait for stable tracking before loading anchors
func session(_ session: ARSession, cameraDidChangeTrackingState camera: ARCamera) {
    guard camera.trackingState == .normal else { return }

    // Add small delay to ensure stable relocalization
    DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
        Task { await self.loadAnchors() }
    }
}

// Implement a timeout and fallback
class RelocalizationManager {
    private var relocalizationTimer: Timer?

    func startRelocalization(with worldMap: ARWorldMap) {
        let config = ARWorldTrackingConfiguration()
        config.initialWorldMap = worldMap
        arSession.run(config, options: [.resetTracking])

        // Timeout after 30 seconds
        relocalizationTimer = Timer.scheduledTimer(withTimeInterval: 30, repeats: false) { [weak self] _ in
            self?.handleRelocalizationTimeout()
        }
    }

    func handleRelocalizationTimeout() {
        // Offer to start fresh
        showAlert(
            title: "Can't Recognize Space",
            message: "The room may have changed. Start fresh?",
            actions: [
                ("Try Again", { self.retryRelocalization() }),
                ("Start New Space", { self.createNewSpace() })
            ]
        )
    }
}

// Always handle the nil case
if let space = try await storage.loadSpace(id: savedId) {
    // Use space
} else {
    // Space not found - create new one
    print("Space \(savedId) not found, creating new space")
}

// Check what's actually in storage
let allSpaces = try await storage.loadAllSpaces()
print("Available spaces: \(allSpaces.map { $0.id })")

// Check storage size
let size = try storage.localStorageSize()
print("Storage: \(ByteCountFormatter.string(fromByteCount: Int64(size), countStyle: .file))")

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

// Delete unused spaces
for space in try await storage.loadAllSpaces() {
    let anchors = try await storage.loadAnchors(spaceId: space.id)
    if anchors.isEmpty && space.updatedAt < thirtyDaysAgo {
        try await storage.deleteSpace(id: space.id)
    }
}

// Check if cloud is enabled
print("Cloud enabled: \(storage.isCloudEnabled)")
print("Pending operations: \(storage.pendingOperationCount)")

// Force a sync and handle errors explicitly
do {
    try await storage.sync()
    print("Sync completed")
} catch HBStorageError.cloudNotConfigured {
    print("Cloud not configured - using local only")
} catch HBStorageError.networkError(let underlying) {
    print("Network error: \(underlying)")
} catch {
    print("Sync failed: \(error)")
}

// Check pending count
if storage.pendingOperationCount > 10 {
    print("Warning: \(storage.pendingOperationCount) operations pending")

    // Try syncing when network is available
    let monitor = NWPathMonitor()
    monitor.pathUpdateHandler = { path in
        if path.status == .satisfied {
            Task { try? await storage.sync() }
        }
    }
    monitor.start(queue: .global())
}

// Load on background thread, apply on main
Task.detached(priority: .userInitiated) {
    let worldMap = try space.arWorldMap()

    await MainActor.run {
        let config = ARWorldTrackingConfiguration()
        config.initialWorldMap = worldMap
        arSession.run(config)
    }
}

// Show loading indicator
isLoading = true
defer { isLoading = false }

// Check world map size before saving
let sizeInMB = Double(space.worldMapSize) / 1_000_000
if sizeInMB > 40 {
    print("Warning: Large world map (\(space.worldMapSizeFormatted))")
}

// Use compression (enabled by default)
let config = HBStorageConfig(compression: .balanced)  // ~40% size reduction
let storage = HBStorage(config: config)

// Print all stored data
func debugStorage() async throws {
    let spaces = try await storage.loadAllSpaces()
    print("=== Spaces (\(spaces.count)) ===")
    for space in spaces {
        print("  \(space.id): \(space.name ?? "unnamed") (\(space.worldMapSizeFormatted))")

        let anchors = try await storage.loadAnchors(spaceId: space.id, includeDeleted: true)
        print("    Anchors: \(anchors.filter { !$0.isDeleted }.count) active, \(anchors.filter { $0.isDeleted }.count) deleted")
    }

    print("\nTotal size: \(ByteCountFormatter.string(fromByteCount: Int64(try storage.localStorageSize()), countStyle: .file))")
}

// Nuclear option - clear all data and start fresh
func resetAll() throws {
    try storage.clearLocalStorage()
    print("All local data cleared")
}