"""Session wiring for the release smoke suite.

The suite drives a real instance over HTTP. It never starts one: that is
`scripts/odysseus-smoke`'s job, which boots the worktree through
`scripts/odysseus-dev` and hands the details over in the environment.
Run under a plain `pytest` with no instance up, every scenario skips
with the reason rather than failing, so the full suite stays green.

Three environment values form the contract, and they are exactly what
`odysseus dev env` prints plus the dev admin account:

  APP_PORT                    - which instance, read through
                                `internal_api_base()`
  ODYSSEUS_ADMIN_USER         - the account to authenticate as
  ODYSSEUS_ADMIN_PASSWORD
  ODYSSEUS_DATA_DIR           - where the email fixture file goes, read
                                through `src.constants.DATA_DIR`
"""
from __future__ import annotations

import os

import httpx
import pytest

from src.constants import internal_api_base
from tests.helpers.cli_loader import load_script
from tests.smoke import areas
from tests.smoke.stub_provider import MODEL_PRIMARY, StubProvider

# How long a smoke request may take. Generous: the first turn through a
# cold agent path does real work, and a timeout here reads as a product
# failure, which is the one thing this suite must not get wrong.
REQUEST_TIMEOUT_SECONDS = 120.0

# Auth and endpoint routes the suite drives directly. Kept here so a
# route rename shows up in one place rather than twelve.
LOGIN_PATH = "/api/auth/login"
HEALTH_PATH = "/api/health"
ENDPOINTS_PATH = "/api/model-endpoints"
SESSION_PATH = "/api/session"

_NO_PORT = (
    "APP_PORT is not set, so there is no instance to drive. Run the suite "
    "with `scripts/odysseus-smoke`, which boots this worktree and exports it."
)


def _reserved_ports() -> dict:
    """`odysseus dev`'s own refuse-list, read from the launcher.

    The smoke suite writes and deletes real records, so pointing it at a
    port that means something - a normal launch of this checkout, the
    machine's production instance - has to be impossible rather than
    merely discouraged. Reusing the launcher's table keeps one source of
    truth instead of a second copy that can drift.
    """
    try:
        return dict(load_script("odysseus-dev").RESERVED_PORTS)
    except Exception:  # pragma: no cover - launcher absent or unloadable
        return {}


@pytest.fixture(scope="session")
def base_url() -> str:
    """The instance this run drives, or a skip explaining why there is none."""
    port = (os.environ.get("APP_PORT") or "").strip()
    if not port:
        pytest.skip(_NO_PORT)
    reason = _reserved_ports().get(int(port)) if port.isdigit() else None
    if reason:
        pytest.skip(
            f"APP_PORT={port} is {reason}. The smoke suite creates and deletes "
            f"real records, so it refuses to run against that instance."
        )
    return internal_api_base()


@pytest.fixture(scope="session")
def account() -> dict:
    user = (os.environ.get("ODYSSEUS_ADMIN_USER") or "").strip()
    password = os.environ.get("ODYSSEUS_ADMIN_PASSWORD") or ""
    if not user or not password:
        pytest.skip(
            "ODYSSEUS_ADMIN_USER / ODYSSEUS_ADMIN_PASSWORD are not set, so the "
            "suite cannot authenticate. Run it with `scripts/odysseus-smoke`."
        )
    return {"username": user, "password": password}


def _new_client(base_url: str, account: dict) -> httpx.Client:
    """An authenticated client, or a skip naming what the instance said."""
    client = httpx.Client(base_url=base_url, timeout=REQUEST_TIMEOUT_SECONDS,
                          follow_redirects=True)
    try:
        client.get(HEALTH_PATH)
    except httpx.HTTPError as exc:
        client.close()
        pytest.skip(f"no instance answering at {base_url} ({exc}). Boot one with "
                    f"`odysseus dev up`, or run `scripts/odysseus-smoke`.")
    response = client.post(LOGIN_PATH, json=account)
    if response.status_code != 200:
        client.close()
        pytest.skip(
            f"could not log in as {account['username']} at {base_url}: "
            f"HTTP {response.status_code}. The recorded credentials may not "
            f"match this instance's data dir."
        )
    return client


@pytest.fixture(scope="session")
def client(base_url, account):
    """One authenticated session shared by every scenario."""
    handle = _new_client(base_url, account)
    yield handle
    handle.close()


