RouterOS/RouterOSAssistant/Features/Wizard/Steps/Connect/ConnectView.swift

import SwiftUI

struct ConnectView: View {
    @ObservedObject private var connectionService: ConnectionService
    @StateObject private var viewModel: ConnectViewModel
    @StateObject private var backupViewModel = BackupViewModel()
    @State private var showUpdateInstallConfirmation = false
    @State private var showFirmwareUpgradeConfirmation = false
    @State private var showRebootConfirmation = false

    init(connectionService: ConnectionService) {
        self.connectionService = connectionService
        _viewModel = StateObject(wrappedValue: ConnectViewModel(connectionService: connectionService))
    }

    var body: some View {
        mainContent
            .withUpdateDialogs(viewModel: viewModel, connectionService: connectionService, showUpdateInstallConfirmation: $showUpdateInstallConfirmation, showFirmwareUpgradeConfirmation: $showFirmwareUpgradeConfirmation)
            .withRebootDialogs(viewModel: viewModel, connectionService: connectionService, isPresented: $showRebootConfirmation)
    }

    /// Split out of `body` — same reasoning as `BackupListView.restoreAwareContent` (Bug 19 in
    /// HANDOFF.md): too many `.alert`/`.confirmationDialog` modifiers chained onto one view times
    /// out the Swift type-checker with a misleading error location, not an actual logic issue.
    private var mainContent: some View {
        NavigationSplitView {
            Form {
                Section("Verbindung") {
                    TextField("IP-Adresse oder Hostname", text: $viewModel.host)
                        .help("Die Adresse deines Routers im Netzwerk. Werkseinstellung bei Mikrotik ist meist 192.168.88.1.")
                    TextField("Benutzername", text: $viewModel.username)
                        .help("Der Admin-Benutzername deines Routers. Werkseinstellung ist meist \"admin\".")
                    SecureField("Passwort", text: $viewModel.password)
                        .help("Das Passwort für diesen Benutzer. Bei unverändertem Werkszustand oft leer.")
                    Toggle("Passwort merken", isOn: $viewModel.rememberPassword)
                        .help("Speichert das Passwort verschlüsselt in der macOS-Schlüsselbundverwaltung, damit du es nicht jedes Mal neu eingeben musst.")
                }

                Section {
                    Button("Verbinden") {
                        viewModel.connect()
                    }
                    .disabled(viewModel.host.isEmpty || viewModel.username.isEmpty)
                }

                statusSection
            }
            .formStyle(.grouped)
            .frame(minWidth: 320)
        } detail: {
            deviceDetail
        }
        .onAppear {
            viewModel.onAppear()
            backupViewModel.load()
        }
        .alert(
            "Unbekanntes Zertifikat",
            isPresented: certificateAlertBinding,
            presenting: certificateFingerprint
        ) { fingerprint in
            Button("Vertrauen und verbinden") {
                viewModel.trustAndRetry(fingerprint: fingerprint)
            }
            Button("Abbrechen", role: .cancel) {}
        } message: { fingerprint in
            Text("Der Router hat sich mit einem unbekannten Zertifikat gemeldet.\nFingerabdruck: \(fingerprint)\n\nNur bestätigen, wenn dies dein eigenes Gerät im lokalen Netzwerk ist.")
        }
        .alert(
            "Unbekannter SSH-Schlüssel",
            isPresented: sshHostKeyAlertBinding,
            presenting: sshHostKeyFingerprint
        ) { fingerprint in
            Button("Vertrauen und verbinden") {
                viewModel.trustSSHHostKeyAndRetry(fingerprint: fingerprint)
            }
            Button("Abbrechen", role: .cancel) {}
        } message: { fingerprint in
            Text("Der Router hat sich mit einem unbekannten SSH-Schlüssel gemeldet.\nFingerabdruck: \(fingerprint)\n\nNur bestätigen, wenn dies dein eigenes Gerät im lokalen Netzwerk ist. Falls du diesen Router schon einmal verbunden hattest und sich der Fingerabdruck geändert hat, könnte das auf ein manipuliertes Netzwerk hindeuten — im Zweifel nicht bestätigen.")
        }
        .alert(
            "Sicherung fehlgeschlagen",
            isPresented: Binding(
                get: { backupViewModel.errorMessage != nil },
                set: { _ in backupViewModel.errorMessage = nil }
            ),
            presenting: backupViewModel.errorMessage
        ) { _ in
            Button("OK") {}
        } message: { message in
            Text(message)
        }
    }

