Holzleitner-Lieferservice-App/lib/data/network/keycloak_oidc_token_provider.dart

import 'dart:async';
import 'dart:convert';

import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart' show PlatformException;
import 'package:flutter_appauth/flutter_appauth.dart';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';

import 'auth_session_event.dart';
import 'auth_token_provider.dart';
import 'backend_config.dart';

/// OIDC-Token-Provider gegen Keycloak (PKCE Authorization Code Flow).
///
/// Verantwortlich für:
/// * **Login** über `flutter_appauth` (Browser-Tab → Keycloak →
///   RedirectURI `holzleitner://oauth2redirect`).
/// * **Token-Refresh** mit dem persistierten Refresh-Token.
/// * **Session-Restore** beim App-Start (Refresh-Token aus Secure
///   Storage einlesen + sofortigen Refresh anstoßen).
/// * **Logout**: lokale Token droppen + Secure Storage säubern.
///
/// Access-Token und ID-Token-Claims liegen im Speicher (flüchtig),
/// der Refresh-Token wird in der Plattform-Secure-Storage abgelegt
/// (Keychain / EncryptedSharedPreferences).
///
/// Events werden über [events] gebroadcastet — der AuthBloc abonniert
/// und reagiert. Diese Indirektion vermeidet eine Abhängigkeit auf die
/// Bloc-Schicht.
class KeycloakOidcTokenProvider implements AuthTokenProvider {
  KeycloakOidcTokenProvider({
    required BackendConfig config,
    required this.issuerUrl,
    required this.redirectUrl,
    FlutterAppAuth? appAuth,
    FlutterSecureStorage? storage,
  }) : _config = config,
       _appAuth = appAuth ?? const FlutterAppAuth(),
       _storage = storage ?? const FlutterSecureStorage();

  final BackendConfig _config;
  final FlutterAppAuth _appAuth;
  final FlutterSecureStorage _storage;

  /// Vollständige Issuer-URL ohne `/.well-known/...`-Suffix.
  /// Beispiel: `http://localhost:8080/realms/holzleitner`.
  final String issuerUrl;

  /// Redirect-URI, die im Keycloak-Client erlaubt ist und auf das
  /// Custom-Scheme der App matcht. Beispiel:
  /// `holzleitner://oauth2redirect`.
  final String redirectUrl;

  String? _accessToken;
  DateTime? _expiresAt;
  String? _refreshToken;
  Map<String, dynamic>? _idTokenClaims;

  /// Single-flight-Guard: hält den gerade laufenden Refresh, damit mehrere
  /// gleichzeitige Aufrufer (Bootstrap: Restore + PaymentMethodsCubit +
  /// Folge-Requests) sich EINEN Refresh teilen statt parallele
  /// `flutter_appauth.token()`-Calls auszulösen (die nativ blockieren/haken
  /// können → App hängt nach Hot-Restart am Splash/Login).
  Future<String?>? _refreshInFlight;

  /// Dedup-Sperre für den interaktiven Login: es darf zu jedem Zeitpunkt nur
  /// EIN `authorizeAndExchangeCode` laufen. Ein zweiter Aufruf, während noch
  /// einer offen ist, würde nativ mit „Connection already in progress"
  /// abbrechen — dann bliebe der Browser zu. `null` = kein Login läuft.
  Future<void>? _loginInFlight;

  final StreamController<AuthSessionEvent> _events =
      StreamController<AuthSessionEvent>.broadcast();

  /// Stream der Auth-Events. Wird vom AuthBloc abonniert.
  Stream<AuthSessionEvent> get events => _events.stream;

  /// Discovery-URL für `flutter_appauth` — wird intern auch geprüft,
  /// bevor PKCE losläuft.
  String get _discoveryUrl => '$issuerUrl/.well-known/openid-configuration';

  /// ID-Token-Claims der aktuellen Session, oder `null` wenn nicht
  /// angemeldet.
  Map<String, dynamic>? get idTokenClaims => _idTokenClaims;

  bool get isAuthenticated => _accessToken != null;

