"""MSTeams 存储类单元测试 (polls/pairing/feedback/sso/conv_store/sent_cache)。"""

from __future__ import annotations

import json
import time
from pathlib import Path

import pytest

from yuxi.channels.adapters.msteams.polls import PollStore
from yuxi.channels.adapters.msteams.pairing import PairingManager, build_pairing_request_card, _make_pair_id
from yuxi.channels.adapters.msteams.feedback import (
    FeedbackLearningsStore,
    process_feedback,
    parse_reflection_response,
    build_feedback_channel_data,
    build_feedback_activity,
    is_feedback_invoke,
    parse_feedback_value,
    build_reflection_prompt,
)
from yuxi.channels.adapters.msteams.sso import SSOTokenStore
from yuxi.channels.adapters.msteams.proactive import (
    ConversationStore,
    MemoryConversationStore,
    extract_conversation_ref,
)
from yuxi.channels.adapters.msteams.sent_message_cache import SentMessageCache


class TestPollStore:
    @pytest.fixture
    def store(self, tmp_path):
        return PollStore(storage_dir=str(tmp_path))

    def test_create_poll(self, store):
        poll = store.create_poll("poll-1", "Test Poll", ["A", "B", "C"])
        assert poll["poll_id"] == "poll-1"
        assert poll["title"] == "Test Poll"
        assert len(poll["options"]) == 3

    def test_create_poll_with_creator(self, store):
        poll = store.create_poll("poll-2", "Poll", ["A", "B"], creator_id="user-1")
        assert poll["creator_id"] == "user-1"

    def test_create_poll_multi_select(self, store):
        poll = store.create_poll("poll-3", "Poll", ["A", "B"], multi_select=True, max_selections=2)
        assert poll["multi_select"] is True
        assert poll["max_selections"] == 2

    @pytest.mark.asyncio
    async def test_cast_vote(self, store):
        store.create_poll("poll-1", "Test", ["A", "B"])
        result = await store.cast_vote("poll-1", "user-1", "A")
        assert result is True

    @pytest.mark.asyncio
    async def test_cast_vote_invalid_option(self, store):
        store.create_poll("poll-1", "Test", ["A", "B"])
        result = await store.cast_vote("poll-1", "user-1", "C")
        assert result is False

    @pytest.mark.asyncio
    async def test_cast_vote_poll_not_found(self, store):
        result = await store.cast_vote("nonexistent", "user-1", "A")
        assert result is False

    @pytest.mark.asyncio
    async def test_cast_vote_duplicate(self, store):
        store.create_poll("poll-1", "Test", ["A", "B"])
        await store.cast_vote("poll-1", "user-1", "A")
        result = await store.cast_vote("poll-1", "user-1", "B")
        assert result is False

    def test_get_results(self, store):
        store.create_poll("poll-1", "Test", ["A", "B"])

        import asyncio

        async def _vote():
            await store.cast_vote("poll-1", "user-1", "A")
            await store.cast_vote("poll-1", "user-2", "A")
            await store.cast_vote("poll-1", "user-3", "B")

        asyncio.run(_vote())

        results = store.get_results("poll-1")
        assert results is not None
        assert results["total_votes"] == 3
        assert results["tally"]["A"] == 2
        assert results["tally"]["B"] == 1

    def test_get_results_nonexistent(self, store):
        assert store.get_results("nonexistent") is None

    def test_get_poll(self, store):
        store.create_poll("poll-1", "Test", ["A"])
        poll = store.get_poll("poll-1")
        assert poll is not None
        assert poll["title"] == "Test"

    def test_has_voted(self, store):
        store.create_poll("poll-1", "Test", ["A"])

        import asyncio

        async def _vote():
            await store.cast_vote("poll-1", "user-1", "A")

        asyncio.run(_vote())

        assert store.has_voted("poll-1", "user-1") is True
        assert store.has_voted("poll-1", "user-2") is False

    def test_active_count(self, store):
        store.create_poll("poll-1", "Test", ["A"])
        store.create_poll("poll-2", "Test", ["B"])
        assert store.active_count == 2

    def test_cleanup(self, store):
        store.create_poll("poll-1", "Test", ["A"])
        store.cleanup()
        assert store.active_count == 1


