Flaro/Flixy/Session/PlaybackDiagnostics.swift

import Foundation
import Observation
import FlixyPlayback

/// Hält fest, was beim letzten Abspielversuch passiert ist.
///
/// Der Player verschwindet, wenn man ihn schließt — und mit ihm jeder Hinweis
/// darauf, woran es lag. Dieser Mitschnitt überlebt das und steht in den
/// Einstellungen. Aus „es läuft nicht" wird damit „umgepackt, lokale
/// Verbindung, hängt bei Öffnen" — ein Unterschied, der Stunden spart.
@MainActor
@Observable
final class PlaybackDiagnostics {
    struct Attempt: Identifiable {
        let id = UUID()
        let startedAt: Date
        var title: String
        var method: String
        var connection: String
        /// Die Adresse ohne Abfrageteil.
        ///
        /// Der Token steckt in der Abfrage. Er hat in einem Protokoll nichts
        /// zu suchen — es landet in Screenshots, und wer ihn hat, kommt an die
        /// ganze Mediathek.
        var sourceDescription: String
        var steps: [String] = []
        var outcome: String?
    }

    private(set) var lastAttempt: Attempt?

    func begin(title: String, connection: String?) {
        lastAttempt = Attempt(
            startedAt: Date(),
            title: title,
            method: "—",
            connection: connection ?? "—",
            sourceDescription: "—"
        )
        note("Player geöffnet")
    }

    func record(decision: PlaybackDecision, source: URL) {
        lastAttempt?.method = Self.describe(decision)
        lastAttempt?.sourceDescription = Self.describe(source)
        note("Quelle gewählt")
    }

    /// Ein Zwischenschritt, mit Zeitabstand zum Beginn.
    ///
    /// Der Abstand ist die eigentliche Auskunft: steht zwischen „Quelle
    /// gewählt" und „spielt" eine Minute, liegt es an der Leitung; kommt
    /// „spielt" gar nicht, am Engine.
    func note(_ step: String) {
        guard var attempt = lastAttempt else { return }
        let elapsed = Date().timeIntervalSince(attempt.startedAt)
        attempt.steps.append(String(format: "%.1fs  %@", elapsed, step))
        lastAttempt = attempt
    }

    func finish(outcome: String) {
        lastAttempt?.outcome = outcome
        note(outcome)
    }

    private static func describe(_ decision: PlaybackDecision) -> String {
        switch decision.method {
        case .directPlay:
            "Direkt" 
        case .remux:
            decision.rationale.contains { if case .audioCodecUnsupported = $0 { true } else { false } }
                ? "Umgepackt · Bild unverändert, Ton umgerechnet"
                : "Umgepackt · MP4, ohne Neukodierung"
        case .transcode(let limit):
            limit.map { "Transcode · max. \($0 / 1000) Mbit" } ?? "Transcode"
        }
    }


    private static func describe(_ url: URL) -> String {
        guard var components = URLComponents(url: url, resolvingAgainstBaseURL: false) else {
            return "—"
        }
        components.query = nil
        return components.string ?? "—"
    }
}