import pytest

from app.services.adaptive_rag_service.mixin_answer_entry import AdaptiveRAGAnswerEntryMixin
from app.services.adaptive_rag_service.mixin_answer_mainline import AdaptiveRAGAnswerMainlineMixin


class _FakeAdaptiveRAGService(
    AdaptiveRAGAnswerEntryMixin,
    AdaptiveRAGAnswerMainlineMixin,
):
    def __init__(self) -> None:
        self.db = object()
        self.tenant_id = 9
        self.ack_calls = 0
        self.base_calls = 0
        self.base_kwargs: dict[str, object] = {}

    def _normalize_thinking_mode(self, thinking_mode: str) -> str:
        return "deep" if str(thinking_mode or "").strip().lower() == "deep" else "normal"

    async def _prepare_answer_runtime(self, **kwargs):
        clean_q = str(kwargs.get("clean_q") or "").strip()
        action_mode = str(kwargs.get("action_mode") or "").strip().lower()
        return {
            "session_id": 101,
            "turn_index": 2,
            "context_session_id": 101,
            "conversation": [],
            "state_row": None,
            "effective_q": clean_q,
            "rewrite_meta": {"mode": "direct"},
            "query_type": "explain",
            "effective_action_mode": action_mode,
        }

    async def _handle_ack_first_requirement(self, **kwargs):
        self.ack_calls += 1
        _ = kwargs
        return {"answer": "ack-required", "processing_stage": "ack_only"}

    async def _execute_base_answer_mainline(self, **kwargs):
        self.base_calls += 1
        self.base_kwargs = dict(kwargs)
        return {"answer": "base-answer", "processing_stage": "qa"}


@pytest.mark.asyncio
async def test_answer_entry_read_mainline_skips_requirement_ack() -> None:
    service = _FakeAdaptiveRAGService()

    result = await service.answer_question(
        question="现在有哪些阻塞？",
        asked_by=1,
        asked_via="pmflow_manual",
        action_mode="read",
        sync_requirement=True,
    )

    assert result["processing_stage"] == "qa"
    assert service.ack_calls == 0
    assert service.base_calls == 1


@pytest.mark.asyncio
async def test_answer_entry_write_mode_uses_requirement_ack_gate() -> None:
    service = _FakeAdaptiveRAGService()

    result = await service.answer_question(
        question="请同步写入一条风险",
        asked_by=1,
        asked_via="pmflow_manual",
        action_mode="write",
        sync_requirement=True,
    )

    assert result["processing_stage"] == "ack_only"
    assert service.ack_calls == 1
    assert service.base_calls == 0


@pytest.mark.asyncio
async def test_answer_entry_feishu_write_mode_still_goes_base_mainline() -> None:
    service = _FakeAdaptiveRAGService()

    result = await service.answer_question(
        question="请在飞书里补一条风险",
        asked_by=1,
        asked_via="feishu",
        action_mode="write",
        sync_requirement=True,
    )

    assert result["processing_stage"] == "qa"
    assert service.ack_calls == 0
    assert service.base_calls == 1
    assert int(service.base_kwargs["deep_retrieval_steps"]) <= 3
    assert int(service.base_kwargs["deep_vector_top_k"]) <= 8