    private var certificateFingerprint: String? {
        if case .needsCertificateConfirmation(let fingerprint) = connectionService.state {
            return fingerprint
        }
        return nil
    }

    private var certificateAlertBinding: Binding<Bool> {
        Binding(
            get: { certificateFingerprint != nil },
            set: { _ in }
        )
    }

    private var sshHostKeyFingerprint: String? {
        if case .needsSSHHostKeyConfirmation(let fingerprint) = connectionService.state {
            return fingerprint
        }
        return nil
    }

    private var sshHostKeyAlertBinding: Binding<Bool> {
        Binding(
            get: { sshHostKeyFingerprint != nil },
            set: { _ in }
        )
    }

    @ViewBuilder
    private var statusSection: some View {
        switch connectionService.state {
        case .idle, .needsCertificateConfirmation, .needsSSHHostKeyConfirmation:
            EmptyView()
        case .connecting:
            Section {
                HStack {
                    ProgressView()
                    Text("Verbinde…")
                }
            }
        case .connected(let kind):
            Section {
                Label("Verbunden (\(kind == .rest ? "REST-API" : "SSH"))", systemImage: "checkmark.circle.fill")
                    .foregroundStyle(.green)

                Button("Trennen", role: .destructive) {
                    Task { await connectionService.disconnect() }
                }
                .help("Beendet die Verbindung zum Router. Zugangsdaten bleiben erhalten (falls gemerkt).")

                Button {
                    if let credentials = connectionService.credentials {
                        backupViewModel.createBackup(for: credentials)
                    }
                } label: {
                    if backupViewModel.isCreatingBackup {
                        HStack {
                            ProgressView()
                            Text("Sichere…")
                        }
                    } else {
                        Label("Jetzt sichern", systemImage: "square.and.arrow.down")
                    }
                }
                .disabled(backupViewModel.isCreatingBackup)
                .help("Sichert die aktuelle Router-Konfiguration — sinnvoll direkt nach dem Verbinden, bevor du im Einrichten-Tab etwas änderst.")

                if let lastBackup = backupViewModel.backups.first(where: { $0.host == connectionService.credentials?.host }) {
                    Label(
                        "Zuletzt gesichert: \(lastBackup.createdAt.formatted(date: .abbreviated, time: .standard))",
                        systemImage: "checkmark"
                    )
                    .font(.caption)
                    .foregroundStyle(.secondary)
                }
            }
        case .failed(let message):
            Section {
                Label(message, systemImage: "exclamationmark.triangle.fill")
                    .foregroundStyle(.red)
            }
        }
    }

