import XCTest
@testable import CoachModel

/* Le déroulé d'une séance structurée au poignet.
 *
 * Ces tests portent sur ce qu'aucun build Xcode ne rattrape : la dérive
 * silencieuse. Un intervalle qui démarre trois secondes trop tard ne casse
 * rien, ne lève rien, et se voit seulement au neuvième tour — sur le terrain,
 * pas en relecture.
 */
final class IntervalEngineTests: XCTestCase {

    // Séance réelle du plan (CDC · reprise) : 5' marche, 3×(1' course / 1'
    // marche), 5' marche. C'est le gabarit le plus fréquent chez l'utilisateur.
    private func cdcPlan(reps: Int = 3) -> [CoachPlanStep] {
        var steps: [CoachPlanStep] = [
            CoachPlanStep(kind: .warmup, durationSec: 300, hrZone: 1, label: "5 min marche")
        ]
        for _ in 0..<reps {
            steps.append(CoachPlanStep(kind: .work, durationSec: 60, hrZone: 2,
                                       label: "1' course, cadence 170+"))
            steps.append(CoachPlanStep(kind: .recovery, durationSec: 60, hrZone: 1,
                                       label: "1' marche"))
        }
        steps.append(CoachPlanStep(kind: .cooldown, durationSec: 300, hrZone: 1,
                                   label: "5 min marche"))
        return steps
    }

    // MARK: Déroulé nominal

    func testFirstStepIsAnnouncedOnFirstTick() {
        var engine = IntervalEngine(steps: cdcPlan())
        let events = engine.update(elapsed: 0, distance: 0)
        XCTAssertEqual(events, [.stepStarted(index: 0)])
        XCTAssertEqual(engine.index, 0)
        XCTAssertEqual(engine.currentStep?.label, "5 min marche")
        XCTAssertEqual(engine.nextStep?.kind, .work)
    }

    func testStepBoundaryEmitsFinishThenStart() {
        var engine = IntervalEngine(steps: cdcPlan())
        engine.update(elapsed: 0, distance: 0)
        XCTAssertTrue(engine.update(elapsed: 299, distance: 0).transitions.isEmpty,
                      "Une seconde avant la fin, rien ne doit basculer")

        let events = engine.update(elapsed: 300, distance: 0)
        XCTAssertEqual(events, [.stepFinished(index: 0), .stepStarted(index: 1)])
        XCTAssertEqual(engine.index, 1)
    }

    func testWholeSessionRunsToCompletion() {
        var engine = IntervalEngine(steps: cdcPlan())
        var finished = false
        // 16 min de séance échantillonnées à la seconde.
        for t in stride(from: 0.0, through: 960.0, by: 1.0) {
            if engine.update(elapsed: t, distance: 0).contains(.planFinished) {
                finished = true
                XCTAssertEqual(t, 960, "5 min + 3×(1'+1') + 5 min = 16 min = 960 s")
                break
            }
        }
        XCTAssertTrue(finished)
        XCTAssertTrue(engine.isFinished)
        XCTAssertNil(engine.currentStep)
    }

    // MARK: La dérive — le cœur du sujet

    func testLateTickDoesNotGrantExtraTimeToTheNextStep() {
        // L'app est suspendue poignet baissé : le tick suivant arrive 3 s en
        // retard. L'intervalle d'une minute qui démarre ne doit PAS hériter de
        // ces 3 secondes.
        var engine = IntervalEngine(steps: cdcPlan())
        engine.update(elapsed: 0, distance: 0)
        engine.update(elapsed: 303, distance: 0)   // 3 s de retard sur la frontière

        XCTAssertEqual(engine.index, 1)
        XCTAssertEqual(engine.progress().elapsedInStep, 3, accuracy: 0.001,
                       "L'étape a commencé à 300 s, pas à 303 s")
        XCTAssertEqual(engine.progress().remainingInStep ?? -1, 57, accuracy: 0.001)

        // Et la frontière suivante tombe bien à 360 s, pas à 363 s.
        XCTAssertTrue(engine.update(elapsed: 359, distance: 0).transitions.isEmpty)
        XCTAssertEqual(engine.update(elapsed: 360, distance: 0),
                       [.stepFinished(index: 1), .stepStarted(index: 2)])
    }

