Kisani/Services/BackupStatusService.swift

import Foundation
import Photos
import UIKit
import os.log

private let log = Logger(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>?
    // Separate debounce task for photo library change events
    private var debounceTask: Task<Void, Never>?

    private var lastFullRefresh: Date?
    private static let debounceInterval: TimeInterval = 4      // seconds before photo-change refresh runs
    private static let minRefreshInterval: TimeInterval = 30   // minimum between full NAS reconciliations

    // 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

    /// Start a reconciliation. `force: true` bypasses the minimum refresh interval.
    func refresh(force: Bool = false) {
        cancelAll()
        refreshTask = Task { [weak self] in
            await self?.performRefresh(force: force)
        }
    }

    /// Awaitable reconciliation — used by pull-to-refresh and post-failure resolution.
    func refreshAndWait(force: Bool = true) async {
        cancelAll()
        await performRefresh(force: force)
    }

    /// Called by BackupEngine after a completed run with newly uploaded entries.
    /// Applies an optimistic count update, writes the manifest in background, then reconciles.
    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")
        // Write manifest then force reconcile (entries captured only briefly)
        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
        }

        // Minimum interval guard (skip NAS round-trip if recently refreshed)
        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 store = ConnectionStore.shared
        guard let conn = store.savedConnection else { return }

        // ── Step 1: Phone count — metadata only, no image data, no thumbnails ──
        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 {
            // NAS offline — keep cached safe count, enforce invariant
            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 — Data + BackupManifest released after this call ──
        let manifestPath = "\(conn.remotePath)/\(BackupManifest.remoteFilename)"
        let index = await buildManifestIndex(transfer: transfer, path: manifestPath, conn: conn)
        log.info("Manifest index built — \(index.totalCount) NAS entries, filename-only=\(index.isFilenameOnly)")

        try Task.checkCancellation()

        // ── Step 4: Count safe assets — PHFetchResult enumerated in batches, no [PhotoAsset] kept ──
        let safe = try await countSafe(in: fetchResult, against: index)
        log.info("Comparison complete — \(safe)/\(phoneTotal) already safe")

        // ── Step 5: Commit — enforce invariant (alreadySafe ≤ phoneTotal) ──
        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. Data and BackupManifest are scoped inside
    /// this function — they are released before the caller's comparison step begins.
    private func buildManifestIndex(
        transfer: any NASTransferProtocol,
        path: String,
        conn: NASConnection
    ) async -> ManifestIndex {
        do {
            let data = try await transfer.downloadData(at: path)
            if let manifest = try? JSONDecoder().decode(BackupManifest.self, from: data) {
                // `data` and `manifest` released when this scope exits
                return ManifestIndex(manifest: manifest)
            }
        } catch {
            // File not found — fall through to directory listing bootstrap
        }
        // Bootstrap from directory listing
        let items = (try? await transfer.listDirectory(at: conn.remotePath)) ?? []
        log.info("Manifest not found — bootstrapping from \(items.count) NAS items")
        return ManifestIndex(nasListing: items)
    }

    /// Enumerates a PHFetchResult in batches using autoreleasepool.
    /// Never builds a full [PHAsset] or [PhotoAsset] array.
    private 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) {
                        // Fast path — O(1) Set lookup, no resource inspection
                        count += 1
                    } else if index.isFilenameOnly {
                        // Bootstrap path — manifest was built from NAS directory listing,
                        // no localIdentifiers available, must look up filename
                        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() // yield between batches to keep main thread responsive
        }

        return safe
    }

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

    private func updatePhoneCountOnly() {
        // Returns PHFetchResult — no array allocation
        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)"

            // Load existing, merge new entries, write back
            var manifest: BackupManifest
            do {
                let data = try await transfer.downloadData(at: manifestPath)
                manifest = (try? JSONDecoder().decode(BackupManifest.self, from: data)) ?? BackupManifest()
            } catch {
                manifest = BackupManifest()
            }

            manifest.merge(entries: entries)

            let encoder = JSONEncoder()
            encoder.dateEncodingStrategy = .iso8601
            let data = try encoder.encode(manifest)
            // manifest released here before write
            try await transfer.writeData(data, to: manifestPath)
            log.info("Manifest written — \(manifest.entries.count) 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 {
    /// Called on an arbitrary background thread by Photos.
    /// Debounced: schedules a refresh after a short delay, cancels any pending debounce.
    nonisolated func photoLibraryDidChange(_ changeInstance: PHChange) {
        Task { @MainActor [weak self] in
            guard let self else { return }
            // Cancel pending debounce and start a new one
            self.debounceTask?.cancel()
            self.debounceTask = Task {
                do {
                    try await Task.sleep(nanoseconds: UInt64(BackupStatusService.debounceInterval * 1_000_000_000))
                    self.refresh()  // non-forced: respects minRefreshInterval
                } catch {
                    // Cancelled — a newer change event took over
                }
            }
        }
    }
}