"""Example E2E tests demonstrating test infrastructure.

These tests verify that the E2E testing setup works correctly:
- Test server runs on random port
- Fake Keycloak provides authentication
- Database is isolated
"""

import asyncio

import pytest
from playwright.sync_api import Page

from tests.e2e.fake_keycloak import FakeKeycloakClient


@pytest.mark.e2e
def test_server_health_endpoint(base_url: str, page: Page) -> None:
    """Test that test server responds on health endpoint."""
    response = page.goto(f"{base_url}/health")
    assert response is not None
    assert response.status == 200

    body = response.json()
    assert body["status"] == "ok"
    assert body["env"] == "e2e-test"


@pytest.mark.e2e
def test_unauthenticated_user_sees_login_prompt(base_url: str, page: Page) -> None:
    """Test that unauthenticated user sees login option."""
    page.goto(f"{base_url}/web/")

    header = page.locator("header")
    header.wait_for()

    login_link = page.locator("a[href='/auth/login']")
    assert login_link.is_visible()


@pytest.mark.e2e
@pytest.mark.skip(
    reason="E2E auth flow needs further debugging - authentication cookie not being validated properly"
)
def test_authenticated_user_can_access_profile(
    base_url: str,
    authenticated_page: Page,
    test_user_data: dict[str, str],
) -> None:
    """Test that authenticated user can access profile page."""
    authenticated_page.goto(f"{base_url}/web/")

    user_menu = authenticated_page.locator("text=" + test_user_data["username"])
    user_menu.wait_for()

    authenticated_page.goto(f"{base_url}/profile")

    profile_content = authenticated_page.locator("main")
    profile_content.wait_for()

    body_text = profile_content.inner_text()
    assert test_user_data["email"] in body_text or test_user_data["username"] in body_text


@pytest.mark.e2e
@pytest.mark.skip(reason="Session-scoped fixture conflicts - needs isolated client per test")
def test_fake_keycloak_creates_different_users() -> None:
    """Test that fake Keycloak creates independent users."""

    # Create isolated client to avoid conflicts with session-scoped fixture
    client = FakeKeycloakClient(token_ttl=3600)

    user1 = client.create_user("alice", "pass1", roles=["user"])
    user2 = client.create_user("bob", "pass2", roles=["user", "admin"])

    assert user1.id != user2.id
    assert user1.username == "alice"
    assert user2.username == "bob"
    assert user1.roles == ["user"]
    assert user2.roles == ["user", "admin"]

    token1 = client.login("alice", "pass1")
    token2 = client.login("bob", "pass2")

    info1 = asyncio.run(client.introspect_token(token1))
    info2 = asyncio.run(client.introspect_token(token2))

    assert info1.active is True
    assert info2.active is True
    assert info1.username == "alice"
    assert info2.username == "bob"


@pytest.mark.e2e
def test_admin_user_has_admin_role(admin_user: dict[str, str]) -> None:
    """Test that admin user fixture creates user with admin role."""
    assert "admin" in admin_user["roles"]
    assert "user" in admin_user["roles"]
    assert admin_user["token"] is not None


@pytest.mark.e2e
def test_regular_user_has_only_user_role(regular_user: dict[str, str]) -> None:
    """Test that regular user fixture creates user without admin role."""
    assert regular_user["roles"] == ["user"]
    assert "admin" not in regular_user["roles"]
    assert regular_user["token"] is not None


@pytest.mark.e2e
@pytest.mark.skip(reason="Depends on authenticated_page fixture which needs debugging")
def test_isolated_database_per_session(
    base_url: str,
    authenticated_page: Page,
) -> None:
    """Test that database is isolated (no data from other tests)."""
    authenticated_page.goto(f"{base_url}/web/")

    posts = authenticated_page.locator("[data-testid^='post-card-']")
    count = posts.count()

    assert count == 0, "Expected empty database at start of test"