# tests/persistence/test_sqlite_token.py

from datetime import datetime, timedelta

from myauth.models.token import TokenData
from myauth.persistence.sqlite import SQLiteTokenRepository


def test_i_can_save_and_retrieve_token(token_repository: SQLiteTokenRepository,
                                       test_token_data: TokenData):
  """Verifies token saving and successful retrieval by token string and type."""
  
  # 1. Save Token
  token_repository.save_token(test_token_data)
  
  # 2. Retrieve Token
  retrieved_token = token_repository.get_token(test_token_data.token, test_token_data.token_type)
  
  # Assertions
  assert retrieved_token is not None
  assert retrieved_token.token == test_token_data.token
  assert retrieved_token.user_id == test_token_data.user_id
  assert retrieved_token.is_revoked is False
  assert retrieved_token.token_type == test_token_data.token_type


def test_i_can_revoke_token(token_repository: SQLiteTokenRepository,
                            test_token_data: TokenData):
  """Verifies a token can be revoked and its revoked status is updated."""
  
  # Setup: Save the token
  token_repository.save_token(test_token_data)
  
  # 1. Revoke the token
  was_revoked = token_repository.revoke_token(test_token_data.token)
  assert was_revoked is True
  
  # 2. Retrieve and check status
  revoked_token = token_repository.get_token(test_token_data.token, test_token_data.token_type)
  assert revoked_token is not None
  assert revoked_token.is_revoked is True
  
  # 3. Attempt to revoke a non-existent token
  was_revoked_again = token_repository.revoke_token("non_existent_token")
  assert was_revoked_again is False


def test_i_can_use_is_token_valid_for_valid_token(token_repository: SQLiteTokenRepository,
                                                  test_token_data: TokenData):
  """Verifies the convenience method returns True for a fresh, unexpired token."""
  
  token_repository.save_token(test_token_data)
  
  is_valid = token_repository.is_token_valid(test_token_data.token, test_token_data.token_type)
  assert is_valid is True
  
  is_valid = token_repository.is_token_valid("non_existent_token", test_token_data.token_type)
  assert is_valid is False


def test_i_can_use_is_token_valid_for_revoked_token(token_repository: SQLiteTokenRepository,
                                                    test_token_data: TokenData):
  """Verifies is_token_valid returns False for a token marked as revoked."""
  
  token_repository.save_token(test_token_data)
  token_repository.revoke_token(test_token_data.token)
  
  is_valid = token_repository.is_token_valid(test_token_data.token, test_token_data.token_type)
  assert is_valid is False


def test_i_can_use_is_token_valid_for_expired_token(token_repository: SQLiteTokenRepository):
  """Verifies is_token_valid returns False for a token whose expiration is in the past."""
  
  expired_token_data = TokenData(
    token="expired_token_test",
    token_type="password_reset",
    user_id="user_id_expired",
    expires_at=datetime.now() - timedelta(hours=1),  # Set expiration to 1 hour ago
    is_revoked=False,
    created_at=datetime.now() - timedelta(hours=2)
  )
  
  token_repository.save_token(expired_token_data)
  
  is_valid = token_repository.is_token_valid(expired_token_data.token, expired_token_data.token_type)
  assert is_valid is False