    func testNoCumulativeDriftOverManyRepetitions() {
        // Neuf répétitions, chaque tick arrivant systématiquement en retard de
        // 2,5 s. Sans frontières théoriques, l'erreur s'accumulerait à ~22 s.
        var engine = IntervalEngine(steps: cdcPlan(reps: 9))
        var t = 0.0
        var lastStart: TimeInterval = 0
        var events: [IntervalEvent] = []
        while !engine.isFinished && t < 3000 {
            events = engine.update(elapsed: t, distance: 0)
            if events.contains(where: { if case .stepStarted = $0 { return true }; return false }) {
                lastStart = t
            }
            t += 2.5
        }
        XCTAssertTrue(engine.isFinished)
        // Dernière étape (retour au calme) : démarre à 1380 s en théorie.
        // Avec des ticks tous les 2,5 s, on la détecte au plus tard 2,5 s après.
        XCTAssertEqual(lastStart, 1380, accuracy: 2.5,
                       "La fin de séance ne doit pas dériver avec les répétitions")
    }

    func testSeveralShortStepsCrossedInASingleTick() {
        // Tick manqué de 30 s sur des intervalles de 10 s : trois étapes
        // franchies d'un coup. Traiter une seule transition par tick ferait
        // décrocher le déroulé sans rien signaler.
        let steps = (0..<6).map { i in
            CoachPlanStep(kind: i.isMultiple(of: 2) ? .work : .recovery,
                          durationSec: 10, label: "step\(i)")
        }
        var engine = IntervalEngine(steps: steps)
        engine.update(elapsed: 0, distance: 0)
        let events = engine.update(elapsed: 30, distance: 0)

        XCTAssertEqual(engine.index, 3)
        XCTAssertEqual(events, [
            .stepFinished(index: 0), .stepStarted(index: 1),
            .stepFinished(index: 1), .stepStarted(index: 2),
            .stepFinished(index: 2), .stepStarted(index: 3),
        ])
    }

    // MARK: Étapes en distance et étapes ouvertes

    func testDistanceStepCompletesOnDistanceNotTime() {
        let steps = [
            CoachPlanStep(kind: .work, distanceM: 1000, label: "1 km"),
            CoachPlanStep(kind: .recovery, durationSec: 60, label: "récup"),
        ]
        var engine = IntervalEngine(steps: steps)
        engine.update(elapsed: 0, distance: 0)

        XCTAssertTrue(engine.update(elapsed: 600, distance: 999).transitions.isEmpty,
                      "Dix minutes ne terminent pas une étape en distance")
        XCTAssertEqual(engine.progress().remainingDistanceM ?? -1, 1, accuracy: 0.001)

        let events = engine.update(elapsed: 610, distance: 1000)
        XCTAssertEqual(events, [.stepFinished(index: 0), .stepStarted(index: 1)])
    }

    func testOpenStepNeverEndsByItself() {
        let steps = [
            CoachPlanStep(kind: .warmup, label: "Pars quand tu es prêt"),
            CoachPlanStep(kind: .work, durationSec: 60, label: "effort"),
        ]
        var engine = IntervalEngine(steps: steps)
        engine.update(elapsed: 0, distance: 0)
        XCTAssertTrue(engine.update(elapsed: 3600, distance: 8000).isEmpty,
                      "Une étape ouverte ne se termine que sur ordre")
        XCTAssertNil(engine.progress().fraction)
        XCTAssertNil(engine.progress().remainingInStep)

        let events = engine.advanceManually()
        XCTAssertEqual(events, [.stepFinished(index: 0), .stepStarted(index: 1)])
        // L'effort démarre maintenant, pas au début de la séance.
        XCTAssertEqual(engine.progress().remainingInStep ?? -1, 60, accuracy: 0.001)
    }

    func testManualSkipStartsNextStepNow() {
        var engine = IntervalEngine(steps: cdcPlan())
        engine.update(elapsed: 0, distance: 0)
        engine.update(elapsed: 120, distance: 0)   // au milieu de l'échauffement
        let events = engine.advanceManually()

        XCTAssertEqual(events, [.stepFinished(index: 0), .stepStarted(index: 1)])
        XCTAssertEqual(engine.progress().elapsedInStep, 0, accuracy: 0.001,
                       "Sauter une étape ne doit pas amputer la suivante")
        XCTAssertEqual(engine.progress().remainingInStep ?? -1, 60, accuracy: 0.001)
    }

