# -*- coding: utf-8 -*-
"""
Search 路径 e2e 测试

不完整启动 HyMemoryClient（重）；通过组合真实 CodingMemoryStore + 轻量 SimpleNamespace
直接测 _search_coding；并为入参归一化逻辑做局部测试。
"""

import asyncio
import os
import shutil
import tempfile
import uuid
from types import SimpleNamespace
from typing import List

import pytest

from hy_memory.client import HyMemoryClient
from hy_memory.coding.store import CodingMemoryStore
from hy_memory.coding.types import CodingMemory, WorkingFact

from tests.coding._helpers import MockEmbedService, MockLLMProvider


# ================================================================
# Fixtures（避免重复全启 client）
# ================================================================

@pytest.fixture
async def search_ctx(tmp_data_dir, mock_embed):
    """
    构造一个轻量 client-like ctx，含真实 CodingMemoryStore + mock embed。
    适合测 HyMemoryClient._search_coding 这个 method。
    """
    from hy_memory.config import MemoryConfig

    cfg = MemoryConfig.from_env()
    cfg.history.db_path = os.path.join(tmp_data_dir, "history.db")
    cfg.coding.db_path = os.path.join(tmp_data_dir, "coding_memory.db")
    cfg.vector_store.provider = "chroma"
    cfg.vector_store.path = os.path.join(tmp_data_dir, "chroma")
    cfg.vector_store.collection_name = f"test_search_{uuid.uuid4().hex[:8]}"
    cfg.vector_store.embedding_dims = 1536

    store = CodingMemoryStore(cfg, embed_service=mock_embed)
    await store.initialize()

    # 一个绑了所需属性的 SimpleNamespace 当 self 用
    ns = SimpleNamespace(
        _embed_service=mock_embed,
        _coding_store=store,
        _coding_writer=object(),  # 占位，让 _get_coding_writer 跳过 lazy
        _coding_llm_provider=None,
        _coding_init_lock=asyncio.Lock(),
    )

    async def _stub_get_coding_writer():
        return ns._coding_writer

    ns._get_coding_writer = _stub_get_coding_writer

    yield ns
    await store.close()


def _seed_memories(store_to_seed: CodingMemoryStore, mock_embed: MockEmbedService):
    """同步种几个用于测试的 memory（要在 fixture 之外用 asyncio.run 跑）。"""
    async def _do():
        await store_to_seed.insert(CodingMemory(
            experience_id="m_publish", user_id="u1", task="打包发布到私有包索引",
            search_keys=["凭证位置", "twine upload"], solution="详细发布步骤",
            boundary_envs="twine>=6", workspace_id="ws/a",
            files=["scripts/publish_package.sh"], confidence=0.9,
        ))
        await store_to_seed.insert(CodingMemory(
            experience_id="m_pnpm", user_id="u1", task="本项目用 pnpm",
            search_keys=["不要用 npm"], solution="所有项目用 pnpm",
confidence=1.0,
        ))
        await store_to_seed.insert(CodingMemory(
            experience_id="m_other_user", user_id="u_other", task="其他用户记忆",
            solution="x",
        ))
    asyncio.run(_do())


# ================================================================
# _search_coding 路径测试
# ================================================================

