mycode/myApp/Keging/Shared/KegelEngine.swift

//
//  KegelEngine.swift
//  Keging
//
//  타이머 상태 기계 — iOS·워치 공용. 국면 전환마다 onPhaseChange(진동·Live Activity),
//  종료 시 onSessionEnd(완주 여부 + 완주 기록). 중단하면 기록하지 않는다.
//

import Foundation
import Combine

nonisolated enum KegelPhase: String, Codable, Hashable {
    case contract, relax

    var label: String { self == .contract ? "수축" : "이완" }
    var symbolName: String {
        self == .contract ? "arrow.down.right.and.arrow.up.left" : "arrow.up.left.and.arrow.down.right"
    }
}

@MainActor
final class KegelEngine: ObservableObject {
    static let shared = KegelEngine()

    enum State: Equatable {
        case idle
        case running(phase: KegelPhase, rep: Int, phaseStart: Date, phaseEnd: Date)
        case finished(reps: Int)
    }

    @Published private(set) var state: State = .idle
    private(set) var config = WorkoutConfig()
    private(set) var startedAt = Date()
    private var timer: Timer?

    /// 국면 진입마다 호출 (phase, rep, phaseEnd)
    var onPhaseChange: ((KegelPhase, Int, Date) -> Void)?
    /// 세션 종료 (completed, 완주 시 저장된 기록)
    var onSessionEnd: ((Bool, SessionRecord?) -> Void)?

    var isRunning: Bool { if case .running = state { true } else { false } }

    private init() {}

    func start(config: WorkoutConfig) {
        guard !isRunning else { return }
        self.config = config
        startedAt = Date()
        enterPhase(.contract, rep: 1)
    }

    /// 중단 — 이 세트는 아예 안 한 것으로 (기록 없음)
    func stop() {
        guard isRunning else { return }
        timer?.invalidate()
        timer = nil
        state = .idle
        onSessionEnd?(false, nil)
    }

    /// 완료 화면 확인 후 대기 상태 복귀
    func acknowledgeFinish() {
        if case .finished = state { state = .idle }
    }

    private func enterPhase(_ phase: KegelPhase, rep: Int) {
        let seconds = phase == .contract ? config.contractSeconds : config.relaxSeconds
        let now = Date()
        let end = now.addingTimeInterval(Double(max(1, seconds)))
        state = .running(phase: phase, rep: rep, phaseStart: now, phaseEnd: end)
        onPhaseChange?(phase, rep, end)
        timer?.invalidate()
        timer = Timer.scheduledTimer(withTimeInterval: Double(max(1, seconds)), repeats: false) { [weak self] _ in
            guard let self else { return }
            Task { @MainActor in self.advance(from: phase, rep: rep) }
        }
    }

    private func advance(from phase: KegelPhase, rep: Int) {
        guard case .running = state else { return }
        if phase == .contract {
            enterPhase(.relax, rep: rep)
        } else if rep < config.reps {
            enterPhase(.contract, rep: rep + 1)
        } else {
            complete()
        }
    }

    private func complete() {
        timer?.invalidate()
        timer = nil
        state = .finished(reps: config.reps)
        let record = SessionRecord(
            startedAt: startedAt,
            reps: config.reps,
            contractSeconds: config.contractSeconds,
            relaxSeconds: config.relaxSeconds
        )
        RecordStore.shared.append(record)
        onSessionEnd?(true, record)
    }
}