class TestPairingManager:
    @pytest.fixture
    def manager(self, tmp_path):
        return PairingManager(storage_dir=str(tmp_path))

    def test_request_pairing(self, manager):
        pair_id = manager.request_pairing("user-1", "Test User", "chat-1")
        assert pair_id.startswith("req_")
        assert pair_id.endswith(str(int(time.time())))
        assert manager.is_pending("user-1") is True

    def test_approve_pairing(self, manager):
        pair_id = manager.request_pairing("user-1", "Test User")
        result = manager.approve(pair_id)
        assert result is True
        assert manager.is_approved("user-1") is True
        assert manager.is_pending("user-1") is False

    def test_approve_nonexistent(self, manager):
        result = manager.approve("nonexistent")
        assert result is False

    def test_deny_pairing(self, manager):
        pair_id = manager.request_pairing("user-1", "Test User")
        result = manager.deny(pair_id)
        assert result is True
        assert manager.is_approved("user-1") is False
        assert manager.is_pending("user-1") is False

    def test_deny_nonexistent(self, manager):
        result = manager.deny("nonexistent")
        assert result is False

    def test_get_pending_requests(self, manager):
        manager.request_pairing("user-1", "User One")
        manager.request_pairing("user-2", "User Two")
        pending = manager.get_pending_requests()
        assert len(pending) == 2

    def test_cleanup(self, manager):
        pair_id = manager.request_pairing("user-1", "User")
        count = manager.cleanup()
        assert count > 0

    def test_persistence(self, tmp_path):
        mgr1 = PairingManager(storage_dir=str(tmp_path))
        pair_id = mgr1.request_pairing("user-1", "Test")
        mgr1.approve(pair_id)

        mgr2 = PairingManager(storage_dir=str(tmp_path))
        assert mgr2.is_approved("user-1") is True


class TestBuildPairingRequestCard:
    def test_card_structure(self):
        card = build_pairing_request_card("Test User", "user-001", "req_123")
        assert card["type"] == "AdaptiveCard"
        assert card["version"] == "1.5"
        assert len(card["actions"]) == 2
        assert card["actions"][0]["title"] == "批准"
        assert card["actions"][1]["title"] == "拒绝"


class TestMakePairId:
    def test_format(self):
        result = _make_pair_id("user-001-abc", 1000000.0)
        assert result.startswith("req_user-001-abc")
        assert str(int(1000000)) in result


class TestFeedbackLearningsStore:
    @pytest.fixture
    def store(self, tmp_path):
        return FeedbackLearningsStore(storage_dir=str(tmp_path))

    def test_is_reflection_allowed_initial(self, store):
        assert store.is_reflection_allowed("session-1") is True

    def test_store_and_load_learnings(self, store):
        store.store_session_learning("session-1", "user msg", "bot reply", "reflection text")
        learnings = store.load_session_learnings("session-1")
        assert len(learnings) == 1
        assert learnings[0]["reflection"] == "reflection text"

    def test_session_count(self, store):
        store.store_session_learning("session-1", "msg", "reply", "reflect")
        store.store_session_learning("session-2", "msg", "reply", "reflect")
        assert store.session_count == 2

    def test_clear(self, store):
        store.store_session_learning("session-1", "msg", "reply", "reflect")
        store.clear()
        assert store.session_count == 0

    def test_cooldown(self, store):
        store.store_session_learning("session-1", "msg", "reply", "reflect")
        assert store.is_reflection_allowed("session-1") is False

    def test_clear_cooldowns(self, store):
        store.store_session_learning("session-1", "msg", "reply", "reflect")
        store.clear_reflection_cooldowns("session-1")
        assert store.is_reflection_allowed("session-1") is True

    def test_load_session_learnings_empty(self, store):
        assert store.load_session_learnings("nonexistent") == []


