//
// LiveProgress.swift
// Workouts (Shared)
//
// Copyright 2025 Rouslan Zenetl. All Rights Reserved.
//

import Foundation

/// Which page of the Ready → Work → Rest → Finish run flow the driving device is on.
enum LiveRunPhase: String, Sendable, Equatable {
    case ready, work, rest, finish
}

/// An *ephemeral* "live run" frame broadcast by the device actively driving an exercise so a
/// propped-up second device can mirror the run flow in real time.
///
/// This is deliberately **not** the durable `WorkoutDocument` sync. That path writes a file to
/// iCloud Drive at set-completion granularity; this one is a throwaway snapshot of *where in
/// the flow* the driver is, sent on every phase transition and never persisted (no SwiftData,
/// no iCloud).
///
/// Timers ride as wall-clock anchors, not a streamed countdown: the mirror renders the same
/// SwiftUI timer text off `phaseStart` / `phaseEnd`, so both devices count independently and
/// stay in lockstep without ticking over the wire. Paired-device clock skew is sub-second, so
/// the two displays agree in practice. A count-down phase (rest, timed work, the finish
/// auto-Done) carries `phaseEnd`; a rep-based work set counts *up* and leaves it `nil`.
struct LiveProgress: Sendable, Equatable {
    var workoutID: String
    var logID: String
    var exerciseName: String
    var phase: LiveRunPhase

    /// 0-based set this frame pertains to: the set being worked (`work`/`finish`), or the set
    /// just completed that this rest follows (`rest`). Drives the header and the progress dots.
    var setIndex: Int
    var setCount: Int

    /// Footer line under the timer, e.g. "8 reps" or "30 sec".
    var detail: String

    /// Wall-clock anchor for the phase's timer. Work counts up from here; count-down phases
    /// run from here to `phaseEnd`.
    var phaseStart: Date
    /// End anchor for count-down phases; `nil` for a rep-based work set (which counts up).
    var phaseEnd: Date?

    /// Monotonic per-run sequence, so the mirror can drop a stale / out-of-order delivery.
    var version: Int
}

extension LiveProgress {
    /// Strict "newer than" over the shared per-run sequence, tie-broken by the phase anchor.
    /// The tie-break matters because the sequence isn't collision-free: each side catches its
    /// counter up only from frames it *receives*, so after a lost frame both devices can mint
    /// the same version independently. On a collision the later wall-clock action wins —
    /// paired-device clock skew is sub-second, so the anchor orders genuine collisions
    /// correctly. Equal version *and* equal anchor is the same frame redelivered: not newer.
    func isNewer(thanVersion version: Int, start: Date) -> Bool {
        self.version != version ? self.version > version : phaseStart > start
    }

    func isNewer(than other: LiveProgress) -> Bool {
        isNewer(thanVersion: other.version, start: other.phaseStart)
    }
}
