InvestmentTrackerApp/PortfolioJournalWatch/WatchDataStore.swift

import Foundation
import WatchConnectivity
import WidgetKit

/// Receives portfolio snapshots from the iPhone and keeps them available to the
/// watch app and its complications.
///
/// Two paths feed it: the application context the phone pushes whenever data
/// changes (delivered even if the watch app is not running), and an explicit
/// request sent when the user opens the app while the phone is reachable.
@MainActor
final class WatchDataStore: NSObject, ObservableObject {

    static let shared = WatchDataStore()

    @Published private(set) var snapshot: WatchPortfolioSnapshot
    @Published private(set) var isRefreshing = false
    /// True once we know the phone can be asked for fresh data.
    @Published private(set) var isPhoneReachable = false

    private var session: WCSession? {
        WCSession.isSupported() ? WCSession.default : nil
    }

    private override init() {
        snapshot = WatchSnapshotCache.load() ?? .empty
        super.init()
    }

    func activate() {
        guard let session else { return }
        session.delegate = self
        if session.activationState != .activated {
            session.activate()
        } else {
            isPhoneReachable = session.isReachable
        }
    }

    /// Asks the phone for a fresh snapshot. Silently does nothing when the
    /// phone is out of reach — the cached snapshot stays on screen.
    func refresh() {
        guard let session, session.activationState == .activated, session.isReachable else { return }
        isRefreshing = true
        session.sendMessage(
            [WatchSyncMessage.requestSnapshot: true],
            replyHandler: { [weak self] reply in
                Task { @MainActor in
                    self?.isRefreshing = false
                    self?.apply(context: reply)
                }
            },
            errorHandler: { [weak self] _ in
                Task { @MainActor in
                    self?.isRefreshing = false
                }
            }
        )
    }

    private func apply(context: [String: Any]) {
        guard let received = WatchPortfolioSnapshot.from(applicationContext: context) else { return }
        // Application contexts can arrive out of order after a reconnect.
        guard received.generatedAt >= snapshot.generatedAt else { return }
        snapshot = received
        WatchSnapshotCache.save(received)
        WidgetCenter.shared.reloadAllTimelines()
    }
}

// MARK: - WCSessionDelegate

extension WatchDataStore: WCSessionDelegate {

    nonisolated func session(
        _ session: WCSession,
        activationDidCompleteWith activationState: WCSessionActivationState,
        error: Error?
    ) {
        guard activationState == .activated else { return }
        let context = session.receivedApplicationContext
        let reachable = session.isReachable
        Task { @MainActor in
            self.isPhoneReachable = reachable
            self.apply(context: context)
            self.refresh()
        }
    }

    nonisolated func session(_ session: WCSession, didReceiveApplicationContext applicationContext: [String: Any]) {
        Task { @MainActor in
            self.apply(context: applicationContext)
        }
    }

    nonisolated func sessionReachabilityDidChange(_ session: WCSession) {
        let reachable = session.isReachable
        Task { @MainActor in
            self.isPhoneReachable = reachable
            if reachable { self.refresh() }
        }
    }
}