import '../../api/services/auth_service.dart';
import '../../features/auth/models/auth_token.dart';
import '../../features/auth/models/auth_credentials.dart';
import '../../data/models/user.dart';
import '../../security/secure_storage.dart';

class AuthRepository {
  final AuthService _authService;
  final SecureStorage _secureStorage;
  
  static const _accessTokenKey = 'access_token';
  static const _refreshTokenKey = 'refresh_token';
  static const _tokenExpiryKey = 'token_expiry';
  static const _userKey = 'user_data';
  
  AuthRepository(this._authService, this._secureStorage);
  
  Future<User> login(String username, String password) async {
    // Create credentials and call service
    final credentials = AuthCredentials(username: username, password: password);
    final authToken = await _authService.login(credentials);
    
    // Save token securely
    await _saveAuthToken(authToken);
    
    // Get and save user profile
    final user = await _authService.getUserProfile();
    await _saveUserData(user);
    
    return user;
  }
  
  Future<bool> isLoggedIn() async {
    final token = await _getAuthToken();
    return token != null && !token.isExpired;
  }
  
  Future<void> logout() async {
    final token = await _getAuthToken();
    if (token != null) {
      try {
        await _authService.logout(token.refreshToken);
      } finally {
        // Clear stored data regardless of logout API success
        await _clearAuthData();
      }
    }
  }
  
  Future<User?> getCurrentUser() async {
    final userJson = await _secureStorage.read(_userKey);
    if (userJson != null) {
      return User.fromJson(userJson);
    }
    return null;
  }
  
  Future<String?> getAccessToken() async {
    final token = await _getAuthToken();
    if (token == null) return null;
    
    // If token expired, try to refresh it
    if (token.isExpired) {
      final newToken = await _refreshToken(token.refreshToken);
      if (newToken != null) {
        return newToken.accessToken;
      }
      return null;
    }
    
    return token.accessToken;
  }
  
  // Private helper methods
  Future<void> _saveAuthToken(AuthToken token) async {
    await _secureStorage.write(_accessTokenKey, token.accessToken);
    await _secureStorage.write(_refreshTokenKey, token.refreshToken);
    await _secureStorage.write(_tokenExpiryKey, token.expiresAt.toIso8601String());
  }
  
  Future<AuthToken?> _getAuthToken() async {
    final accessToken = await _secureStorage.read(_accessTokenKey);
    final refreshToken = await _secureStorage.read(_refreshTokenKey);
    final expiryString = await _secureStorage.read(_tokenExpiryKey);
    
    if (accessToken != null && refreshToken != null && expiryString != null) {
      return AuthToken(
        accessToken: accessToken,
        refreshToken: refreshToken,
        expiresAt: DateTime.parse(expiryString),
      );
    }
    return null;
  }
  
  Future<void> _saveUserData(User user) async {
    await _secureStorage.write(_userKey, user);
  }
  
  Future<void> _clearAuthData() async {
    await _secureStorage.delete(_accessTokenKey);
    await _secureStorage.delete(_refreshTokenKey);
    await _secureStorage.delete(_tokenExpiryKey);
    await _secureStorage.delete(_userKey);
  }
  
  Future<AuthToken?> _refreshToken(String refreshToken) async {
    try {
      final newToken = await _authService.refreshToken(refreshToken);
      await _saveAuthToken(newToken);
      return newToken;
    } catch (e) {
      // If refresh fails, clear auth data
      await _clearAuthData();
      return null;
    }
  }
}