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 prepare, contract, relax

    var label: String {
        switch self {
        case .prepare: String(localized: "준비")
        case .contract: String(localized: "수축")
        case .relax: String(localized: "이완")
        }
    }

    var symbolName: String {
        switch self {
        case .prepare: "timer"
        case .contract: "arrow.down.right.and.arrow.up.left"
        case .relax: "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()
        if config.prepSeconds > 0 {
            enterPhase(.prepare, rep: 1)
        } else {
            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 = switch phase {
        case .prepare: config.prepSeconds
        case .contract: config.contractSeconds
        case .relax: config.relaxSeconds
        }
        // 기록·건강의 시작 시각은 준비를 뺀 첫 수축 기준
        if phase == .contract && rep == 1 { startedAt = Date() }
        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 }
        switch phase {
        case .prepare:
            enterPhase(.contract, rep: 1)
        case .contract:
            enterPhase(.relax, rep: rep)
        case .relax:
            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)
    }
}