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 sessionStart = 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
        sessionStart = Date()
        startedAt = sessionStart.addingTimeInterval(Double(config.prepSeconds))
        applyTarget(computeTarget(at: Date()))
    }

    /// 포그라운드 복귀 등에서 호출 — 벽시계 기준 현재 국면으로 재정렬.
    /// 국면이 실제로 바뀌었을 때만 onPhaseChange(진동·Live Activity)가 나간다
    func resyncAfterWake() {
        guard case .running = state else { return }
        applyTarget(computeTarget(at: Date()))
    }

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

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

    private enum Target {
        case finished
        case running(KegelPhase, Int, Date, Date)
    }

    /// 벽시계 기준 지금 있어야 할 국면 — 세션 전체가 sessionStart로부터 결정적
    private func computeTarget(at now: Date) -> Target {
        let prep = Double(config.prepSeconds)
        let contract = Double(max(1, config.contractSeconds))
        let relax = Double(max(1, config.relaxSeconds))
        let cycle = contract + relax
        let elapsed = now.timeIntervalSince(sessionStart)
        if elapsed < prep {
            return .running(.prepare, 1, sessionStart, sessionStart.addingTimeInterval(prep))
        }
        let exercised = elapsed - prep
        let repIndex = Int(exercised / cycle)  // 0부터
        guard repIndex < config.reps else { return .finished }
        let repStart = sessionStart.addingTimeInterval(prep + Double(repIndex) * cycle)
        if exercised - Double(repIndex) * cycle < contract {
            return .running(.contract, repIndex + 1, repStart, repStart.addingTimeInterval(contract))
        }
        return .running(.relax, repIndex + 1, repStart.addingTimeInterval(contract), repStart.addingTimeInterval(cycle))
    }

    private func applyTarget(_ target: Target) {
        switch target {
        case .finished:
            complete()
        case let .running(phase, rep, phaseStart, phaseEnd):
            let changed: Bool = {
                guard case let .running(currentPhase, currentRep, _, _) = state else { return true }
                return currentPhase != phase || currentRep != rep
            }()
            state = .running(phase: phase, rep: rep, phaseStart: phaseStart, phaseEnd: phaseEnd)
            if changed { onPhaseChange?(phase, rep, phaseEnd) }
            scheduleTick(at: phaseEnd)
        }
    }

    private func scheduleTick(at date: Date) {
        timer?.invalidate()
        let interval = max(0.05, date.timeIntervalSinceNow + 0.02)
        timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: false) { [weak self] _ in
            guard let self else { return }
            Task { @MainActor in
                guard case .running = self.state else { return }
                self.applyTarget(self.computeTarget(at: Date()))
            }
        }
    }

    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)
    }
}