import 'package:firebase_auth/firebase_auth.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'dart:async';

import '../views/login_page.dart';

import '../providers/local_user_provider.dart';
import '../views/widgets/common/startup_splash_screen.dart';

/// Gate de démarrage qui attend la restauration Firebase Auth avant
/// d'afficher soit le contenu connecté, soit la page de connexion.
class AppStartGate extends StatelessWidget {
  const AppStartGate({super.key});

  @override
  Widget build(BuildContext context) {
    // Sur le web, certaines erreurs natives (ex: cookies tiers bloqués)
    // peuvent faire remonter une FirebaseException sur le stream d'auth.
    // Pour éviter que StreamBuilder reçoive une erreur qui casse le build
    // (TypeError JS interop), on "handleError" et on transforme l'erreur
    // en une valeur nulle (pas d'utilisateur) afin de garder l'app stable.
    // Accès protégé à `FirebaseAuth.instance` — sur le web certaines erreurs
    // d'interop JS peuvent produire des TypeError non compatibles. Nous
    // attrapons toute exception lors de l'accès et fournissons un stream
    // neutre (pas d'utilisateur) afin de garder l'UI stable.
    late final Stream<User?> safeAuthStream;
    try {
      safeAuthStream = FirebaseAuth.instance
          .authStateChanges()
          .handleError((error, stack) {
        // Log pour debug ; ne rethrow pas
        debugPrint('[AppStartGate] authStateChanges error: $error');
      });
    } catch (e, st) {
      // Sur certaines configurations web l'accès à FirebaseAuth.instance
      // peut échouer au niveau JS interop. On log puis on fournit un stream
      // qui émet une seule valeur nulle pour indiquer "pas d'utilisateur".
      debugPrint('[AppStartGate] FirebaseAuth.instance access error: $e\n$st');
      safeAuthStream = Stream<User?>.value(null);
    }

    return StreamBuilder<User?>(
      stream: safeAuthStream,
      builder: (context, snapshot) {
        if (snapshot.connectionState == ConnectionState.waiting) {
          return const StartupSplashScreen();
        }

        if (snapshot.hasError) {
          // En théorie handleError évite d'arriver ici, mais on garde
          // une protection supplémentaire.
          debugPrint('[AppStartGate] snapshot error: ${snapshot.error}');
          return const StartupSplashScreen(message: 'Erreur de connexion');
        }

        if (snapshot.data != null) {
          return const _AuthenticatedBootstrap();
        }

        return const LoginPage();
      },
    );
  }
}

class _AuthenticatedBootstrap extends StatefulWidget {
  const _AuthenticatedBootstrap();

  @override
  State<_AuthenticatedBootstrap> createState() =>
      _AuthenticatedBootstrapState();
}

class _AuthenticatedBootstrapState extends State<_AuthenticatedBootstrap> {
  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addPostFrameCallback((_) {
      _redirectAfterAuth();
    });
  }

  Future<void> _redirectAfterAuth() async {
    final fragment = Uri.base.fragment;

    if (!mounted) return;

    // Charger les données utilisateur de façon non bloquante
    unawaited(
      context.read<LocalUserProvider>().loadUserData().catchError((e) {
        debugPrint('[AppStartGate] User data bootstrap failed: $e');
      }),
    );

    if (fragment.isNotEmpty && fragment != '/' && fragment != '/calendar') {
      Navigator.of(context).pushReplacementNamed(fragment);
    } else {
      Navigator.of(context).pushReplacementNamed('/calendar');
    }
  }

  @override
  Widget build(BuildContext context) {
    return const StartupSplashScreen();
  }
}



