"""Real-Postgres proof that a batch create cannot be interfered with (#4016).

What mocks cannot show: that the ids a placeholder is rewritten to are the ids
the rows actually got, that two batches running at the same time each cite
their OWN records, and that a failing batch leaves nothing behind. Those are
properties of the sequence and the transaction, so they are measured against
the real ones.
"""
import asyncio
from unittest.mock import MagicMock, patch

import pytest
import pytest_asyncio
from sqlalchemy import func, select

from scribe.models import async_session
from scribe.models.milestone import Milestone
from scribe.models.note import Note
from scribe.models.project import Project
from scribe.services import record_refs
from scribe.services.planning import start_planning
from scribe.services.record_batch import BatchItem, create_batch
from tests.helpers import ensure_user

pytestmark = [pytest.mark.integration, pytest.mark.usefixtures("_dispose_engine")]


@pytest.fixture(autouse=True)
def _no_embedding():
    # embed_note detaches a task that loads the embedding model; this lane is
    # about ids and transactions, and a background model load would outlive
    # the test's event loop.
    with patch("scribe.services.notes.embed_note", MagicMock()):
        yield


@pytest_asyncio.fixture
async def seeded():
    async with async_session() as s:
        owner = await ensure_user(s, "record_batch_owner")
        project = Project(user_id=owner.id, title="Batch target")
        s.add(project)
        await s.flush()
        ids = {"owner": owner.id, "pid": project.id}
        await s.commit()
    return ids


async def _count_in_project(pid: int) -> tuple[int, int]:
    async with async_session() as s:
        notes = (await s.execute(select(func.count(Note.id)).where(Note.project_id == pid))).scalar()
        milestones = (await s.execute(
            select(func.count(Milestone.id)).where(Milestone.project_id == pid)
        )).scalar()
    return notes, milestones


async def test_a_plan_and_its_steps_cite_each_others_real_ids(seeded):
    owner, pid = seeded["owner"], seeded["pid"]
    out = await start_planning(
        owner, pid, "Ship it",
        body="First {{ref:1}}, then {{ref:2}}.",
        steps=[
            BatchItem(title="Step one", body="Part of {{ref:milestone}}; next is {{ref:2}}."),
            BatchItem(title="Step two", body="Follows {{ref:1}}."),
        ],
    )
    ms = out["milestone"]
    one, two = out["steps"]
    assert ms["body"] == f'First #{one["id"]} "Step one", then #{two["id"]} "Step two".'
    assert one["body"] == f'Part of milestone {ms["id"]} "Ship it"; next is #{two["id"]} "Step two".'
    assert two["body"] == f'Follows #{one["id"]} "Step one".'
    assert one["milestone_id"] == two["milestone_id"] == ms["id"]
    assert one["project_id"] == pid

    # What was returned is what was stored — not a rewrite applied to the
    # response alone.
    async with async_session() as s:
        stored = await s.get(Note, two["id"])
        assert stored.body == f'Follows #{one["id"]} "Step one".'


async def test_concurrent_batches_each_cite_their_own_records(seeded):
    """The operator's scenario: several sessions creating at once. Each batch
    must resolve {{ref:1}} to ITS first record, whatever the others take."""
    owner, pid = seeded["owner"], seeded["pid"]

    async def one_batch(tag: str):
        return await create_batch(owner, [
            BatchItem(title=f"{tag} first"),
            BatchItem(title=f"{tag} second", body="points at {{ref:1}}"),
        ], project_id=pid)

    results = await asyncio.gather(*(one_batch(f"session-{i}") for i in range(6)))

    all_ids = [n.id for _ms, notes in results for n in notes]
    assert len(all_ids) == len(set(all_ids)), "the sequence handed out an id twice"
    for _ms, (first, second) in results:
        assert second.body == f'points at #{first.id} "{first.title}"'
        async with async_session() as s:
            assert (await s.get(Note, first.id)).title == first.title


async def test_a_failing_batch_writes_nothing(seeded):
    owner, pid = seeded["owner"], seeded["pid"]
    before = await _count_in_project(pid)
    with pytest.raises(ValueError, match="Invalid status"):
        await start_planning(owner, pid, "Doomed", steps=[
            BatchItem(title="fine"),
            BatchItem(title="broken", status="someday"),
        ])
    assert await _count_in_project(pid) == before, "a partial batch (or its milestone) was left behind"


async def test_a_guess_above_the_real_highest_id_is_refused(seeded):
    owner, pid = seeded["owner"], seeded["pid"]
    _ms, (made,) = await create_batch(owner, [BatchItem(title="anchor")], project_id=pid)
    # `made` is the newest row, so anything just past it can only be a guess —
    # unless a parallel test in the lane created more since, which only moves
    # the ceiling up and keeps made.id itself a real id.
    with pytest.raises(ValueError, match="does not exist yet"):
        await record_refs.refuse_guessed_ids(f"#{made.id + record_refs.GUESS_WINDOW}")
    await record_refs.refuse_guessed_ids(f"#{made.id}")