tasktracker/lib/services/auth_service.dart

import 'package:shared_preferences/shared_preferences.dart';
import 'package:supabase_flutter/supabase_flutter.dart';
import 'package:flutter/foundation.dart';

class AuthService {
  static const String _emailKey = 'saved_email';
  static const String _passwordKey = 'saved_password';
  static const String _rememberMeKey = 'remember_me';
  static const String _userNameKey = 'user_name';
  static const String _userEmailKey = 'user_email';

  final SupabaseClient _supabase = Supabase.instance.client;

  /// Save login credentials to SharedPreferences
  Future<void> saveCredentials({
    required String email,
    required String password,
    required bool rememberMe,
  }) async {
    final prefs = await SharedPreferences.getInstance();
    
    if (rememberMe) {
      await prefs.setString(_emailKey, email);
      await prefs.setString(_passwordKey, password);
      await prefs.setBool(_rememberMeKey, true);
    } else {
      // Clear saved credentials if user doesn't want to be remembered
      await prefs.remove(_emailKey);
      await prefs.remove(_passwordKey);
      await prefs.setBool(_rememberMeKey, false);
    }
  }

  /// Get saved login credentials
  Future<Map<String, dynamic>?> getSavedCredentials() async {
    try {
      final prefs = await SharedPreferences.getInstance().timeout(
        const Duration(seconds: 5),
      );
      final rememberMe = prefs.getBool(_rememberMeKey) ?? false;
      
      if (!rememberMe) return null;
      
      final email = prefs.getString(_emailKey);
      final password = prefs.getString(_passwordKey);
      
      if (email != null && password != null) {
        return {
          'email': email,
          'password': password,
          'rememberMe': rememberMe,
        };
      }
      
      return null;
    } catch (e) {
      debugPrint('Error getting saved credentials: $e');
      return null;
    }
  }

  /// Save user information after successful login
  Future<void> saveUserInfo({
    required String name,
    required String email,
  }) async {
    final prefs = await SharedPreferences.getInstance();
    await prefs.setString(_userNameKey, name);
    await prefs.setString(_userEmailKey, email);
  }

  /// Get saved user information
  Future<Map<String, String>?> getUserInfo() async {
    try {
      final prefs = await SharedPreferences.getInstance().timeout(
        const Duration(seconds: 5),
      );
      final name = prefs.getString(_userNameKey);
      final email = prefs.getString(_userEmailKey);
      
      if (name != null && email != null) {
        return {
          'name': name,
          'email': email,
        };
      }
      
      return null;
    } catch (e) {
      debugPrint('Error getting user info: $e');
      return null;
    }
  }

  /// Clear all saved data (for logout)
  Future<void> clearSavedData() async {
    final prefs = await SharedPreferences.getInstance();
    await prefs.remove(_emailKey);
    await prefs.remove(_passwordKey);
    await prefs.remove(_rememberMeKey);
    await prefs.remove(_userNameKey);
    await prefs.remove(_userEmailKey);
  }

  /// Check if user is currently authenticated
  bool get isAuthenticated => _supabase.auth.currentUser != null;

  /// Get current user
  User? get currentUser => _supabase.auth.currentUser;

  /// Auto-login with saved credentials
  Future<bool> autoLogin() async {
    try {
      debugPrint('Auto-login started');
      final credentials = await getSavedCredentials();
      if (credentials == null) {
        debugPrint('No saved credentials found');
        return false;
      }

      debugPrint('Attempting sign-in with saved credentials');
      final response = await _supabase.auth.signInWithPassword(
        email: credentials['email'],
        password: credentials['password'],
      ).timeout(const Duration(seconds: 10));

      if (response.user != null) {
        debugPrint('Auto-login successful');
        // Save user info if not already saved
        final userInfo = await getUserInfo();
        if (userInfo == null) {
          await saveUserInfo(
            name: response.user!.userMetadata?['name'] ?? 'User',
            email: response.user!.email ?? credentials['email'],
          );
        }
        return true;
      }
      debugPrint('Auto-login failed: no user in response');
      return false;
    } catch (e) {
      debugPrint('Auto-login error: $e');
      // If auto-login fails, clear saved credentials
      await clearSavedData();
      return false;
    }
  }

  /// Login with email and password
  Future<AuthResponse> loginWithPassword({
    required String email,
    required String password,
    required bool rememberMe,
  }) async {
    final response = await _supabase.auth.signInWithPassword(
      email: email,
      password: password,
    );

    if (response.user != null) {
      // Save credentials if remember me is checked
      await saveCredentials(
        email: email,
        password: password,
        rememberMe: rememberMe,
      );

      // Save user info
      await saveUserInfo(
        name: response.user!.userMetadata?['name'] ?? 'User',
        email: response.user!.email ?? email,
      );
    }

    return response;
  }

  /// Register new user
  Future<AuthResponse> registerUser({
    required String email,
    required String password,
    required String name,
    required bool rememberMe,
  }) async {
    final response = await _supabase.auth.signUp(
      email: email,
      password: password,
      data: {'name': name},
    );

    if (response.user != null) {
      // Save credentials if remember me is checked
      await saveCredentials(
        email: email,
        password: password,
        rememberMe: rememberMe,
      );

      // Save user info
      await saveUserInfo(
        name: name,
        email: email,
      );
    }

    return response;
  }

  /// Logout user
  Future<void> logout() async {
    await _supabase.auth.signOut();
    await clearSavedData();
  }
}