import 'dart:async';
import 'package:afterwork/data/datasources/user_remote_data_source.dart';
import 'package:afterwork/data/models/user_model.dart';
import 'package:afterwork/data/services/preferences_helper.dart';
import 'package:afterwork/data/services/secure_storage.dart';
import 'package:afterwork/presentation/screens/home/home_screen.dart';
import 'package:flutter/material.dart';
import 'package:flutter_spinkit/flutter_spinkit.dart';
import 'package:fluttertoast/fluttertoast.dart';
import 'package:http/http.dart' as http;
import 'package:loading_icon_button/loading_icon_button.dart';
import 'package:provider/provider.dart';

import '../../../core/errors/exceptions.dart';
import '../../../core/theme/theme_provider.dart';
import '../../../data/datasources/event_remote_data_source.dart';
import '../signup/SignUpScreen.dart';

/// L'écran de connexion où les utilisateurs peuvent s'authentifier.
/// Toutes les actions sont loguées pour permettre un suivi dans le terminal et détecter les erreurs.
class LoginScreen extends StatefulWidget {
  const LoginScreen({super.key});

  @override
  _LoginScreenState createState() => _LoginScreenState();
}

class _LoginScreenState extends State<LoginScreen>
    with SingleTickerProviderStateMixin {
  // Clé globale pour la validation du formulaire
  final _formKey = GlobalKey<FormState>();

  // Variables pour stocker l'email et le mot de passe saisis par l'utilisateur
  String _email = '';
  String _password = '';

  // États de l'écran
  bool _isPasswordVisible = false; // Pour basculer la visibilité du mot de passe
  bool _isSubmitting = false; // Indique si la soumission du formulaire est en cours
  bool _showErrorMessage = false; // Affiche un message d'erreur si nécessaire

  // Sources de données et services
  final UserRemoteDataSource _userRemoteDataSource = UserRemoteDataSource(http.Client());
  final SecureStorage _secureStorage = SecureStorage();
  final PreferencesHelper _preferencesHelper = PreferencesHelper();

  // Contrôleur pour le bouton de chargement
  final _btnController = LoadingButtonController();

  // Contrôleur d'animation pour gérer la transition entre les écrans
  late AnimationController _animationController;

  @override
  void initState() {
    super.initState();
    _animationController = AnimationController(
      vsync: this,
      duration: const Duration(milliseconds: 500),
    );
    debugPrint("[LOG] Contrôleur d'animation initialisé.");
  }

  @override
  void dispose() {
    _animationController.dispose();
    debugPrint("[LOG] Ressources d'animation libérées.");
    super.dispose();
  }

  /// Bascule la visibilité du mot de passe et logue l'état actuel.
  void _togglePasswordVisibility() {
    setState(() {
      _isPasswordVisible = !_isPasswordVisible;
    });
    debugPrint("[LOG] Visibilité du mot de passe basculée: $_isPasswordVisible");
  }

  /// Affiche un toast avec le message spécifié et logue l'action.
  void _showToast(String message) {
    Fluttertoast.showToast(
      msg: message,
      toastLength: Toast.LENGTH_SHORT,
      gravity: ToastGravity.BOTTOM,
      timeInSecForIosWeb: 1,
      backgroundColor: Colors.black,
      textColor: Colors.white,
      fontSize: 16.0,
    );
    debugPrint("[LOG] Toast affiché : $message");
  }

  /// Soumet le formulaire de connexion et tente d'authentifier l'utilisateur.
  /// Toutes les étapes et erreurs sont loguées pour une traçabilité complète.
  Future<void> _submit() async {
    debugPrint("[LOG] Tentative de soumission du formulaire de connexion.");

    if (_formKey.currentState!.validate()) {
      setState(() {
        _isSubmitting = true;
        _showErrorMessage = false;
      });
      _formKey.currentState!.save(); // Sauvegarde des données saisies

      try {
        _btnController.start(); // Démarre l'animation de chargement du bouton
        debugPrint("[LOG] Appel à l'API pour authentifier l'utilisateur.");

        // Appel à l'API pour authentifier l'utilisateur
        final UserModel user = await _userRemoteDataSource.authenticateUser(_email, _password);

        // Validation de l'ID utilisateur
        if (user.userId.isNotEmpty) {
          debugPrint("[LOG] Utilisateur authentifié avec succès. ID: ${user.userId}");

          // Sauvegarde des informations utilisateur
          await _secureStorage.saveUserId(user.userId);
          await _preferencesHelper.saveUserName(user.nom);
          await _preferencesHelper.saveUserLastName(user.prenoms);

          _showToast("Connexion réussie !");
          // Redirection vers l'écran d'accueil
          Navigator.pushReplacement(
            context,
            MaterialPageRoute(
              builder: (context) => HomeScreen(
                userId: user.userId,
                userName: user.nom,
                userLastName: user.prenoms,
                userProfileImage: 'lib/assets/images/profile_picture.png',
                eventRemoteDataSource: EventRemoteDataSource(http.Client()),
              ),
            ),
          );
        } else {
          debugPrint("[ERROR] L'ID utilisateur est manquant dans la réponse.");
          _showToast("Erreur : ID utilisateur manquant.");
        }
      } catch (e) {
        // Gestion des erreurs spécifiques et log de chaque type d'erreur
        if (e is ServerExceptionWithMessage) {
          debugPrint("[ERROR] Erreur serveur : ${e.message}");
          _showToast("Erreur serveur : ${e.message}");
        } else if (e is UnauthorizedException) {
          debugPrint("[ERROR] Erreur d'authentification : ${e.message}");
          _showToast("Erreur : ${e.message}");
        } else {
          debugPrint("[ERROR] Erreur lors de la connexion : $e");
          _showToast("Erreur lors de la connexion : ${e.toString()}");
        }
        _btnController.error(); // Affiche une erreur sur le bouton
        setState(() {
          _showErrorMessage = true;
        });
      } finally {
        _btnController.reset(); // Réinitialise l'état du bouton
        setState(() {
          _isSubmitting = false; // Réinitialise l'état de chargement
        });
      }
    } else {
      debugPrint("[ERROR] Validation du formulaire échouée.");
      _btnController.reset();
      _showToast("Veuillez vérifier les informations saisies.");
    }
  }

  @override
  Widget build(BuildContext context) {
    final theme = Theme.of(context);
    final size = MediaQuery.of(context).size;
    final themeProvider = Provider.of<ThemeProvider>(context);
    bool isKeyboardVisible = MediaQuery.of(context).viewInsets.bottom != 0;

    return Scaffold(
      body: Stack(
        children: [
          // Arrière-plan animé
          AnimatedContainer(
            duration: const Duration(seconds: 3),
            decoration: BoxDecoration(
              gradient: LinearGradient(
                colors: [
                  theme.colorScheme.primary,
                  theme.colorScheme.secondary,
                ],
                begin: Alignment.topLeft,
                end: Alignment.bottomRight,
              ),
            ),
          ),
          // Spinner de chargement lors de la soumission
          if (_isSubmitting)
            const Center(
              child: SpinKitFadingCircle(
                color: Colors.white,
                size: 50.0,
              ),
            ),
          // Icône de changement de thème
          Positioned(
            top: 40,
            right: 20,
            child: IconButton(
              icon: Icon(
                themeProvider.isDarkMode ? Icons.dark_mode : Icons.light_mode,
                color: theme.iconTheme.color,
              ),
              onPressed: () {
                themeProvider.toggleTheme();
                debugPrint("[LOG] Thème basculé : ${themeProvider.isDarkMode ? 'Sombre' : 'Clair'}");
              },
            ),
          ),
          // Formulaire de connexion
          Center(
            child: SingleChildScrollView(
              padding: const EdgeInsets.all(16.0),
              child: Form(
                key: _formKey,
                child: Column(
                  crossAxisAlignment: CrossAxisAlignment.center,
                  children: [
                    Image.asset(
                      'lib/assets/images/logo.png',
                      height: size.height * 0.25,
                    ),
                    const SizedBox(height: 20),
                    Text(
                      'Bienvenue sur AfterWork',
                      style: theme.textTheme.titleLarge,
                    ),
                    const SizedBox(height: 40),
                    _buildTextFormField(
                      label: 'Email',
                      icon: Icons.email,
                      validator: (value) {
                        if (value == null || value.isEmpty) {
                          debugPrint("[ERROR] Champ email vide.");
                          return 'Veuillez entrer votre email';
                        }
                        if (!RegExp(r'^[^@]+@[^@]+\.[^@]+').hasMatch(value)) {
                          debugPrint("[ERROR] Email invalide.");
                          return 'Veuillez entrer un email valide';
                        }
                        return null;
                      },
                      onSaved: (value) {
                        _email = value!;
                        debugPrint("[LOG] Email enregistré : $_email");
                      },
                    ),
                    const SizedBox(height: 20),
                    _buildTextFormField(
                      label: 'Mot de passe',
                      icon: Icons.lock,
                      obscureText: !_isPasswordVisible,
                      suffixIcon: IconButton(
                        icon: Icon(
                          _isPasswordVisible ? Icons.visibility : Icons.visibility_off,
                          color: theme.iconTheme.color,
                        ),
                        onPressed: _togglePasswordVisibility,
                      ),
                      validator: (value) {
                        if (value == null || value.isEmpty) {
                          debugPrint("[ERROR] Champ mot de passe vide.");
                          return 'Veuillez entrer votre mot de passe';
                        }
                        if (value.length < 6) {
                          debugPrint("[ERROR] Mot de passe trop court.");
                          return 'Le mot de passe doit comporter au moins 6 caractères';
                        }
                        return null;
                      },
                      onSaved: (value) {
                        _password = value!;
                        debugPrint("[LOG] Mot de passe enregistré.");
                      },
                    ),
                    const SizedBox(height: 30),
                    SizedBox(
                      width: size.width * 0.85,
                      child: LoadingButton(
                        controller: _btnController,
                        onPressed: _isSubmitting ? null : _submit,
                        iconData: Icons.login,
                        iconColor: theme.colorScheme.onPrimary,
                        child: Text(
                          'Connexion',
                          style: theme.textTheme.bodyLarge!.copyWith(
                            color: theme.colorScheme.onPrimary,
                          ),
                        ),
                      ),
                    ),
                    const SizedBox(height: 20),
                    TextButton(
                      onPressed: () {
                        debugPrint("[LOG] Redirection vers la page d'inscription.");
                        Navigator.push(
                          context,
                          MaterialPageRoute(
                            builder: (context) => const SignUpScreen(),
                          ),
                        );
                      },
                      child: Text(
                        'Pas encore de compte ? Inscrivez-vous',
                        style: theme.textTheme.bodyMedium!.copyWith(color: Colors.white70),
                      ),
                    ),
                    TextButton(
                      onPressed: () {
                        debugPrint("[LOG] Mot de passe oublié cliqué.");
                      },
                      child: Text(
                        'Mot de passe oublié ?',
                        style: theme.textTheme.bodyMedium!.copyWith(color: Colors.white70),
                      ),
                    ),
                    if (_showErrorMessage)
                      const Padding(
                        padding: EdgeInsets.only(top: 20),
                        child: Text(
                          'Erreur lors de la connexion. Veuillez vérifier vos identifiants.',
                          style: TextStyle(color: Colors.red, fontSize: 16),
                          textAlign: TextAlign.center,
                        ),
                      ),
                  ],
                ),
              ),
            ),
          ),
          AnimatedPositioned(
            duration: const Duration(milliseconds: 300),
            bottom: isKeyboardVisible ? 0 : 20,
            left: isKeyboardVisible ? 20 : 0,
            right: isKeyboardVisible ? 20 : 0,
            child: Row(
              mainAxisAlignment: isKeyboardVisible
                  ? MainAxisAlignment.spaceBetween
                  : MainAxisAlignment.center,
              children: [
                Image.asset(
                  'lib/assets/images/logolionsdev.png',
                  height: 30,
                ),
                if (isKeyboardVisible)
                  Text(
                    '© 2024',
                    style: theme.textTheme.bodyMedium!.copyWith(color: Colors.white70),
                    textAlign: TextAlign.center,
                  ),
              ],
            ),
          ),
        ],
      ),
    );
  }

  /// Méthode pour construire les champs de formulaire avec les styles adaptés.
  Widget _buildTextFormField({
    required String label,
    required IconData icon,
    bool obscureText = false,
    Widget? suffixIcon,
    required FormFieldValidator<String> validator,
    required FormFieldSetter<String> onSaved,
  }) {
    final theme = Theme.of(context);

    return TextFormField(
      decoration: InputDecoration(
        labelText: label,
        filled: true,
        fillColor: theme.inputDecorationTheme.fillColor,
        labelStyle: theme.textTheme.bodyMedium,
        border: OutlineInputBorder(
          borderRadius: BorderRadius.circular(12.0),
          borderSide: BorderSide.none,
        ),
        prefixIcon: Icon(icon, color: theme.iconTheme.color),
        suffixIcon: suffixIcon,
      ),
      obscureText: obscureText,
      style: theme.textTheme.bodyLarge,
      validator: validator,
      onSaved: onSaved,
    );
  }
}