  /// Triggert den PKCE-Login-Flow. Wirft, wenn der User abbricht oder
  /// Keycloak einen Fehler liefert.
  ///
  /// Deduped: läuft bereits ein Login, wird dieselbe Future zurückgegeben
  /// statt ein zweites `authorizeAndExchangeCode` zu starten (das nativ mit
  /// „Connection already in progress" bräche → Browser bliebe zu). Nach
  /// einem UI-Timeout gibt der AuthBloc die Sperre via [discardPendingLogin]
  /// frei, damit ein erneuter Tap wieder einen frischen Browser-Tab öffnet.
  Future<void> login() {
    final existing = _loginInFlight;
    if (existing != null) return existing;
    late final Future<void> flow;
    flow = _login().whenComplete(() {
      // Nur freigeben, wenn WIR noch die aktive Login-Future sind. Sonst
      // würde die späte Completion eines per Timeout verworfenen Versuchs
      // die Sperre eines inzwischen neu gestarteten Logins nullen.
      if (identical(_loginInFlight, flow)) _loginInFlight = null;
    });
    _loginInFlight = flow;
    return flow;
  }

  /// Gibt eine (typischerweise per UI-Timeout „aufgegebene") laufende
  /// Login-Future frei. Der native Flow selbst ist nicht abbrechbar — wir
  /// lösen nur unsere Dedup-Sperre, damit der nächste [login]-Aufruf einen
  /// neuen Authorize-Request (frischer Browser-Tab) starten darf.
  void discardPendingLogin() => _loginInFlight = null;

  Future<void> _login() async {
    final result = await _authorize();

    _applyTokens(
      accessToken: result.accessToken,
      refreshToken: result.refreshToken,
      idToken: result.idToken,
      expiresAt: result.accessTokenExpirationDateTime,
    );
    await _persistRefreshToken();

    _events.add(AuthLoggedIn(_idTokenClaims ?? const <String, dynamic>{}));
  }

  /// Führt den nativen Authorize+Exchange aus. Blockiert ein vom vorigen
  /// (verwaisten) Versuch nativ noch offener Flow den Aufruf mit
  /// „Connection already in progress", warten wir kurz und versuchen es
  /// EINMAL erneut — meist ist der alte Custom-Tab dann geschlossen.
  Future<AuthorizationTokenResponse> _authorize() async {
    try {
      return await _appAuth.authorizeAndExchangeCode(_authRequest());
    } on PlatformException catch (e) {
      if (_looksLikeInProgress(e)) {
        debugPrint('Login: nativer Flow noch offen — einmaliger Retry.');
        await Future<void>.delayed(const Duration(milliseconds: 400));
        return _appAuth.authorizeAndExchangeCode(_authRequest());
      }
      rethrow;
    }
  }

  AuthorizationTokenRequest _authRequest() => AuthorizationTokenRequest(
    _config.keycloakClientId,
    redirectUrl,
    discoveryUrl: _discoveryUrl,
    scopes: const ['openid', 'profile'],
    // Lokales Dev-Setup hat HTTP-Keycloak — der Default-iOS-Browser
    // würde sonst abbrechen. In Produktion (HTTPS) ist das ein
    // No-Op und kann bleiben.
    allowInsecureConnections: true,
    // Wichtig auf Android: ohne `prompt=login` würde Keycloak bei
    // bestehender SSO-Session sofort 302 nach holzleitner://...
    // antworten, Chrome schließt den Custom Tab dabei so schnell,
    // dass der Redirect-Intent unsere RedirectUriReceiverActivity
    // gar nicht erreicht — AppAuth meldet stattdessen
    // "User cancelled flow". Erzwingen der Login-Maske → echter
    // User-Click → sauberer Intent-Dispatch.
    promptValues: const ['login'],
  );

  /// Heuristik: erkennt den „ein Authorize läuft bereits"-Fehler von
  /// AppAuth (Android). Kein stabiler Code über Plattformen hinweg, daher
  /// Code + Message defensiv prüfen.
  static bool _looksLikeInProgress(PlatformException e) {
    final haystack = '${e.code} ${e.message}'.toLowerCase();
    return haystack.contains('already in progress') ||
        haystack.contains('in progress') ||
        haystack.contains('concurrent');
  }

