"""Opening an adventure fetches a window, not the whole story.

A story only ever gets longer. Production's longest is 607 actions and 589.5 kB
in one response, and nothing about that curve bends on its own — so the page
load returns the newest ACTION_PAGE and the reader pages upward.

The paging anchors on an action id rather than an offset, and these tests are
mostly about why. An offset counted back from the newest shifts every older
position the moment a turn lands, which is precisely when a reader is likely
to be scrolling. An anchor means the same thing before and after.

    python -m pytest tests/test_action_paging.py -v
"""
import os
import tempfile

_tmp = tempfile.NamedTemporaryFile(suffix=".db", delete=False)
_tmp.close()
os.environ["AIDND_DB_PATH"] = _tmp.name
os.environ.pop("AIDND_DATABASE_URL", None)
os.environ.pop("DATABASE_URL", None)

import pytest
from fastapi import Depends
from fastapi.testclient import TestClient

from app import auth, limits, models
from app.database import Base, SessionLocal, engine, get_db
from app.main import app
from app.routers.adventures import ACTION_PAGE
from tools import dbmeter

TOTAL = ACTION_PAGE * 3 + 7  # deliberately not a whole number of pages


@pytest.fixture()
def client(monkeypatch):
    Base.metadata.create_all(bind=engine)
    setup = SessionLocal()
    user = models.User(is_guest=False, email="paging@example.com")
    setup.add(user)
    setup.flush()
    setup.add(models.Settings(user_id=user.id, api_key="enc:dummy", model="m"))
    adventure = models.Adventure(user_id=user.id, title="Cave", script_state={})
    setup.add(adventure)
    setup.flush()
    for i in range(TOTAL):
        setup.add(models.Action(
            adventure_id=adventure.id, index=i,
            type="start" if i == 0 else ("ai" if i % 2 else "do"),
            text=f"Action {i}." + "word " * 200,
        ))
    setup.commit()
    adv_id, user_id = adventure.id, user.id
    setup.close()

    monkeypatch.setattr(limits, "rate_limit", lambda *a, **k: None)
    monkeypatch.setattr(limits, "check_row_cap", lambda *a, **k: None)

    def _current_user(db=Depends(get_db)):
        return db.get(models.User, user_id)

    app.dependency_overrides[auth.get_current_user] = _current_user
    c = TestClient(app)
    c.adv_id = adv_id
    try:
        yield c
    finally:
        app.dependency_overrides.clear()
        Base.metadata.drop_all(bind=engine)


def page(client, before_id=None, limit=None):
    params = {}
    if before_id is not None:
        params["before_id"] = before_id
    if limit is not None:
        params["limit"] = limit
    r = client.get(f"/api/adventures/{client.adv_id}/actions", params=params)
    assert r.status_code == 200, r.text
    return r.json()


def add_action(client, text="A new turn.") -> int:
    db = SessionLocal()
    try:
        highest = db.query(models.Action.index).order_by(
            models.Action.index.desc()).first()[0]
        action = models.Action(
            adventure_id=client.adv_id, index=highest + 1, type="ai", text=text
        )
        db.add(action)
        db.commit()
        return action.id
    finally:
        db.close()


# ------------------------------------------------------------- the page load

def test_the_page_load_returns_only_the_newest_window(client):
    r = client.get(f"/api/adventures/{client.adv_id}")
    assert r.status_code == 200
    body = r.json()
    assert len(body["actions"]) == ACTION_PAGE
    assert body["action_count"] == TOTAL
    # ...and it is the *newest* window, ending on the last action.
    assert body["actions"][-1]["index"] == TOTAL - 1
    assert body["actions"][0]["index"] == TOTAL - ACTION_PAGE


def test_a_short_story_is_returned_whole(client):
    db = SessionLocal()
    try:
        db.query(models.Action).filter(models.Action.index >= 5).delete()
        db.commit()
    finally:
        db.close()

    body = client.get(f"/api/adventures/{client.adv_id}").json()
    assert len(body["actions"]) == 5
    assert body["action_count"] == 5


