Kisani/Services/BackupStatusService.swift

import Foundation
import Photos
import UIKit
import os.log

private let log = Logger(subsystem: "com.albert.nasbackup", category: "BackupStatus")
private let signposter = OSSignposter(subsystem: "com.albert.nasbackup", category: "BackupStatus")

@MainActor
final class BackupStatusService: NSObject, ObservableObject {
    static let shared = BackupStatusService()

    @Published private(set) var snapshot: BackupStatusSnapshot = .empty
    @Published private(set) var isRefreshing: Bool = false
    @Published private(set) var refreshError: String?

    private let photoService = PhotoLibraryService()
    private let cacheKey = "backupStatusSnapshot_v2"

    // One active reconciliation task at a time — cancelled before starting a new one.
    private var refreshTask: Task<Void, Never>?
    private var debounceTask: Task<Void, Never>?

    private var lastFullRefresh: Date?
    private static let debounceInterval: TimeInterval = 4
    private static let minRefreshInterval: TimeInterval = 30

    // MARK: — Init

    private override init() {
        super.init()
        loadCachedSnapshot()
        PHPhotoLibrary.shared().register(self)
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(handleMemoryWarning),
            name: UIApplication.didReceiveMemoryWarningNotification,
            object: nil
        )
    }

    deinit {
        PHPhotoLibrary.shared().unregisterChangeObserver(self)
        NotificationCenter.default.removeObserver(self)
    }

    @objc private func handleMemoryWarning() {
        log.warning("Memory warning — cancelling in-flight refresh")
        cancelAll()
        isRefreshing = false
    }

    // MARK: — Public API

    func refresh(force: Bool = false) {
        cancelAll()
        refreshTask = Task { [weak self] in
            await self?.performRefresh(force: force)
        }
    }

    func refreshAndWait(force: Bool = true) async {
        cancelAll()
        await performRefresh(force: force)
    }

    func refreshAfterBackup(entries: [ManifestEntry], connection: NASConnection) {
        let uploaded = entries.count
        snapshot.alreadySafe = min(snapshot.phoneTotal, snapshot.alreadySafe + uploaded)
        snapshot.nasArchiveTotal += uploaded
        saveSnapshot()
        log.info("Post-backup optimistic update: +\(uploaded) safe")
        Task {
            await writeManifest(entries: entries, connection: connection)
            refresh(force: true)
        }
    }

    // MARK: — Refresh lifecycle

    private func cancelAll() {
        refreshTask?.cancel()
        refreshTask = nil
        debounceTask?.cancel()
        debounceTask = nil
    }

    private func performRefresh(force: Bool) async {
        guard !isRefreshing else {
            log.debug("Refresh skipped — already in progress")
            return
        }

        if !force, let last = lastFullRefresh,
           Date().timeIntervalSince(last) < Self.minRefreshInterval {
            log.debug("Refresh debounced — updating phone count only")
            updatePhoneCountOnly()
            return
        }

        lastFullRefresh = Date()
        isRefreshing = true
        refreshError = nil
        log.info("Refresh started (force=\(force))")

        do {
            try await reconcile()
            log.info("Refresh completed — phone=\(self.snapshot.phoneTotal) safe=\(self.snapshot.alreadySafe)")
        } catch is CancellationError {
            log.info("Refresh cancelled")
        } catch {
            log.error("Refresh failed: \(error.localizedDescription)")
            refreshError = error.localizedDescription
            snapshot.connectionState = .offline
            snapshot.lastCheckedAt = Date()
            saveSnapshot()
        }

        isRefreshing = false
    }

    // MARK: — Reconciliation

    private func reconcile() async throws {
        let spReconcile = signposter.beginInterval("Reconcile")
        defer { signposter.endInterval("Reconcile", spReconcile) }

        let store = ConnectionStore.shared
        guard let conn = store.savedConnection else { return }

        // ── Step 1: Phone count ───────────────────────────────────────────
        // PHFetchResult.count is O(1) after the initial index build — fast on main actor.
        let filter = store.backupFilter
        let fetchResult = photoService.fetchResultForReconciliation(filter: filter)
        let phoneTotal = fetchResult.count
        log.info("PHFetchResult count: \(phoneTotal)")

        try Task.checkCancellation()

        // ── Step 2: NAS connection ────────────────────────────────────────
        let transfer: any NASTransferProtocol = conn.nasProtocol == .smb ? SMBService() : SFTPService()
        do {
            try await transfer.connect(
                to: conn.host, port: conn.port,
                username: conn.username, password: conn.password
            )
        } catch {
            snapshot.phoneTotal = phoneTotal
            snapshot.alreadySafe = min(snapshot.alreadySafe, phoneTotal)
            snapshot.connectionState = .offline
            snapshot.lastCheckedAt = Date()
            saveSnapshot()
            log.warning("NAS offline — cached numbers retained")
            return
        }
        defer { transfer.disconnect() }

        try Task.checkCancellation()

        // ── Step 3: Load ManifestIndex ────────────────────────────────────
        // Download suspends main actor (good). JSON decode + Set<String> construction
        // is CPU-bound O(N) — runs in a background task so touch/animation remain smooth.
        let spManifest = signposter.beginInterval("ManifestLoad")
        let manifestPath = "\(conn.remotePath)/\(BackupManifest.remoteFilename)"
        let index = await buildManifestIndex(transfer: transfer, path: manifestPath, conn: conn)
        signposter.endInterval("ManifestLoad", spManifest,
                               "\(index.totalCount) entries, filename-only=\(index.isFilenameOnly)")
        log.info("Manifest index built — \(index.totalCount) NAS entries, filename-only=\(index.isFilenameOnly)")

        try Task.checkCancellation()

        // ── Step 4: Count safe assets — off main actor ────────────────────
        // Batch enumeration of PHFetchResult is CPU-bound (up to N/150 batches).
        // Running it in a detached task keeps the main thread free for the UI
        // while the count is in progress. Task.yield() inside countSafe lets other
        // async work interleave between batches.
        let spCount = signposter.beginInterval("CountSafe")
        let safe = try await Task.detached(priority: .userInitiated) { [weak self, fetchResult, index] in
            guard let self else { throw CancellationError() }
            return try await self.countSafe(in: fetchResult, against: index)
        }.value
        signposter.endInterval("CountSafe", spCount, "\(safe)/\(phoneTotal) safe")
        log.info("Comparison complete — \(safe)/\(phoneTotal) already safe")

        // ── Step 5: Commit ────────────────────────────────────────────────
        var updated = BackupStatusSnapshot()
        updated.phoneTotal      = phoneTotal
        updated.alreadySafe     = min(safe, phoneTotal)
        updated.nasArchiveTotal = index.totalCount
        updated.connectionState = .connected
        updated.lastCheckedAt   = Date()
        snapshot = updated
        saveSnapshot()
    }

    /// Builds a ManifestIndex from NAS.
    /// - The download suspends the main actor.
    /// - JSON decode and Set construction run in a background task.
    private func buildManifestIndex(
        transfer: any NASTransferProtocol,
        path: String,
        conn: NASConnection
    ) async -> ManifestIndex {
        do {
            let data = try await transfer.downloadData(at: path)
            // Decode and build index off main actor — JSONDecoder is not cheap for large manifests.
            let index: ManifestIndex? = await Task.detached(priority: .utility) {
                guard let manifest = try? JSONDecoder().decode(BackupManifest.self, from: data)
                else { return nil }
                return ManifestIndex(manifest: manifest)
            }.value
            if let index { return index }
        } catch {
            // File not found — fall through to directory listing bootstrap
        }

        // Bootstrap: list NAS directory and build filename-only index in background.
        let items = (try? await transfer.listDirectory(at: conn.remotePath)) ?? []
        log.info("Manifest not found — bootstrapping from \(items.count) NAS items")
        return await Task.detached(priority: .utility) {
            ManifestIndex(nasListing: items)
        }.value
    }

    /// Enumerates a PHFetchResult in batches using autoreleasepool.
    /// Marked nonisolated so it can be called from a background Task without
    /// requiring main-actor scheduling — it accesses no @MainActor state.
    private nonisolated func countSafe(
        in result: PHFetchResult<PHAsset>,
        against index: ManifestIndex,
        batchSize: Int = 150
    ) async throws -> Int {
        var safe = 0
        let total = result.count
        var processed = 0

        while processed < total {
            try Task.checkCancellation()

            let batchEnd = min(processed + batchSize, total)

            // autoreleasepool releases PHAsset objects and PHAssetResource arrays
            // created during this batch before moving to the next.
            let batchSafe: Int = autoreleasepool {
                var count = 0
                for i in processed..<batchEnd {
                    let asset = result.object(at: i)
                    if index.matches(localIdentifier: asset.localIdentifier) {
                        count += 1
                    } else if index.isFilenameOnly {
                        let resources = PHAssetResource.assetResources(for: asset)
                        if let name = resources.first?.originalFilename,
                           index.matches(filename: name) {
                            count += 1
                        }
                    }
                }
                return count
            }

            safe += batchSafe
            processed = batchEnd
            await Task.yield()
        }

        return safe
    }

    // MARK: — Phone-only lightweight update (no NAS connection)

    private func updatePhoneCountOnly() {
        let result = photoService.fetchResultForReconciliation(
            filter: ConnectionStore.shared.backupFilter
        )
        let phoneTotal = result.count
        guard phoneTotal != snapshot.phoneTotal else { return }
        snapshot.phoneTotal = phoneTotal
        snapshot.alreadySafe = min(snapshot.alreadySafe, phoneTotal)
        saveSnapshot()
        log.debug("Phone-only update: \(phoneTotal) assets")
    }

    // MARK: — Manifest write (non-blocking, background only)

    func writeManifest(entries: [ManifestEntry], connection: NASConnection) async {
        guard !entries.isEmpty else { return }
        let transfer: any NASTransferProtocol = connection.nasProtocol == .smb ? SMBService() : SFTPService()
        do {
            try await transfer.connect(
                to: connection.host, port: connection.port,
                username: connection.username, password: connection.password
            )
            defer { transfer.disconnect() }

            let manifestPath = "\(connection.remotePath)/\(BackupManifest.remoteFilename)"

            // Download existing manifest (async, main actor suspended).
            let existingData = try? await transfer.downloadData(at: manifestPath)

            // Merge + JSON encode off main actor — can be slow for large manifests.
            let encoded: Data? = await Task.detached(priority: .utility) {
                var manifest: BackupManifest
                if let data = existingData,
                   let existing = try? JSONDecoder().decode(BackupManifest.self, from: data) {
                    manifest = existing
                } else {
                    manifest = BackupManifest()
                }
                manifest.merge(entries: entries)
                let encoder = JSONEncoder()
                encoder.dateEncodingStrategy = .iso8601
                return try? encoder.encode(manifest)
            }.value
            guard let encoded else { return }

            try await transfer.writeData(encoded, to: manifestPath)
            log.info("Manifest written — \(entries.count) new entries")
        } catch {
            log.error("Manifest write failed (non-fatal): \(error.localizedDescription)")
        }
    }

    // MARK: — Cache

    private func loadCachedSnapshot() {
        guard let data = UserDefaults.standard.data(forKey: cacheKey),
              let cached = try? JSONDecoder().decode(BackupStatusSnapshot.self, from: data)
        else { return }
        snapshot = cached
    }

    private func saveSnapshot() {
        let encoder = JSONEncoder()
        encoder.dateEncodingStrategy = .iso8601
        if let data = try? encoder.encode(snapshot) {
            UserDefaults.standard.set(data, forKey: cacheKey)
        }
    }
}

// MARK: — PHPhotoLibraryChangeObserver

extension BackupStatusService: PHPhotoLibraryChangeObserver {
    nonisolated func photoLibraryDidChange(_ changeInstance: PHChange) {
        Task { @MainActor [weak self] in
            guard let self else { return }
            self.debounceTask?.cancel()
            self.debounceTask = Task {
                do {
                    try await Task.sleep(nanoseconds: UInt64(BackupStatusService.debounceInterval * 1_000_000_000))
                    self.refresh()
                } catch {
                    // Cancelled — a newer change event took over
                }
            }
        }
    }
}