    @ViewBuilder
    private var deviceDetail: some View {
        if let info = connectionService.deviceInfo {
            Form {
                Section("Gerät") {
                    LabeledContent("Modell", value: info.boardName)
                    LabeledContent("RouterOS-Version", value: info.routerOSVersion)
                    LabeledContent("Architektur", value: info.architecture)
                    LabeledContent("Laufzeit", value: info.uptime)
                }
                if let board = connectionService.routerBoardInfo {
                    Section("Routerboard") {
                        LabeledContent("Modell (RB-Code)", value: board.model)
                        LabeledContent("Revision", value: board.revision)
                        LabeledContent("Seriennummer", value: board.serialNumber)
                            .textSelection(.enabled)
                        LabeledContent("Firmware-Typ", value: board.firmwareType)
                        LabeledContent("Firmware (aktuell)", value: board.currentFirmware)
                        LabeledContent("Firmware (minimal)", value: board.minimumFirmware)
                        LabeledContent("Firmware (verfügbar)", value: board.upgradeFirmware)
                        // Confirmed via docs: same value = up to date, different = a bootloader
                        // update is available (only ever becomes available after installing a
                        // newer RouterOS package first — the firmware ships bundled inside it).
                        if board.currentFirmware != board.upgradeFirmware {
                            Label("Firmware-Update verfügbar", systemImage: "arrow.up.circle.fill")
                                .foregroundStyle(.orange)
                            Button {
                                showFirmwareUpgradeConfirmation = true
                            } label: {
                                if viewModel.isUpgradingFirmware {
                                    HStack { ProgressView(); Text("Aktualisiere…") }
                                } else {
                                    Label("Firmware aktualisieren", systemImage: "arrow.up.circle")
                                }
                            }
                            .disabled(viewModel.isUpgradingFirmware)
                        } else {
                            Label("Firmware aktuell", systemImage: "checkmark.circle")
                                .font(.caption)
                                .foregroundStyle(.secondary)
                        }
                        if let message = viewModel.firmwareUpgradeResultMessage {
                            Text(message).font(.caption).foregroundStyle(.secondary)
                            Button {
                                showRebootConfirmation = true
                            } label: {
                                if viewModel.isRebooting {
                                    HStack { ProgressView(); Text("Starte neu…") }
                                } else {
                                    Label("Jetzt neu starten", systemImage: "arrow.clockwise")
                                }
                            }
                            .disabled(viewModel.isRebooting)
                            .help("Nötig, damit die neu geschriebene Firmware aktiv wird — passiert nicht automatisch.")
                        }
                    }
                }
                Section("Software-Update") {
                    if let update = viewModel.packageUpdateInfo {
                        LabeledContent("Kanal", value: update.channel)
                        LabeledContent("Installiert", value: update.installedVersion)
                        LabeledContent("Neueste Version", value: update.latestVersion)
                        LabeledContent("Status", value: update.status)
                        if update.status == "New version is available" {
                            Button {
                                showUpdateInstallConfirmation = true
                            } label: {
                                if viewModel.isInstallingUpdate {
                                    HStack { ProgressView(); Text("Installiere…") }
                                } else {
                                    Label("Update installieren", systemImage: "arrow.down.circle")
                                }
                            }
                            .disabled(viewModel.isInstallingUpdate)
                        }
                    }
                    Button {
                        if let credentials = connectionService.credentials {
                            viewModel.checkForUpdates(for: credentials)
                        }
                    } label: {
                        if viewModel.isCheckingForUpdates {
                            HStack { ProgressView(); Text("Prüfe…") }
                        } else {
                            Label("Jetzt prüfen", systemImage: "arrow.triangle.2.circlepath")
                        }
                    }
                    .disabled(viewModel.isCheckingForUpdates)
                    .help("Prüft bei MikroTik, ob eine neuere RouterOS-Version verfügbar ist. Braucht Internetzugang auf dem Router.")

                    if viewModel.didSendUpdateInstall {
                        Label(
                            "Update-Befehl gesendet — der Router lädt herunter, installiert und startet danach automatisch neu.",
                            systemImage: "arrow.clockwise"
                        )
                        .font(.caption)
                    }
                }
                Section("Interfaces") {
                    ForEach(connectionService.interfaces) { interface in
                        HStack {
                            Image(systemName: interface.running ? "circle.fill" : "circle")
                                .foregroundStyle(interface.running ? .green : .secondary)
                                .font(.caption)
                            VStack(alignment: .leading) {
                                Text(interface.name).bold()
                                Text(interface.type).font(.caption).foregroundStyle(.secondary)
                            }
                        }
                    }
                }
            }
            .formStyle(.grouped)
        } else {
            ContentUnavailableView(
                "Nicht verbunden",
                systemImage: "network.slash",
                description: Text("Verbinde dich mit deinem Router, um Geräteinformationen zu sehen.")
            )
        }
    }
}

/// Split into two small functions (software-update dialogs, firmware-upgrade dialogs), not one
/// big one — same Bug 19 reasoning as `mainContent`'s own split: keep each modifier chain short
/// enough that the type-checker doesn't time out.
private extension View {
    func withUpdateDialogs(
        viewModel: ConnectViewModel,
        connectionService: ConnectionService,
        showUpdateInstallConfirmation: Binding<Bool>,
        showFirmwareUpgradeConfirmation: Binding<Bool>
    ) -> some View {
        self
            .withSoftwareUpdateDialogs(viewModel: viewModel, connectionService: connectionService, isPresented: showUpdateInstallConfirmation)
            .withFirmwareUpgradeDialogs(viewModel: viewModel, connectionService: connectionService, isPresented: showFirmwareUpgradeConfirmation)
    }

