"""
Integration Tests für das Zusammenspiel von Authentication und Data.

Testet, dass:
1. QuestraAuthentication und QuestraData zusammen funktionieren
2. Die erwartete API-Integration funktioniert (High-Level Tests)
3. Keine Import-Fehler bei kombinierter Verwendung auftreten
"""

from unittest.mock import Mock

from questra import (
    QuestraAuthentication,
    QuestraData,
    QuestraDataCore,
)


class TestAuthenticationDataIntegration:
    """Tests für Integration von Authentication und Data Client."""

    def test_auth_client_can_be_passed_to_data_client(self):
        """Test: Mock Auth Client kann an QuestraData übergeben werden."""
        # Mock Auth Client mit erforderlichen Methoden
        auth = Mock()
        auth.is_authenticated.return_value = True
        auth.get_access_token.return_value = "test_token"

        # Create Data Client with Auth - sollte keine Exception werfen
        data_client = QuestraData(
            graphql_url="https://api.example.com/graphql", auth_client=auth
        )

        # Verifiziere, dass Client erstellt wurde und erwartete Methoden hat
        assert data_client is not None
        assert hasattr(data_client, "list_items")

    def test_auth_client_can_be_passed_to_data_core_client(self):
        """Test: Mock Auth Client kann an QuestraDataCore übergeben werden."""
        # Mock Auth Client
        auth = Mock()
        auth.is_authenticated.return_value = True
        auth.get_access_token.return_value = "test_token"

        # Create Data Core Client with Auth
        core_client = QuestraDataCore(
            graphql_url="https://api.example.com/graphql", auth_client=auth
        )

        # Verifiziere, dass Client erstellt wurde
        assert core_client is not None

    def test_data_client_has_expected_methods(self):
        """Test: Data Clients haben erwartete Methoden."""
        # Mock Auth
        auth = Mock()
        auth.is_authenticated.return_value = True
        auth.get_access_token.return_value = "test_token"

        # High-Level Client
        data_client = QuestraData(
            graphql_url="https://api.example.com/graphql", auth_client=auth
        )

        assert hasattr(data_client, "list_items")
        assert hasattr(data_client, "create_items")
        assert hasattr(data_client, "list_inventories")

        # Low-Level Client
        core_client = QuestraDataCore(
            graphql_url="https://api.example.com/graphql", auth_client=auth
        )

        assert hasattr(core_client, "queries")
        assert hasattr(core_client, "mutations")


class TestAuthenticationExceptions:
    """Tests für Exception-Handling in der Integration."""

    def test_authentication_error_is_importable(self):
        """Test: AuthenticationError kann importiert werden."""
        from questra import (
            AuthenticationError,
            InvalidCredentialsError,
            NotAuthenticatedError,
            SessionNotInitializedError,
            TokenExpiredError,
        )

        assert issubclass(InvalidCredentialsError, AuthenticationError)
        assert issubclass(NotAuthenticatedError, AuthenticationError)
        assert issubclass(SessionNotInitializedError, AuthenticationError)
        assert issubclass(TokenExpiredError, AuthenticationError)

    def test_data_error_is_importable(self):
        """Test: Data Errors können importiert werden."""
        from questra import QuestraError, QuestraGraphQLError

        assert issubclass(QuestraGraphQLError, QuestraError)


class TestCombinedImports:
    """Tests für kombinierte Imports."""

    def test_all_main_classes_importable_together(self):
        """Test: Alle Hauptklassen können zusammen importiert werden."""
        from questra import (
            Inventory,
            Namespace,
            OAuth2ServiceCredential,
            QuestraData,
            QuestraDataCore,
        )

        # Alle sollten importierbar sein
        assert QuestraAuthentication is not None
        assert QuestraData is not None
        assert QuestraDataCore is not None
        assert OAuth2ServiceCredential is not None
        assert Inventory is not None
        assert Namespace is not None

    def test_all_exceptions_importable_together(self):
        """Test: Alle Exceptions können zusammen importiert werden."""
        from questra import (
            AuthenticationError,
            InvalidCredentialsError,
            NotAuthenticatedError,
            QuestraError,
            QuestraGraphQLError,
        )

        # Alle sollten Exception-Klassen sein
        assert issubclass(AuthenticationError, Exception)
        assert issubclass(QuestraError, Exception)
        assert issubclass(InvalidCredentialsError, AuthenticationError)
        assert issubclass(NotAuthenticatedError, AuthenticationError)
        assert issubclass(QuestraGraphQLError, QuestraError)
