"""
Smoke tests for frontend-backend integration.

These tests verify that key authentication and API changes work correctly
with the frontend's expectations for JWT tokens.
"""
import pytest
from httpx import ASGITransport, AsyncClient

from src.server.fastapi_app import app
from src.server.services.auth_service import auth_service


@pytest.fixture(autouse=True)
def reset_auth():
    """Reset authentication state."""
    auth_service._hash = None
    auth_service._failed.clear()
    yield
    auth_service._hash = None
    auth_service._failed.clear()


@pytest.fixture
async def client():
    """Create async test client."""
    transport = ASGITransport(app=app)
    async with AsyncClient(transport=transport, base_url="http://test") as ac:
        yield ac


class TestFrontendIntegration:
    """Test frontend integration with JWT authentication."""

    async def test_login_returns_jwt_token(self, client):
        """Test that login returns JWT token in expected format."""
        # Setup
        await client.post(
            "/api/auth/setup",
            json={"master_password": "StrongP@ss123"}
        )

        # Login
        response = await client.post(
            "/api/auth/login",
            json={"password": "StrongP@ss123"}
        )

        assert response.status_code == 200
        data = response.json()

        # Frontend expects these fields
        assert "access_token" in data
        assert "token_type" in data
        assert data["token_type"] == "bearer"

    async def test_authenticated_endpoints_require_bearer_token(self, client):
        """Test that authenticated endpoints require Bearer token."""
        # Setup and login
        await client.post(
            "/api/auth/setup",
            json={"master_password": "StrongP@ss123"}
        )
        login_resp = await client.post(
            "/api/auth/login",
            json={"password": "StrongP@ss123"}
        )
        token = login_resp.json()["access_token"]

        # Test without token - should fail
        response = await client.get("/api/anime/")
        assert response.status_code == 401

        # Test with Bearer token in header - should work or return 503
        headers = {"Authorization": f"Bearer {token}"}
        response = await client.get("/api/anime/", headers=headers)
        # May return 503 if anime directory not configured
        assert response.status_code in [200, 503]

    async def test_queue_endpoints_accessible_with_token(self, client):
        """Test queue endpoints work with JWT token."""
        # Setup and login
        await client.post(
            "/api/auth/setup",
            json={"master_password": "StrongP@ss123"}
        )
        login_resp = await client.post(
            "/api/auth/login",
            json={"password": "StrongP@ss123"}
        )
        token = login_resp.json()["access_token"]
        headers = {"Authorization": f"Bearer {token}"}

        # Test queue status endpoint
        response = await client.get("/api/queue/status", headers=headers)
        # Should work or return 503 if service not configured
        assert response.status_code in [200, 503]