    func testManualAdvanceOnLastStepFinishesThePlan() {
        var engine = IntervalEngine(steps: [CoachPlanStep(kind: .work, label: "libre")])
        engine.update(elapsed: 0, distance: 0)
        XCTAssertEqual(engine.advanceManually(), [.stepFinished(index: 0), .planFinished])
        XCTAssertTrue(engine.isFinished)
        XCTAssertTrue(engine.advanceManually().isEmpty, "Plus rien après la fin")
    }

    // MARK: Robustesse

    func testHalfwayAnnouncedOncePerStep() {
        var engine = IntervalEngine(steps: cdcPlan())
        engine.update(elapsed: 0, distance: 0)
        XCTAssertTrue(engine.update(elapsed: 149, distance: 0).isEmpty)
        XCTAssertEqual(engine.update(elapsed: 150, distance: 0), [.halfway(index: 0)])
        XCTAssertTrue(engine.update(elapsed: 151, distance: 0).isEmpty,
                      "La mi-parcours ne s'annonce qu'une fois")
        XCTAssertTrue(engine.update(elapsed: 200, distance: 0).isEmpty)
    }

    func testGoingBackwardsInTimeIsClamped() {
        // Un appelant fautif ou une reprise après crash peut réinjecter un
        // temps antérieur. Mieux vaut borner que produire des durées négatives
        // qui remonteraient jusqu'à l'affichage.
        var engine = IntervalEngine(steps: cdcPlan())
        engine.update(elapsed: 0, distance: 0)
        engine.update(elapsed: 200, distance: 500)
        engine.update(elapsed: 10, distance: 5)

        XCTAssertEqual(engine.progress().elapsedInStep, 200, accuracy: 0.001)
        XCTAssertEqual(engine.index, 0)
    }

    func testEmptyPlanIsFinishedImmediately() {
        var engine = IntervalEngine(steps: [])
        XCTAssertTrue(engine.isFinished)
        XCTAssertTrue(engine.update(elapsed: 0, distance: 0).isEmpty)
        XCTAssertTrue(engine.progress().isFinished)
    }

    func testReplayingTicksReproducesTheSameState() {
        // Propriété qui rend la reprise après crash triviale : le moteur est
        // une fonction de la suite des ticks, sans horloge interne.
        let ticks = stride(from: 0.0, through: 700.0, by: 3.0)
        var a = IntervalEngine(steps: cdcPlan())
        var b = IntervalEngine(steps: cdcPlan())
        for t in ticks { a.update(elapsed: t, distance: t * 2) }
        for t in ticks { b.update(elapsed: t, distance: t * 2) }
        XCTAssertEqual(a, b)
        XCTAssertEqual(a.progress(), b.progress())
    }

    // MARK: Décodage du plan poussé par l'iPhone

    func testDecodesPlanFromPhonePayload() throws {
        let json = """
        {
          "date": "2026-08-21",
          "sport": "running",
          "title": "CDC · Reprise séance 1",
          "steps": [
            {"kind": "warmup", "duration_sec": 300, "hr_zone": 1,
             "hr_bpm_min": 90, "hr_bpm_max": 105, "label": "5 min marche"},
            {"kind": "work", "duration_sec": 60, "hr_zone": 2,
             "hr_bpm_min": 110, "hr_bpm_max": 125, "label": "1' course, cadence 170+"}
          ]
        }
        """
        let plan = try JSONDecoder().decode(CoachSessionPlan.self, from: Data(json.utf8))
        XCTAssertEqual(plan.steps.count, 2)
        XCTAssertEqual(plan.steps[0].hrMaxBpm, 105)
        XCTAssertEqual(plan.steps[1].displayLabel, "1' course, cadence 170+")
        XCTAssertEqual(plan.plannedDurationSec, 360)
        XCTAssertEqual(plan.steps[1].goal, .time(60))
    }

    func testPlannedDurationIsNilWhenAStepIsOpen() {
        let plan = CoachSessionPlan(date: "2026-08-21", sport: "running", steps: [
            CoachPlanStep(kind: .warmup, durationSec: 300),
            CoachPlanStep(kind: .work, label: "libre"),
        ])
        XCTAssertNil(plan.plannedDurationSec,
                     "Mieux vaut ne rien annoncer qu'annoncer un total faux")
    }

    func testMissingLabelFallsBackToStepKind() {
        XCTAssertEqual(CoachPlanStep(kind: .recovery).displayLabel, "Récupération")
        XCTAssertEqual(CoachPlanStep(kind: .work, label: "   ").displayLabel, "Effort")
    }
}