@pytest.fixture
def fresh_client(base_url, account):
    """A second authenticated session, for asserting something persisted.

    Reading a value back on the same cookie proves the request handler
    returned it. Reading it back on a new login is the closest a test can
    get to the user reloading the page.
    """
    handle = _new_client(base_url, account)
    yield handle
    handle.close()


@pytest.fixture(scope="session")
def stub_provider():
    """The deterministic provider every model-backed scenario talks to."""
    with StubProvider() as provider:
        yield provider


@pytest.fixture(scope="session")
def stub_endpoint(client, stub_provider) -> str:
    """Register the stub as a model endpoint and return its id.

    Registered as `endpoint_kind=local` so the app treats it the way it
    treats a Cookbook-served model rather than probing it as a hosted
    API, and removed afterwards so a `--keep-up` instance is not left
    pointing at a port that has gone away.
    """
    response = client.post(ENDPOINTS_PATH, data={
        "name": "odysseus-smoke-stub",
        "base_url": stub_provider.base_url,
        "endpoint_kind": "local",
    })
    if response.status_code != 200:
        pytest.skip(
            f"the instance would not register the stub provider at "
            f"{stub_provider.base_url}: HTTP {response.status_code} "
            f"{response.text[:200]}"
        )
    body = response.json()
    endpoint_id = str(body.get("id") or "")
    if not endpoint_id:
        pytest.skip(f"the endpoint the instance registered has no id: {body}")
    if MODEL_PRIMARY not in (body.get("models") or []):
        pytest.skip(
            f"the instance did not discover {MODEL_PRIMARY} on the stub "
            f"provider; it saw {body.get('models')}"
        )
    yield endpoint_id
    client.delete(f"{ENDPOINTS_PATH}/{endpoint_id}")


@pytest.fixture
def chat_session(client, stub_endpoint):
    """A chat session bound to the stub provider, deleted afterwards."""
    response = client.post(SESSION_PATH, data={
        "name": "odysseus-smoke",
        "endpoint_id": stub_endpoint,
        "model": MODEL_PRIMARY,
    })
    assert response.status_code == 200, response.text
    session_id = response.json()["id"]
    yield session_id
    client.delete(f"{SESSION_PATH}/{session_id}")


# --------------------------------------------------------------------------
# The per-area table
# --------------------------------------------------------------------------
# One row per area in `areas.COVERED`, built from the outcomes pytest
# reports rather than from anything a test asserts about itself, so a
# module that never ran cannot report a pass.

_outcomes: dict[str, list[str]] = {}
_details: dict[str, str] = {}
_checks: dict[str, int] = {}


def _skip_reason(report) -> str:
    """The reason text out of a skip report, best effort."""
    longrepr = getattr(report, "longrepr", None)
    if isinstance(longrepr, tuple) and len(longrepr) == 3:
        reason = str(longrepr[2] or "")
        return reason.removeprefix("Skipped: ").strip()
    return str(longrepr or "").strip()


def pytest_runtest_logreport(report):
    key = areas.area_for_module(os.path.basename(str(report.fspath)))
    if key is None:
        return
    if report.skipped:
        _outcomes.setdefault(key, []).append(areas.SKIP)
        _details.setdefault(key, _skip_reason(report))
        return
    if report.failed:
        _outcomes.setdefault(key, []).append(areas.FAIL)
        _details[key] = f"{report.when} failed: {report.nodeid.split('::')[-1]}"
        return
    if report.when == "call" and report.passed:
        _outcomes.setdefault(key, []).append(areas.PASS)
        _checks[key] = _checks.get(key, 0) + 1


def pytest_terminal_summary(terminalreporter, exitstatus, config):
    if not _outcomes:
        return
    results = {}
    for key, outcomes in _outcomes.items():
        results[key] = {
            "result": areas.resolve(outcomes),
            "checks": _checks.get(key, 0),
            "detail": _details.get(key, ""),
        }

    if all(entry["result"] == areas.SKIP for entry in results.values()):
        reasons = {entry["detail"] for entry in results.values() if entry["detail"]}
        terminalreporter.write_line("")
        terminalreporter.write_line(
            "release smoke suite skipped: " + (
                reasons.pop() if len(reasons) == 1 else "; ".join(sorted(reasons))
            )
        )
        return

    header = f"Odysseus release smoke - {internal_api_base()}"
    terminalreporter.write_line("")
    terminalreporter.write_line(areas.render_table(results, header=header))