Camper-Monitor/CamperMonitorWatch/Views/WatchLevelView.swift

import SwiftUI

/// Nivellierung auf der Uhr.
///
/// Die Werte kommen bevorzugt **direkt vom Sensor** (`WatchLevelRadio`); nur
/// wenn der gerade nicht erreichbar ist, tritt der zuletzt über das iPhone
/// gemeldete Stand an seine Stelle. Woher sie stammen, steht unten – ein alter
/// Wert sieht sonst aus wie ein stillstehendes Fahrzeug.
///
/// Kalibriert wird hier nichts. Das gehört einmalig ans iPhone, mit ebenem
/// Fahrzeug und Ruhe dafür; auf der Uhr wäre der Knopf nur eine Gelegenheit,
/// die Nullage aus Versehen zu verstellen.
struct WatchLevelView: View {
    @Environment(PhoneLink.self) private var link
    @Environment(WatchLevelRadio.self) private var radio
    @AppStorage("levelDisplayStyle") private var showsVehicle = true

    private var reading: WatchLevelReading { WatchLevelReading(radio: radio, phone: link) }

    var body: some View {
        ScrollView {
            VStack(spacing: 8) {
                if showsVehicle {
                    WatchVehicleView(pitch: reading.state.pitch, roll: reading.state.roll)
                } else {
                    WatchBubble(pitch: reading.state.pitch, roll: reading.state.roll)
                        .frame(maxWidth: 110)
                    HStack(spacing: 14) {
                        angle("Längs", reading.state.pitch)
                        angle("Quer", reading.state.roll)
                    }
                }

                Text(reading.state.instruction ?? "Keine Werte")
                    .font(.footnote.weight(.medium))
                    .multilineTextAlignment(.center)
                    .foregroundStyle(reading.state.isLevel ? .green : .primary)

                if let wedges = wedgeText {
                    Text(wedges)
                        .font(.caption2)
                        .foregroundStyle(.secondary)
                        .multilineTextAlignment(.center)
                }

                NavigationLink {
                    WatchAlignView()
                } label: {
                    Label("Ausrichten", systemImage: "arrow.left.and.right")
                }
                .buttonStyle(.borderedProminent)

                Button {
                    showsVehicle.toggle()
                } label: {
                    Label(showsVehicle ? "Libelle" : "Fahrzeug",
                          systemImage: showsVehicle ? "circle.circle" : "box.truck")
                }
                .font(.caption2)

                SourceNote(reading: reading)
            }
            .padding(.horizontal, 4)
        }
        .navigationTitle("Nivellierung")
    }

    private func angle(_ title: String, _ value: Double?) -> some View {
        VStack(spacing: 0) {
            Text(value.map { String(format: "%.1f°", $0) } ?? "–")
                .font(.title3.weight(.semibold))
                .monospacedDigit()
            Text(title)
                .font(.caption2)
                .foregroundStyle(.secondary)
        }
    }

    /// Wie hoch die Auffahrkeile sein müssen – reine Geometrie, und nur zu
    /// haben, wenn im Fahrzeugprofil Spurweite und Radstand stehen.
    private var wedgeText: String? {
        guard let profile = link.payload?.profile else { return nil }
        var parts: [String] = []
        if let roll = reading.state.roll, let width = profile.trackWidth,
           let wedge = LevelingWedge.across(roll: roll, trackWidth: width) {
            parts.append(String(format: "%.0f cm %@", wedge.heightInCentimetres, wedge.side.text))
        }
        if let pitch = reading.state.pitch, let base = profile.wheelbase,
           let wedge = LevelingWedge.along(pitch: pitch, wheelbase: base) {
            parts.append(String(format: "%.0f cm %@", wedge.heightInCentimetres, wedge.side.text))
        }
        return parts.isEmpty ? nil : "Keile: " + parts.joined(separator: ", ")
    }
}

/// Woher die angezeigte Neigung kommt und wie alt sie ist.
struct SourceNote: View {
    let reading: WatchLevelReading

    var body: some View {
        TimelineView(.periodic(from: .now, by: 1)) { context in
            let age = reading.age(now: context.date)
            Label {
                Text(text(age: age))
            } icon: {
                Image(systemName: reading.isDirect
                      ? "antenna.radiowaves.left.and.right" : "iphone.gen3")
            }
            .font(.system(size: 10))
            .foregroundStyle(age > 5 ? .orange : .secondary)
        }
    }

    private func text(age: TimeInterval) -> String {
        guard reading.hasReading else { return reading.statusText }
        let source = reading.isDirect ? "Sensor" : "iPhone"
        if age < 3 { return "\(source), eben gemessen" }
        // Steht der Wert, gehört der Grund dazu und nicht nur das Alter.
        if age < 90 { return String(format: "%@, vor %.0f s · %@", source, age, reading.statusText) }
        return String(format: "%@, vor %.0f min · %@", source, age / 60, reading.statusText)
    }
}

/// Die angezeigte Neigung samt Herkunft.
///
/// Die eigene Verbindung hat Vorrang, solange sie **frisch** ist. Das „solange“
/// ist der Punkt: Bleibt der Sensor stehen, ohne die Verbindung zu trennen,
/// würde ein einmal gelesener Wert sonst für immer stehenbleiben – und eine
/// eingefrorene Anzeige ist beim Ausrichten schlimmer als gar keine. Dann tritt
/// der Stand des iPhones an seine Stelle, und wenn auch der fehlt, bleibt der
/// alte Wert stehen, aber mit seinem Alter daneben.
struct WatchLevelReading {
    let state: LevelState
    let isDirect: Bool
    let measuredAt: Date?
    let statusText: String

    /// Ab hier gilt ein direkt gemessener Wert als überholt. Gefragt wird
    /// zweimal je Sekunde ab; drei Sekunden Stille sind schon viel.
    static let directLifetime: TimeInterval = 3

    init(radio: WatchLevelRadio, phone: PhoneLink, now: Date = Date()) {
        let directAge = radio.updatedAt.map { now.timeIntervalSince($0) }
        let hasFreshDirect = radio.state.hasReading
            && (directAge ?? .infinity) <= Self.directLifetime
        let relayed = phone.payload?.levelDevice

        if hasFreshDirect {
            state = radio.state
            isDirect = true
            measuredAt = radio.updatedAt
            statusText = radio.statusText
        } else if let relayed, let level = relayed.level {
            state = level
            isDirect = false
            measuredAt = relayed.snapshot?.timestamp ?? phone.payload?.generatedAt
            statusText = relayed.link.label
        } else if radio.state.hasReading {
            state = radio.state
            isDirect = true
            measuredAt = radio.updatedAt
            statusText = radio.statusText
        } else {
            state = LevelState()
            isDirect = false
            measuredAt = nil
            statusText = radio.statusText
        }
    }

    var hasReading: Bool { state.hasReading }

    func age(now: Date = Date()) -> TimeInterval {
        guard let measuredAt else { return 0 }
        return now.timeIntervalSince(measuredAt)
    }
}