  /// Versucht, eine vorhandene Session aus der Secure Storage zu
  /// reaktivieren. Liefert `true`, wenn anschließend ein gültiger
  /// Access-Token verfügbar ist.
  ///
  /// Schluckt Fehler aus dem Storage-Plugin (z. B. nicht-registriertes
  /// Native-Modul nach Plugin-Update ohne Cold-Restart) — der Caller
  /// landet dann sauber im "kein Restore möglich"-Pfad statt mit einer
  /// MissingPluginException auf dem AuthBloc-Stream.
  Future<bool> restoreSession() async {
    final String? stored;
    try {
      stored = await _storage.read(key: _refreshTokenStorageKey);
    } catch (e, st) {
      debugPrint(
        'restoreSession: konnte Refresh-Token nicht lesen: $e\n$st',
      );
      return false;
    }
    if (stored == null || stored.isEmpty) return false;
    _refreshToken = stored;

    final String? token;
    try {
      token = await currentAccessToken();
    } on AuthTemporarilyUnavailableException catch (e) {
      // Beim App-Start gerade kein Netz/VPN: Refresh-Token NICHT verwerfen —
      // der nächste Start (oder Login) kann die Session wieder aufnehmen.
      debugPrint('restoreSession: Refresh vorübergehend nicht möglich: $e');
      return false;
    }
    if (token == null) return false;

    _events.add(AuthLoggedIn(_idTokenClaims ?? const <String, dynamic>{}));
    return true;
  }

  /// Bricht die Session ab — droppt alle Tokens lokal. Ein
  /// serverseitiges `endSession` (Keycloak Single-Logout) machen wir
  /// bewusst nicht: der Refresh-Token läuft beim Server normal aus,
  /// und der ID-Token-Hint würde uns zwingen, den rohen ID-Token mit
  /// in der Session zu halten.
  Future<void> logout() async {
    _clearSession();
    try {
      await _storage.delete(key: _refreshTokenStorageKey);
    } catch (e) {
      debugPrint('logout: Refresh-Token konnte nicht gelöscht werden: $e');
    }
    _events.add(const AuthLoggedOut());
  }

  @override
  Future<String?> currentAccessToken() async {
    final cached = _accessToken;
    final expiresAt = _expiresAt;
    final now = DateTime.now().toUtc();

    // Schwellwert 30 s: Pufferzeit gegen Clock-Drift und
    // mid-flight-Expiry.
    if (cached != null &&
        expiresAt != null &&
        expiresAt.isAfter(now.add(const Duration(seconds: 30)))) {
      return cached;
    }

    final rt = _refreshToken;
    if (rt == null) return null;

    // Single-flight: läuft bereits ein Refresh, hängen wir uns dran, statt
    // einen zweiten `flutter_appauth.token()`-Call zu starten. `??=`
    // evaluiert die rechte Seite nur, wenn noch kein Refresh läuft.
    return _refreshInFlight ??= _performRefresh(rt).whenComplete(() {
      _refreshInFlight = null;
    });
  }

  /// Führt EINEN Token-Refresh aus. Bei Erfolg werden die Tokens übernommen
  /// und der neue Access-Token zurückgegeben (ohne Event — stiller Refresh).
  ///
  /// Fehler werden unterschieden:
  /// * **Abgelehnt** (OAuth `invalid_grant` o. ä.: Refresh-Token abgelaufen/
  ///   widerrufen, SSO-Session beendet) → Session ist tot: lokal aufräumen,
  ///   `AuthSessionExpired` emittieren, `null` zurück.
  /// * **Vorübergehend** (Netz/VPN/Timeout/Server kurz weg) → Session
  ///   BEHALTEN; noch gültigen Access-Token weiterverwenden, sonst
  ///   [AuthTemporarilyUnavailableException] werfen. Früher beendete jeder
  ///   Netz-Hänger die Session und löschte den Refresh-Token.
  Future<String?> _performRefresh(String rt) async {
    try {
      final result = await _appAuth.token(
        TokenRequest(
          _config.keycloakClientId,
          redirectUrl,
          discoveryUrl: _discoveryUrl,
          refreshToken: rt,
          scopes: const ['openid', 'profile'],
          allowInsecureConnections: true,
        ),
      );
      _applyTokens(
        accessToken: result.accessToken,
        refreshToken: result.refreshToken ?? rt,
        idToken: result.idToken,
        expiresAt: result.accessTokenExpirationDateTime,
      );
      await _persistRefreshToken();
      return _accessToken;
    } on Exception catch (e) {
      if (!_isSessionRejected(e)) {
        // Vorübergehender Fehler (Mobilfunk-/VPN-Aussetzer, Timeout, Keycloak
        // kurz nicht erreichbar): die Session ist NICHT tot. Refresh-Token
        // behalten und beim nächsten Request erneut versuchen — sonst zwingt
        // jeder Netz-Hänger den Fahrer zum Neu-Login.
        debugPrint('Token-Refresh vorübergehend fehlgeschlagen: $e');
        final cached = _accessToken;
        final expiresAt = _expiresAt;
        if (cached != null &&
            expiresAt != null &&
            expiresAt.isAfter(DateTime.now().toUtc())) {
          // Bisheriger Access-Token ist noch (kurz) gültig → weiterverwenden.
          return cached;
        }
        throw AuthTemporarilyUnavailableException(e);
      }
      // Keycloak hat den Refresh-Token ABGELEHNT — Session ist tot, nicht
      // wiederherstellbar. Reihenfolge bewusst: erst State leeren + Event
      // feuern, DANN best-effort den Storage löschen — so kann ein
      // werfendes `delete` weder das Event verschlucken noch eine Exception
      // aus `currentAccessToken()` leaken.
      _clearSession();
      _events.add(const AuthSessionExpired());
      try {
        await _storage.delete(key: _refreshTokenStorageKey);
      } catch (e) {
        debugPrint('currentAccessToken: Refresh-Token-Delete fehlgeschlagen: $e');
      }
      return null;
    }
  }

