"""Real-Postgres tests for finding a plan by meaning (milestone 415, step 3).

A project's roadmap written as milestones was invisible to recall: `search`
covered notes, tasks and rules, so "is there already a plan for this?" had no
tool. What a mock cannot show is the join scoping the vectors to a project and
to what the caller may read, so these seed real milestones with hand-made
vectors and stub only the embedder.
"""
import uuid
from unittest.mock import AsyncMock, patch

import pytest
import pytest_asyncio

from scribe.models import async_session
from scribe.models.embedding import EMBEDDING_DIM, MilestoneEmbedding
from scribe.models.milestone import Milestone
from scribe.models.project import Project
from scribe.services.embeddings import CHUNKER_VERSION, semantic_search_milestones
from tests.helpers import ensure_user

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

NEAR = [1.0] + [0.0] * (EMBEDDING_DIM - 1)
FAR = [0.0, 1.0] + [0.0] * (EMBEDDING_DIM - 2)


@pytest_asyncio.fixture
async def roadmap():
    tag = uuid.uuid4().hex[:8]
    async with async_session() as s:
        owner = await ensure_user(s, f"ms_search_owner_{tag}")
        stranger = await ensure_user(s, f"ms_search_stranger_{tag}")
        mine = Project(user_id=owner.id, title="Librarian")
        other = Project(user_id=owner.id, title="Elsewhere")
        s.add_all([mine, other])
        await s.flush()
        m3 = Milestone(user_id=owner.id, project_id=mine.id, title="M3 — Metadata",
                       description="works, editions, providers, provenance", status="active")
        done = Milestone(user_id=owner.id, project_id=mine.id, title="Covers",
                         description="cover art", status="done")
        unrelated = Milestone(user_id=owner.id, project_id=mine.id, title="Android client",
                              description="native app", status="active")
        foreign = Milestone(user_id=owner.id, project_id=other.id, title="Metadata elsewhere",
                            description="same words, other project", status="active")
        s.add_all([m3, done, unrelated, foreign])
        await s.flush()
        for ms, vec in ((m3, NEAR), (done, NEAR), (unrelated, FAR), (foreign, NEAR)):
            s.add(MilestoneEmbedding(milestone_id=ms.id, chunk_index=0, embedding=vec,
                                     chunk_text=ms.title, chunker_version=CHUNKER_VERSION))
        ids = {"owner": owner.id, "stranger": stranger.id, "mine": mine.id,
               "m3": m3.id, "done": done.id, "unrelated": unrelated.id, "foreign": foreign.id}
        await s.commit()
    return ids


async def _found(user_id, **kw) -> list[int]:
    with patch("scribe.services.embeddings.get_embedding", AsyncMock(return_value=NEAR)):
        hits = await semantic_search_milestones(user_id, "book metadata and providers",
                                                threshold=0.5, limit=10, **kw)
    return [m.id for _s, m in hits]


async def test_a_plan_is_found_in_its_project_and_not_in_another(roadmap):
    found = await _found(roadmap["owner"], project_id=roadmap["mine"])
    assert set(found) == {roadmap["m3"], roadmap["done"]}
    assert roadmap["foreign"] not in found and roadmap["unrelated"] not in found


async def test_status_narrows_to_open_plans(roadmap):
    found = await _found(roadmap["owner"], project_id=roadmap["mine"], status="active")
    assert found == [roadmap["m3"]]


async def test_without_a_project_it_searches_the_callers_own(roadmap):
    found = await _found(roadmap["owner"])
    assert {roadmap["m3"], roadmap["done"], roadmap["foreign"]} <= set(found)


async def test_a_project_the_caller_cannot_read_returns_nothing(roadmap):
    assert await _found(roadmap["stranger"], project_id=roadmap["mine"]) == []
    assert await _found(roadmap["stranger"]) == []