"""Konta imienne i dziennik audytowy (PRE-17).

Kod ochronny — testujemy zachowanie, nie kształt źródła. Dwie rzeczy są tu
krytyczne i CICHE, gdy się zepsują: (1) odebranie dostępu jednej osobie musi
faktycznie działać, (2) dziennik musi mówić KTO i ILE, ale NIGDY nie powielać
treści baz (byłby wtedy kolejnym nośnikiem wycieku).
"""
import logging

import pytest

from app import security


def _kto(user: str, password: str) -> str | None:
    """Login, gdy poświadczenia pasują; None przy odmowie.

    Po przejściu na sesje (LOG-34) sprawdzanie hasła robi `verify`, a nie
    parsowanie nagłówka Basic — samego nagłówka nie ma już w ogóle."""
    who = security.verify(user, password)
    return who.login if who else None


@pytest.fixture(autouse=True)
def _clean_env(monkeypatch):
    for var in ("APP_USERS", "APP_PASSWORD", "APP_USER"):
        monkeypatch.delenv(var, raising=False)
    security._hits.clear()          # limit żądań nie może przeciekać między testami


# ── hasła: hash zamiast jawnego tekstu ──

def test_hash_roundtrip_and_salt_is_random():
    h = security.hash_password("tajne")
    assert h.startswith("scrypt$")
    assert security._secret_matches(h, "tajne")
    assert not security._secret_matches(h, "inne")
    assert security.hash_password("tajne") != h          # inna sól za każdym razem


def test_broken_hash_denies_instead_of_crashing():
    assert security._secret_matches("scrypt$niepoprawny", "cokolwiek") is False


def test_non_ascii_password_is_handled_not_crashing():
    """REGRESJA (błąd zastany): `secrets.compare_digest` rzuca TypeError na znakach
    spoza ASCII, więc hasło z polskimi literami wywracało logowanie błędem 500
    zamiast zwykłej odmowy. Porównujemy bajty."""
    assert security._secret_matches("zażółć", "zażółć") is True
    assert security._secret_matches("zażółć", "inne") is False
    assert security._secret_matches(security.hash_password("gęślą"), "gęślą") is True


# ── konta imienne ──

def test_named_accounts_are_parsed(monkeypatch):
    monkeypatch.setenv("APP_USERS", "alicja:tajne, bartek:inne")
    assert set(security.accounts()) == {"alicja", "bartek"}


def test_login_with_hashed_password(monkeypatch):
    monkeypatch.setenv("APP_USERS", f"alicja:{security.hash_password('tajne')}")
    assert _kto("alicja", "tajne") == "alicja"
    assert _kto("alicja", "złe") is None


def test_unknown_user_is_denied(monkeypatch):
    monkeypatch.setenv("APP_USERS", "alicja:tajne")
    assert _kto("obcy", "tajne") is None


def test_revoking_one_account_leaves_others_untouched(monkeypatch):
    """Sedno PRE-17: odcinamy jedną osobę BEZ zmiany hasła pozostałym."""
    monkeypatch.setenv("APP_USERS", "alicja:tajne,bartek:inne")
    assert _kto("bartek", "inne") == "bartek"
    monkeypatch.setenv("APP_USERS", "alicja:tajne")          # usunięto wpis Bartka
    assert _kto("bartek", "inne") is None
    assert _kto("alicja", "tajne") == "alicja"


def test_shared_password_still_works_alone(monkeypatch):
    """Zgodność wstecz — dotychczasowe wdrożenie nie może paść po aktualizacji."""
    monkeypatch.setenv("APP_USER", "astrololo")
    monkeypatch.setenv("APP_PASSWORD", "wspolne")
    assert _kto("astrololo", "wspolne") == "astrololo"


def test_named_accounts_disable_the_shared_password(monkeypatch):
    """Gdy są konta imienne, wspólne hasło MUSI przestać działać — inaczej
    zostawiałoby tylne wejście bez śladu w dzienniku."""
    monkeypatch.setenv("APP_USERS", "alicja:tajne")
    monkeypatch.setenv("APP_USER", "astrololo")
    monkeypatch.setenv("APP_PASSWORD", "wspolne")
    assert _kto("astrololo", "wspolne") is None


def test_no_accounts_means_auth_disabled(monkeypatch):
    assert security.auth_enabled() is False


# ── dziennik audytowy ──