@pytest.mark.asyncio
class TestSearchCodingMethod:
    async def test_hit_by_task(self, search_ctx, mock_embed):
        # 在已 init 的 store 中插入数据
        await search_ctx._coding_store.insert(CodingMemory(
            experience_id="m_publish", user_id="u1", task="打包发布到私有包索引",
            search_keys=["凭证位置"], solution="详细发布步骤",
            boundary_envs="twine>=6",
            workspace_id="ws/a", files=["scripts/publish_package.sh"], confidence=0.9,
        ))

        import time
        resp = await HyMemoryClient._search_coding(
            search_ctx,
            target_query="打包发布到私有包索引",
            user_ids=["u1"],
            workspace_id="ws/a",
            branch=None,
            limit=10,
            working_fact_min_score=0.0,
            request_id="req-1",
            t0=time.perf_counter(),
        )
        assert resp["scene"] == "productivity"
        assert resp["request_id"] == "req-1"
        assert "elapsed_ms" in resp
        mems = resp["experiences"]
        assert len(mems) == 1
        m = mems[0]
        assert m["experience_id"] == "m_publish"
        assert m["task"] == "打包发布到私有包索引"
        assert m["search_keys"] == ["凭证位置"]
        assert m["solution"] == "详细发布步骤"
        assert m["boundary_envs"] == "twine>=6"
        assert m["workspace_id"] == "ws/a"
        assert m["files"] == ["scripts/publish_package.sh"]
        assert m["matched_key"] == "打包发布到私有包索引"
        assert m["matched_key_kind"] == "task"
        assert m["score"] > 0.9
        assert m["confidence"] == 0.9

    async def test_hit_by_search_key(self, search_ctx, mock_embed):
        await search_ctx._coding_store.insert(CodingMemory(
            experience_id="m_publish", user_id="u1", task="打包发布到私有包索引",
            search_keys=["凭证位置"], solution="...",
confidence=0.9,
        ))

        import time
        resp = await HyMemoryClient._search_coding(
            search_ctx,
            target_query="凭证位置", user_ids=["u1"],
            workspace_id=None, branch=None,
            limit=10, working_fact_min_score=0.0,
            request_id="r", t0=time.perf_counter(),
        )
        mems = resp["experiences"]
        assert len(mems) == 1
        assert mems[0]["matched_key_kind"] == "aspect"
        assert mems[0]["matched_key"] == "凭证位置"

    async def test_workspace_filters(self, search_ctx, mock_embed):
        """workspace 传了就按作用域筛：换 workspace 召不回，不传则全量召回。"""
        await search_ctx._coding_store.insert(CodingMemory(
            experience_id="m1", user_id="u1", task="task A", solution="S",
            workspace_id="ws/a",
        ))

        import time
        for ws, expect in (("ws/a", 1), ("ws/b", 0), (None, 1)):
            resp = await HyMemoryClient._search_coding(
                search_ctx,
                target_query="task A", user_ids=["u1"],
                workspace_id=ws, branch=None,
                limit=10, working_fact_min_score=0.0,
                request_id="r", t0=time.perf_counter(),
            )
            assert len(resp["experiences"]) == expect, f"workspace_id={ws!r}"
            if expect:
                assert resp["experiences"][0]["workspace_id"] == "ws/a"

    async def test_min_score_filter(self, search_ctx, mock_embed):
        await search_ctx._coding_store.insert(CodingMemory(
            experience_id="m_unrelated", user_id="u1", task="task X",
            solution="S",
        ))

        import time
        # 用一个跟 task 不相关的 query；mock embed 用 hash → 相似度低
        resp = await HyMemoryClient._search_coding(
            search_ctx,
            target_query="完全无关的查询字符串 ABCDEFG xyz",
            user_ids=["u1"],
            workspace_id=None, branch=None,
            limit=10, working_fact_min_score=0.99,  # 高阈值过滤掉一切
            request_id="r", t0=time.perf_counter(),
        )
        assert resp["experiences"] == []

    async def test_user_isolation(self, search_ctx, mock_embed):
        await search_ctx._coding_store.insert(CodingMemory(
            experience_id="m_other", user_id="u_other", task="my task",
            solution="S",
        ))

        import time
        resp = await HyMemoryClient._search_coding(
            search_ctx,
            target_query="my task", user_ids=["u1"],
            workspace_id=None, branch=None,
            limit=10, working_fact_min_score=0.0,
            request_id="r", t0=time.perf_counter(),
        )
        assert resp["experiences"] == []

    async def test_empty_store_returns_empty(self, search_ctx, mock_embed):
        import time
        resp = await HyMemoryClient._search_coding(
            search_ctx,
            target_query="anything", user_ids=["u1"],
            workspace_id=None, branch=None,
            limit=10, working_fact_min_score=0.0,
            request_id="r", t0=time.perf_counter(),
        )
        assert resp["experiences"] == []
        assert resp["facts"] == []
        assert resp["scene"] == "productivity"