    func withSoftwareUpdateDialogs(viewModel: ConnectViewModel, connectionService: ConnectionService, isPresented: Binding<Bool>) -> some View {
        self
            .confirmationDialog(
                "RouterOS-Update installieren?",
                isPresented: isPresented,
                titleVisibility: .visible
            ) {
                Button("Installieren", role: .destructive) {
                    if let credentials = connectionService.credentials {
                        viewModel.installUpdate(for: credentials)
                    }
                }
                Button("Abbrechen", role: .cancel) {}
            } message: {
                Text("Lädt RouterOS \(viewModel.packageUpdateInfo?.latestVersion ?? "die neueste Version") herunter, installiert es und startet den Router danach automatisch neu — die Verbindung geht dabei verloren. Vorher am besten eine Sicherung erstellen (\"Jetzt sichern\" oben).")
            }
            .onChange(of: viewModel.didSendUpdateInstall) { _, didSend in
                if didSend {
                    Task { await connectionService.disconnect() }
                }
            }
            .alert(
                "Update-Prüfung fehlgeschlagen",
                isPresented: Binding(
                    get: { viewModel.updateCheckError != nil },
                    set: { _ in viewModel.updateCheckError = nil }
                ),
                presenting: viewModel.updateCheckError
            ) { _ in
                Button("OK") {}
            } message: { message in
                Text(message)
            }
            .alert(
                "Update-Installation fehlgeschlagen",
                isPresented: Binding(
                    get: { viewModel.installUpdateError != nil },
                    set: { _ in viewModel.installUpdateError = nil }
                ),
                presenting: viewModel.installUpdateError
            ) { _ in
                Button("OK") {}
            } message: { message in
                Text(message)
            }
    }

    func withFirmwareUpgradeDialogs(viewModel: ConnectViewModel, connectionService: ConnectionService, isPresented: Binding<Bool>) -> some View {
        self
            .confirmationDialog(
                "Routerboard-Firmware aktualisieren?",
                isPresented: isPresented,
                titleVisibility: .visible
            ) {
                Button("Aktualisieren", role: .destructive) {
                    if let credentials = connectionService.credentials {
                        viewModel.upgradeRouterboardFirmware(for: credentials)
                    }
                }
                Button("Abbrechen", role: .cancel) {}
            } message: {
                Text("Schreibt die neue Bootloader-Firmware auf den Router. Danach ist ein manueller Neustart nötig — passiert nicht automatisch. Dieser Befehl fragt in einer interaktiven Sitzung normalerweise erst nach Bestätigung; ob das über diese App genauso abläuft, ist nicht abschließend getestet (ähnlich interaktive Befehle liefen bisher aber problemlos). Falls die App hier ungewöhnlich lange ohne Rückmeldung bleibt, bitte melden.")
            }
            .alert(
                "Firmware-Aktualisierung fehlgeschlagen",
                isPresented: Binding(
                    get: { viewModel.firmwareUpgradeError != nil },
                    set: { _ in viewModel.firmwareUpgradeError = nil }
                ),
                presenting: viewModel.firmwareUpgradeError
            ) { _ in
                Button("OK") {}
            } message: { message in
                Text(message)
            }
    }

    func withRebootDialogs(viewModel: ConnectViewModel, connectionService: ConnectionService, isPresented: Binding<Bool>) -> some View {
        self
            .confirmationDialog(
                "Router jetzt neu starten?",
                isPresented: isPresented,
                titleVisibility: .visible
            ) {
                Button("Neu starten", role: .destructive) {
                    if let credentials = connectionService.credentials {
                        viewModel.reboot(for: credentials)
                    }
                }
                Button("Abbrechen", role: .cancel) {}
            } message: {
                Text("Startet den Router sofort neu. Die Verbindung geht dabei kurz verloren, danach im Tab \"Verbinden\" erneut verbinden.")
            }
            .onChange(of: viewModel.didSendReboot) { _, didSend in
                if didSend {
                    Task { await connectionService.disconnect() }
                }
            }
            .alert(
                "Neustart fehlgeschlagen",
                isPresented: Binding(
                    get: { viewModel.rebootError != nil },
                    set: { _ in viewModel.rebootError = nil }
                ),
                presenting: viewModel.rebootError
            ) { _ in
                Button("OK") {}
            } message: { message in
                Text(message)
            }
    }
}

#Preview {
    ConnectView(connectionService: ConnectionService())
}