  /// OAuth-Fehler, bei denen ein erneuter Versuch sinnlos ist: der
  /// Authorization-Server hat den Refresh endgültig abgelehnt.
  static const Set<String> _fatalOAuthErrors = {
    FlutterAppAuthOAuthError.invalidGrant,
    FlutterAppAuthOAuthError.invalidClient,
    FlutterAppAuthOAuthError.unauthorizedClient,
  };

  /// `true`, wenn der Fehler eine echte **Ablehnung** durch Keycloak ist
  /// (Session wirklich beendet). Alles andere — Netzwerk, Timeout, 5xx —
  /// gilt als vorübergehend. Primär über den strukturierten OAuth-Fehlercode
  /// von `flutter_appauth`; als Fallback die Textsuche nach `invalid_grant`.
  static bool _isSessionRejected(Object e) {
    if (e is FlutterAppAuthPlatformException) {
      final oauthError = e.platformErrorDetails.error;
      if (oauthError != null) return _fatalOAuthErrors.contains(oauthError);
    }
    if (e is PlatformException) {
      final haystack = '${e.code} ${e.message} ${e.details}'.toLowerCase();
      return haystack.contains('invalid_grant');
    }
    return false;
  }

  void _applyTokens({
    required String? accessToken,
    required String? refreshToken,
    required String? idToken,
    required DateTime? expiresAt,
  }) {
    _accessToken = accessToken;
    _refreshToken = refreshToken;
    _expiresAt = expiresAt?.toUtc();
    if (idToken != null) {
      _idTokenClaims = _decodeJwtPayload(idToken);
    }
  }

  Future<void> _persistRefreshToken() async {
    final rt = _refreshToken;
    if (rt == null) return;
    try {
      await _storage.write(key: _refreshTokenStorageKey, value: rt);
    } catch (e) {
      // Nicht fatal — Refresh-Token bleibt in-memory verfügbar,
      // wir verlieren nur das Restore-Verhalten beim nächsten Start.
      debugPrint('Refresh-Token konnte nicht persistiert werden: $e');
    }
  }

  void _clearSession() {
    _accessToken = null;
    _expiresAt = null;
    _refreshToken = null;
    _idTokenClaims = null;
  }

  /// Dispose-Hook für Tests / Hot-Restarts.
  Future<void> dispose() async {
    await _events.close();
  }

  static const String _refreshTokenStorageKey =
      'holzleitner_keycloak_refresh_token';

  /// Dekodiert das Payload-Segment eines JWT. Wirft bei strukturellen
  /// Auffälligkeiten — Signatur wird **nicht** geprüft (das macht der
  /// Server bei jedem Request neu).
  static Map<String, dynamic> _decodeJwtPayload(String token) {
    final parts = token.split('.');
    if (parts.length != 3) {
      throw FormatException('Token-Format unerwartet: ${parts.length} Teile');
    }
    String payload = parts[1];
    // base64url ohne Padding → wieder padden, sonst wirft base64Url.decode.
    switch (payload.length % 4) {
      case 0:
        break;
      case 2:
        payload += '==';
      case 3:
        payload += '=';
      default:
        throw const FormatException('Token-Payload hat ungültige Länge');
    }
    final bytes = base64Url.decode(payload);
    final json = utf8.decode(bytes);
    final decoded = jsonDecode(json);
    if (decoded is! Map<String, dynamic>) {
      throw const FormatException('Token-Payload ist kein JSON-Objekt');
    }
    return decoded;
  }
}