class TestFeedbackFunctions:
    def test_build_feedback_channel_data_disabled(self):
        result = build_feedback_channel_data(feedback_enabled=False)
        assert result is None

    def test_build_feedback_channel_data_enabled(self):
        result = build_feedback_channel_data(feedback_enabled=True)
        assert result is not None
        assert result["feedbackLoopEnabled"] is True

    def test_build_feedback_channel_data_with_reflection(self):
        result = build_feedback_channel_data(feedback_enabled=True, feedback_reflection=True)
        assert result["feedbackReflection"] is True

    def test_build_feedback_activity(self):
        activity = build_feedback_activity("hello", feedback_enabled=True)
        assert activity["text"] == "hello"
        assert "channelData" in activity

    def test_is_feedback_invoke(self):
        assert is_feedback_invoke({"name": "message/submitAction"}) is True
        assert is_feedback_invoke({"name": "other"}) is False

    def test_parse_feedback_value(self):
        result = parse_feedback_value({"value": {"feedbackValue": "like"}})
        assert result == "like"

    def test_parse_feedback_value_missing(self):
        result = parse_feedback_value({})
        assert result == ""

    def test_build_reflection_prompt(self):
        prompt = build_reflection_prompt("user text", "bot text")
        assert "user text" in prompt
        assert "bot text" in prompt
        assert "👎" in prompt

    def test_parse_reflection_json(self):
        raw = json.dumps({"reflection": "I should improve"})
        result = parse_reflection_response(raw)
        assert result == "I should improve"

    def test_parse_reflection_code_block(self):
        raw = '```json\n{"reflection": "from code"}\n```'
        result = parse_reflection_response(raw)
        assert result == "from code"

    def test_parse_reflection_fallback(self):
        raw = "plain text reflection"
        result = parse_reflection_response(raw)
        assert result == "plain text reflection"


class TestProcessFeedback:
    def test_positive_feedback(self):
        activity = {
            "name": "message/submitAction",
            "value": {"feedbackValue": "positive"},
            "from": {"id": "user-1", "name": "Test", "aadObjectId": "aad-1"},
        }
        result = process_feedback(activity)
        assert result["is_positive"] is True
        assert result["is_negative"] is False
        assert result["user_id"] == "aad-1"

    def test_negative_feedback(self):
        activity = {
            "name": "message/submitAction",
            "value": {"feedbackValue": "negative"},
            "from": {"id": "user-1", "name": "Test", "aadObjectId": "aad-1"},
        }
        result = process_feedback(activity)
        assert result["is_positive"] is False
        assert result["is_negative"] is True

    def test_unknown_feedback(self):
        activity = {
            "name": "message/submitAction",
            "value": {"feedbackValue": "other"},
            "from": {"id": "user-1", "aadObjectId": "aad-1"},
        }
        result = process_feedback(activity)
        assert result["is_positive"] is False
        assert result["is_negative"] is False

    def test_fallback_user_id(self):
        activity = {
            "name": "message/submitAction",
            "value": {"feedbackValue": "positive"},
            "from": {"id": "user-1"},
        }
        result = process_feedback(activity)
        assert result["user_id"] == "user-1"

    def test_reply_to_id(self):
        activity = {
            "name": "message/submitAction",
            "value": {"feedbackValue": "positive"},
            "from": {"id": "user-1"},
            "replyToId": "msg-1",
        }
        result = process_feedback(activity)
        assert result["reply_to_id"] == "msg-1"


class TestSSOTokenStore:
    @pytest.fixture
    def store(self, tmp_path):
        return SSOTokenStore(storage_dir=str(tmp_path))

    def test_store_and_get(self, store):
        store.store("user-1", {"token": "abc123", "expires": "2024-01-01"})
        result = store.get("user-1")
        assert result is not None
        assert result["token"] == "abc123"

    def test_get_nonexistent(self, store):
        result = store.get("nonexistent")
        assert result is None

    def test_remove(self, store):
        store.store("user-1", {"token": "abc"})
        store.remove("user-1")
        assert store.get("user-1") is None

    def test_clear(self, store):
        store.store("user-1", {"token": "abc"})
        store.store("user-2", {"token": "def"})
        store.clear()
        assert store.get("user-1") is None
        assert store.get("user-2") is None

    def test_persistence(self, tmp_path):
        store1 = SSOTokenStore(storage_dir=str(tmp_path))
        store1.store("user-1", {"token": "abc"})

        store2 = SSOTokenStore(storage_dir=str(tmp_path))
        result = store2.get("user-1")
        assert result is not None


