workouts/Shared/Connectivity/WCPayload.swift

import Foundation

/// Wire format for the iPhone↔Watch bridge. The phone is the only device that
/// touches iCloud Drive; the watch round-trips domain documents through the phone.
/// Payloads carry the shared `*Document` types (JSON-encoded `Data` blobs, which
/// WatchConnectivity allows) keyed by stable ULIDs — no name/date reconciliation.
enum WCPayload {
    static let typeKey = "type"
    static let splitsKey = "splits"
    static let workoutsKey = "workouts"
    static let workoutKey = "workout"
    static let restSecondsKey = "restSeconds"
    static let doneCountdownSecondsKey = "doneCountdownSeconds"

    static let workoutUpdateType = "workoutUpdate"   // watch → phone (one workout)
    static let requestSyncType = "requestSync"       // watch → phone (please push state)

    // MARK: - Phone → Watch (application context: latest-state-wins)

    static func encodeState(splits: [SplitDocument], workouts: [WorkoutDocument], restSeconds: Int, doneCountdownSeconds: Int) -> [String: Any] {
        var dict: [String: Any] = [:]
        if let s = try? DocumentCoder.encoder.encode(splits) { dict[splitsKey] = s }
        if let w = try? DocumentCoder.encoder.encode(workouts) { dict[workoutsKey] = w }
        dict[restSecondsKey] = restSeconds
        dict[doneCountdownSecondsKey] = doneCountdownSeconds
        return dict
    }

    static func decodeSplits(_ dict: [String: Any]) -> [SplitDocument] {
        guard let data = dict[splitsKey] as? Data else { return [] }
        return (try? DocumentCoder.decoder.decode([SplitDocument].self, from: data)) ?? []
    }

    static func decodeWorkouts(_ dict: [String: Any]) -> [WorkoutDocument] {
        guard let data = dict[workoutsKey] as? Data else { return [] }
        return (try? DocumentCoder.decoder.decode([WorkoutDocument].self, from: data)) ?? []
    }

    static func decodeRestSeconds(_ dict: [String: Any]) -> Int? { dict[restSecondsKey] as? Int }

    static func decodeDoneCountdownSeconds(_ dict: [String: Any]) -> Int? { dict[doneCountdownSecondsKey] as? Int }

    // MARK: - Watch → Phone (a single updated workout)

    static func encodeWorkoutUpdate(_ workout: WorkoutDocument) -> [String: Any] {
        var dict: [String: Any] = [typeKey: workoutUpdateType]
        if let w = try? DocumentCoder.encoder.encode(workout) { dict[workoutKey] = w }
        return dict
    }

    static func decodeWorkoutUpdate(_ dict: [String: Any]) -> WorkoutDocument? {
        guard let data = dict[workoutKey] as? Data else { return nil }
        return try? DocumentCoder.decoder.decode(WorkoutDocument.self, from: data)
    }

    static func requestSyncMessage() -> [String: Any] { [typeKey: requestSyncType] }
}