# ================================================================
# 双层召回：事实主索引 + 顺链带经验 + 直查兜底
# ================================================================

@pytest.mark.asyncio
class TestDualLayerSearch:
    async def _search(self, ctx, query, *, limit=10, min_score=0.0,
                      exp_min_score=None):
        import time
        return await HyMemoryClient._search_coding(
            ctx,
            target_query=query, user_ids=["u1"],
            workspace_id=None, branch=None,
            limit=limit, working_fact_min_score=min_score,
            working_experience_min_score=exp_min_score,
            request_id="r", t0=time.perf_counter(),
        )

    async def test_fact_hit_returns_fact_layer(self, search_ctx):
        await search_ctx._coding_store.insert_fact(WorkingFact(
            fact_id="f1", user_id="u1",
            statement="new_file_search 位于 src/search.py",
            files=["src/search.py"],
        ))

        resp = await self._search(search_ctx, "new_file_search 位于 src/search.py")
        assert len(resp["facts"]) == 1
        f = resp["facts"][0]
        assert f["fact_id"] == "f1"
        assert f["statement"] == "new_file_search 位于 src/search.py"
        assert f["files"] == ["src/search.py"]
        assert f["created_at"] is not None
        assert f["score"] > 0.9

    async def _linked_fixture(self, ctx):
        """一条 task 跟 query 完全不像的经验，只能靠事实顺链够到。"""
        await ctx._coding_store.insert(CodingMemory(
            experience_id="e1", user_id="u1",
            task="毫不相干的任务名 QQQQ", solution="怎么改 search 实现",
        ))
        await ctx._coding_store.insert_fact(WorkingFact(
            fact_id="f1", user_id="u1",
            statement="new_file_search 位于 src/search.py",
            derived_experience_ids=["e1"],
        ))

    async def test_fact_carries_linked_experience(self, search_ctx):
        """经验自身跟 query 不像，靠命中的事实被认出来，标 fact_link。"""
        await self._linked_fixture(search_ctx)

        resp = await self._search(
            search_ctx, "new_file_search 位于 src/search.py", exp_min_score=0.0,
        )
        assert [e["experience_id"] for e in resp["experiences"]] == ["e1"]
        assert resp["experiences"][0]["via"] == "fact_link"

    async def test_linked_experience_is_gated_not_exempt(self, search_ctx):
        """顺链不是免检：分不够就不放进来，哪怕担保它的事实命中了。

        早期这一路完全豁免，实测会让事实把"另一个侧面"的无关经验一起拖进来。
        """
        await self._linked_fixture(search_ctx)

        resp = await self._search(
            search_ctx, "new_file_search 位于 src/search.py", exp_min_score=0.99,
        )
        assert [f["fact_id"] for f in resp["facts"]] == ["f1"]  # 事实照样命中
        assert resp["experiences"] == []                        # 经验被闸门挡下

    async def test_both_experience_paths_share_one_gate(self, search_ctx):
        """顺链和直查卡同一道闸门，没有单独给顺链开的后门。

        两路卡的本来就是同一批分数（顺链借的就是直查那轮的分），分两档没有依据。
        事实背书体现在排序上——顺链排在直查前面——而不是准入上打折。
        """
        await self._linked_fixture(search_ctx)

        loose = await self._search(
            search_ctx, "new_file_search 位于 src/search.py", exp_min_score=0.0,
        )
        strict = await self._search(
            search_ctx, "new_file_search 位于 src/search.py", exp_min_score=0.99,
        )
        # 同一条经验，只由 working_experience_min_score 一个值决定进不进来
        assert [e["experience_id"] for e in loose["experiences"]] == ["e1"]
        assert strict["experiences"] == []
        # 事实层有自己的阈值，不受经验那道影响
        assert len(strict["facts"]) == 1

    async def test_direct_hit_marked_via_direct(self, search_ctx):
        await search_ctx._coding_store.insert(CodingMemory(
            experience_id="e1", user_id="u1", task="打包发布到私有包索引", solution="S",
        ))

        resp = await self._search(search_ctx, "打包发布到私有包索引")
        assert resp["facts"] == []
        assert [e["experience_id"] for e in resp["experiences"]] == ["e1"]
        assert resp["experiences"][0]["via"] == "direct"
        assert resp["experiences"][0]["score"] > 0.9

    async def test_fact_link_wins_over_direct_on_dedup(self, search_ctx):
        """同一条经验既被事实带出又被直查命中，只出现一次，标 fact_link。"""
        await search_ctx._coding_store.insert(CodingMemory(
            experience_id="e1", user_id="u1", task="共同的查询词", solution="S",
        ))
        await search_ctx._coding_store.insert_fact(WorkingFact(
            fact_id="f1", user_id="u1", statement="共同的查询词",
            derived_experience_ids=["e1"],
        ))

        resp = await self._search(search_ctx, "共同的查询词")
        assert len(resp["experiences"]) == 1
        assert resp["experiences"][0]["via"] == "fact_link"
        # 直查那一路的分数仍然带出来，不因为走了链就丢掉
        assert resp["experiences"][0]["score"] > 0.9

    async def test_dead_link_filtered(self, search_ctx):
        """事实指向一条已被 DELETE 的经验，存在性过滤应该把死链滤掉。"""
        await search_ctx._coding_store.insert_fact(WorkingFact(
            fact_id="f1", user_id="u1", statement="指向幽灵经验的事实",
            derived_experience_ids=["ghost"],
        ))

        resp = await self._search(search_ctx, "指向幽灵经验的事实")
        assert len(resp["facts"]) == 1
        assert resp["experiences"] == []

    async def test_superseded_fact_not_recalled(self, search_ctx):
        await search_ctx._coding_store.insert_fact(WorkingFact(
            fact_id="f_old", user_id="u1", statement="config 位于 /opt/app/config.yaml",
        ))
        await search_ctx._coding_store.insert_fact(WorkingFact(
            fact_id="f_new", user_id="u1", statement="config 位于 /etc/app/config.yaml",
        ))
        await search_ctx._coding_store.supersede_fact("f_old", "f_new")

        resp = await self._search(search_ctx, "config 位于 /opt/app/config.yaml")
        assert [f["fact_id"] for f in resp["facts"]] == ["f_new"]

    async def test_min_score_filters_facts(self, search_ctx):
        await search_ctx._coding_store.insert_fact(WorkingFact(
            fact_id="f1", user_id="u1", statement="某条事实",
        ))

        assert len((await self._search(search_ctx, "某条事实"))["facts"]) == 1
        resp = await self._search(search_ctx, "完全无关的查询 ABCDEFG", min_score=0.99)
        assert resp["facts"] == []

    async def test_low_score_fact_does_not_drag_experience(self, search_ctx):
        """低分事实被闸门挡掉后，不该再顺链把它的经验带进结果。

        事实层是主索引，噪声在这里会放大成一串无关经验。
        """
        await search_ctx._coding_store.insert(CodingMemory(
            experience_id="e1", user_id="u1", task="无关的经验", solution="S",
        ))
        await search_ctx._coding_store.insert_fact(WorkingFact(
            fact_id="f1", user_id="u1", statement="无关的事实",
            derived_experience_ids=["e1"],
        ))

        resp = await self._search(
            search_ctx, "完全不沾边的查询 ZZZZZ", min_score=0.99,
        )
        assert resp["facts"] == []
        assert resp["experiences"] == []

    async def test_fact_user_isolation(self, search_ctx):
        await search_ctx._coding_store.insert_fact(WorkingFact(
            fact_id="f1", user_id="u_other", statement="别人的事实",
        ))

        resp = await self._search(search_ctx, "别人的事实")
        assert resp["facts"] == []

    async def test_facts_respect_limit_below_floor(self, search_ctx):
        """limit 小于事实层取数下限（5）时，返回条数仍要落回 limit。

        事实层按 max(limit, 5) 取，多出来的那几条是给阈值过滤留的余量，
        不该直接透到结果里。
        """
        for i in range(6):
            await search_ctx._coding_store.insert_fact(WorkingFact(
                fact_id=f"f{i}", user_id="u1", statement=f"同一批事实 {i}",
            ))

        resp = await self._search(search_ctx, "同一批事实 0", limit=2)
        assert len(resp["facts"]) == 2

    async def test_experiences_capped_at_limit_across_both_sources(self, search_ctx):
        """顺链 + 直查合并后总数不超过 limit，且优先保留顺链那批。"""
        for i in range(4):
            await search_ctx._coding_store.insert(CodingMemory(
                experience_id=f"linked{i}", user_id="u1",
                task=f"被事实链带出的经验 {i}", solution="S",
            ))
        # 直查能命中的经验：task 与 query 一致
        for i in range(4):
            await search_ctx._coding_store.insert(CodingMemory(
                experience_id=f"direct{i}", user_id="u1",
                task="同一批事实 0", solution="S",
            ))
        await search_ctx._coding_store.insert_fact(WorkingFact(
            fact_id="f1", user_id="u1", statement="同一批事实 0",
            derived_experience_ids=[f"linked{i}" for i in range(4)],
        ))

        resp = await self._search(search_ctx, "同一批事实 0", limit=3)
        assert len(resp["experiences"]) == 3
        # 顺链在前，limit 砍掉的应该是直查那批
        assert all(e["via"] == "fact_link" for e in resp["experiences"])

    async def test_dead_links_do_not_eat_limit_slots(self, search_ctx):
        """死链在 get_many 就被丢了，不该占掉 limit 名额。

        截断如果放在 get_many 之前，前几个死链会把名额吃光，实际返回数够不到 limit。
        """
        await search_ctx._coding_store.insert(CodingMemory(
            experience_id="alive", user_id="u1", task="活着的经验", solution="S",
        ))
        await search_ctx._coding_store.insert_fact(WorkingFact(
            fact_id="f1", user_id="u1", statement="带死链的事实",
            # 前两个 experience_id 库里不存在
            derived_experience_ids=["ghost1", "ghost2", "alive"],
        ))

        resp = await self._search(search_ctx, "带死链的事实", limit=1)
        assert [e["experience_id"] for e in resp["experiences"]] == ["alive"]
        # 必须是顺链拿到的。直查也可能捞到 alive，那样这条测试会假通过
        assert resp["experiences"][0]["via"] == "fact_link"