class TestConversationStore:
    @pytest.fixture
    def store(self, tmp_path):
        return ConversationStore(storage_dir=str(tmp_path))

    def test_store_and_get(self, store):
        store.store("chat-1", {"conversation": {"id": "conv-1"}})
        ref = store.get("chat-1")
        assert ref is not None
        assert ref["conversation"]["id"] == "conv-1"

    def test_get_nonexistent(self, store):
        assert store.get("nonexistent") is None

    def test_remove(self, store):
        store.store("chat-1", {"data": "test"})
        store.remove("chat-1")
        assert store.get("chat-1") is None

    def test_list_keys(self, store):
        store.store("chat-1", {"data": "a"})
        store.store("chat-2", {"data": "b"})
        keys = store.list_keys()
        assert "chat-1" in keys
        assert "chat-2" in keys

    def test_count(self, store):
        store.store("chat-1", {"data": "a"})
        assert store.count == 1

    def test_persistence(self, tmp_path):
        store1 = ConversationStore(storage_dir=str(tmp_path))
        store1.store("chat-1", {"data": "test"})

        store2 = ConversationStore(storage_dir=str(tmp_path))
        assert store2.get("chat-1") is not None


class TestMemoryConversationStore:
    @pytest.fixture
    def store(self):
        return MemoryConversationStore()

    def test_store_and_get(self, store):
        store.store("chat-1", {"data": "test"})
        assert store.get("chat-1") is not None
        assert store.get("chat-1")["data"] == "test"

    def test_get_nonexistent(self, store):
        assert store.get("nonexistent") is None

    def test_remove(self, store):
        store.store("chat-1", {"data": "test"})
        store.remove("chat-1")
        assert store.get("chat-1") is None

    def test_count(self, store):
        store.store("a", {"d": 1})
        store.store("b", {"d": 2})
        assert store.count == 2


class TestExtractConversationRef:
    def test_basic_extraction(self):
        activity = {
            "id": "activity-1",
            "from": {"id": "user-1", "name": "Test"},
            "recipient": {"id": "bot-1", "name": "Bot"},
            "conversation": {"id": "conv-1"},
            "channelId": "msteams",
            "serviceUrl": "https://example.com",
            "channelData": {"tenant": {"id": "tenant-1"}},
        }
        ref = extract_conversation_ref(activity)
        assert ref["activityId"] == "activity-1"
        assert ref["user"]["id"] == "user-1"
        assert ref["bot"]["id"] == "bot-1"
        assert ref["graphChatId"] == "conv-1"
        assert ref["tenantId"] == "tenant-1"
        assert ref["serviceUrl"] == "https://example.com"

    def test_missing_fields_default(self):
        activity = {"id": "a1", "from": {}, "conversation": {}}
        ref = extract_conversation_ref(activity)
        assert ref["activityId"] == "a1"
        assert ref["graphChatId"] == ""


class TestSentMessageCache:
    @pytest.fixture
    def cache(self):
        return SentMessageCache()

    def test_record_and_was_sent(self, cache):
        cache.record("msg-1", "chat-1")
        assert cache.was_sent("msg-1") is True

    def test_was_sent_nonexistent(self, cache):
        assert cache.was_sent("nonexistent") is False

    def test_get_chat_id(self, cache):
        cache.record("msg-1", "chat-1")
        assert cache.get_chat_id("msg-1") == "chat-1"

    def test_get_chat_id_nonexistent(self, cache):
        assert cache.get_chat_id("nonexistent") is None

    def test_count(self, cache):
        cache.record("msg-1", "chat-1")
        cache.record("msg-2", "chat-2")
        assert cache.count == 2

    def test_clear(self, cache):
        cache.record("msg-1", "chat-1")
        cache.clear()
        assert cache.count == 0

    def test_lru_eviction(self):
        cache = SentMessageCache(max_entries=3)
        for i in range(5):
            cache.record(f"msg-{i}", f"chat-{i}")
        assert cache.count <= 3