def test_the_page_load_does_not_grow_with_the_story(client):
    """The point of the change. Whatever the story's length, opening it costs
    a window."""
    meter = dbmeter.Meter()
    meter.attach(engine)
    try:
        with meter.scope("page load"):
            client.get(f"/api/adventures/{client.adv_id}")
        windowed = meter.scopes[-1].total.fetched
    finally:
        meter.detach()

    # Each action carries ~1 kB of text and there are 187 of them; a window is
    # 60. Generous ceiling, but far below the whole story.
    assert windowed < ACTION_PAGE * 2_000, f"{windowed:,} B for one window"
    assert windowed < TOTAL * 500, (
        f"{windowed:,} B — that is the whole story, not a window"
    )


# ------------------------------------------------------------------ paging up

def test_the_first_page_is_the_newest(client):
    body = page(client)
    assert len(body["actions"]) == ACTION_PAGE
    assert body["total"] == TOTAL
    assert body["has_more"] is True
    assert body["actions"][-1]["index"] == TOTAL - 1


def test_paging_up_covers_the_whole_story_exactly_once(client):
    seen = []
    body = page(client)
    seen = [a["index"] for a in body["actions"]]
    guard = 0
    while body["has_more"]:
        guard += 1
        assert guard < 20, "paging did not terminate"
        body = page(client, before_id=body["actions"][0]["id"])
        seen = [a["index"] for a in body["actions"]] + seen

    assert seen == list(range(TOTAL)), "gap, duplicate or reordering while paging"


def test_has_more_is_false_at_the_beginning_of_the_story(client):
    body = page(client)
    while body["has_more"]:
        body = page(client, before_id=body["actions"][0]["id"])
    assert body["actions"][0]["index"] == 0


def test_each_page_is_ordered_oldest_first(client):
    body = page(client)
    indices = [a["index"] for a in body["actions"]]
    assert indices == sorted(indices)


# ------------------------------------------------- the reason for the anchor

def test_a_turn_arriving_mid_scroll_does_not_shift_the_next_page(client):
    """The failure an offset would have. Read the newest page, let a turn land,
    then page up: the reader must get exactly what precedes what they hold —
    no duplicate, no skipped action."""
    first = page(client)
    oldest_held = first["actions"][0]

    add_action(client)

    older = page(client, before_id=oldest_held["id"])
    assert older["actions"][-1]["index"] == oldest_held["index"] - 1, \
        "the page shifted when a turn landed"
    assert all(a["index"] < oldest_held["index"] for a in older["actions"])
    # The new turn moved the total, which is fine — it must not move the window.
    assert older["total"] == TOTAL + 1


def test_a_deleted_anchor_reports_the_end_rather_than_a_duplicate_page(client):
    """Undo can remove the action a slow scroll was anchored to. Better to stop
    than to hand back a page the reader already has."""
    body = page(client)
    anchor = body["actions"][0]

    db = SessionLocal()
    try:
        db.query(models.Action).filter(models.Action.id == anchor["id"]).delete()
        db.commit()
    finally:
        db.close()

    after = page(client, before_id=anchor["id"])
    assert after["actions"] == []
    assert after["has_more"] is False


# ------------------------------------------------------------------- limits

def test_limit_is_honoured_and_capped(client):
    assert len(page(client, limit=5)["actions"]) == 5
    # A client asking for the whole story does not get to undo the paging.
    assert len(page(client, limit=100_000)["actions"]) <= ACTION_PAGE * 4


def test_a_nonsense_limit_still_returns_something(client):
    assert len(page(client, limit=0)["actions"]) >= 1
    assert len(page(client, limit=-5)["actions"]) >= 1


# --------------------------------------------------------------------- undo

def test_undo_returns_a_window_not_the_story(client):
    r = client.post(f"/api/adventures/{client.adv_id}/undo")
    assert r.status_code == 200, r.text
    body = r.json()
    assert len(body["actions"]) == ACTION_PAGE
    assert body["total"] == TOTAL - 1
    assert body["has_more"] is True