# ================================================================
# 入参归一化测试 — 不需要完整 client，直接静态调用
# ================================================================

class TestInputNormalization:
    """入参校验逻辑测试（用 ValueError 触发即可）"""

    def test_query_and_queries_mutex_via_async(self):
        # async_search 的入参校验在最开头，可以直接 await 一个未初始化的 client 测它
        # 用一个最小 mock client 走到那段逻辑
        async def _run():
            class _DummyClient:
                _coding_llm_provider = None

                async def _check(self, query=None, queries=None):
                    # 复用真正的 async_search 校验逻辑（直接 raise）
                    if queries is not None and query is not None:
                        raise ValueError("query and queries are mutually exclusive; choose one")
                    if queries is None and query is None:
                        raise ValueError("either query or queries is required")
                    if queries is not None and (not isinstance(queries, list) or not queries):
                        raise ValueError("queries must be a non-empty list[str]")

            c = _DummyClient()
            # 互斥
            with pytest.raises(ValueError, match="mutually exclusive"):
                await c._check(query="a", queries=["b"])
            # 都没传
            with pytest.raises(ValueError, match="either query or queries"):
                await c._check()
            # 空 list
            with pytest.raises(ValueError, match="non-empty"):
                await c._check(queries=[])

        asyncio.run(_run())