def _client(monkeypatch):
    # Klucz MUSI być w środowisku ZANIM zaimportujemy app.main: security.install
    # biegnie przy imporcie i bez klucza celowo nie pozwala usłudze wstać.
    monkeypatch.setenv("SESSION_SECRET", "t" * 64)
    monkeypatch.setenv("COOKIES_INSECURE", "1")

    from starlette.testclient import TestClient

    from app.main import app

    return TestClient(app, follow_redirects=False)


class _dziennik:
    """Przechwytuje wpisy audytowe.

    `caplog` podpina się pod korzeń, a dziennik audytowy ma celowo
    `propagate=False` — żeby wpisy nie dublowały się w logach usługi. Trzeba więc
    podpiąć uchwyt WPROST pod niego, inaczej test widzi pustkę i wygląda to na
    brak wpisów zamiast na brak podsłuchu."""

    def __init__(self, caplog):
        self.caplog = caplog

    def __enter__(self):
        security._setup_audit_logging()
        security.audit_log.setLevel(logging.INFO)
        security.audit_log.addHandler(self.caplog.handler)
        return self

    def __exit__(self, *a):
        security.audit_log.removeHandler(self.caplog.handler)

    @property
    def tekst(self) -> str:
        return "\n".join(r.getMessage() for r in self.caplog.records)


def _sesja(user: str) -> dict:
    from app import session

    return {"Cookie": f"{session.COOKIE}={security.issue_session(user)}"}


def test_audit_logs_who_and_how_many(monkeypatch, caplog):
    monkeypatch.setenv("APP_USERS", "alicja:tajne")
    c = _client(monkeypatch)
    with _dziennik(caplog) as d:
        c.get("/synastry", headers=_sesja("alicja"))
    entry = d.tekst
    assert "user=alicja" in entry and "path=/synastry" in entry and "status=200" in entry


def test_audit_marks_a_request_without_a_session(monkeypatch, caplog):
    """Odesłanie na ekran logowania też zostawia ślad — bez tego seria prób
    dobicia się do chronionej ścieżki byłaby w dzienniku niewidoczna."""
    monkeypatch.setenv("APP_USERS", "alicja:tajne")
    c = _client(monkeypatch)
    with _dziennik(caplog) as d:
        c.get("/synastry")
    entry = d.tekst
    assert "status=303" in entry and "user=-" in entry


def test_failed_login_is_logged_without_saying_which_account_exists(monkeypatch, caplog):
    """Nieudane próby są w dzienniku ważniejsze od udanych: pojedyncza nic nie
    znaczy, ale seria pod jednym adresem to jedyny widoczny ślad zgadywania
    haseł. Hasło ani jego fragment NIE mogą tam trafić."""
    monkeypatch.setenv("APP_USERS", f"alicja:{security.hash_password('tajne')}")
    c = _client(monkeypatch)
    with _dziennik(caplog) as d:
        r = c.post("/logowanie", data={"login": "alicja", "haslo": "zgaduje-haslo"})
    assert r.status_code == 401
    entry = d.tekst
    assert "logowanie-odmowa" in entry
    assert "zgaduje-haslo" not in entry, "hasło trafiło do dziennika"


def test_audit_logger_actually_emits(monkeypatch):
    """REGRESJA: wpisy szły na INFO, ale domyślna konfiguracja uvicorna nie
    obsługuje naszych loggerów — dziennik istniał w kodzie i był PUSTY na żywym
    serwerze. Niewidoczny dziennik jest gorszy niż jego brak (złudzenie kontroli),
    więc pilnujemy, że ma własny handler i poziom pozwalający na INFO."""
    security._setup_audit_logging()
    assert security.audit_log.handlers, "dziennik audytowy nie ma własnego handlera"
    assert security.audit_log.isEnabledFor(logging.INFO)


def test_audit_never_carries_database_content():
    """Wpis niesie WYŁĄCZNIE metadane i liczby — logi nie mogą być nośnikiem wycieku."""
    src = (__import__("pathlib").Path(security.__file__)).read_text(encoding="utf-8")
    fmt = src[src.index('"AUDYT'):src.index("ms=%.0f") + 10]
    for forbidden in ("rows", "samples", "effect", "significator", "text", "body"):
        assert forbidden not in fmt, f"format wpisu audytowego dotyka treści: {forbidden}"


def test_handlers_report_record_counts():
    """Bez liczby rekordów dziennik pokazywałby „ktoś wchodził", a nie „ktoś
    wyniósł 5000 rekordów" — czyli nie wykryłby powolnego wypompowywania bazy."""
    import pathlib

    main = (pathlib.Path(security.__file__).parent / "main.py").read_text(encoding="utf-8")
    assert main.count("security.audit_records(") >= 3      # sygnifikatory, raport, eksport