"""
Agent Memory - 模型测试

测试数据模型的正确性
运行方式：
    pytest tests/test_models.py -v
"""

import pytest
from datetime import datetime
from typing import Dict, Any

from hy_memory.models import (
    # 枚举
    MemoryLayer,
    MemoryInputType,
    AgentProcessMode,
    TaskStatus,
    DeleteScope,
    # 数据类
    QAPair,
    AddRequest,
    AddResponse,
    AsyncAddResponse,
    RecallRequest,
    RecallResponse,
    UpdateRequest,
    DeleteRequest,
    BatchDeleteRequest,
    MemoryEntry,
    MemoryMetadata,
)


# ==================== 枚举测试 ====================

class TestEnums:
    """枚举测试"""
    
    def test_memory_layer_values(self):
        """测试记忆层枚举值 (V3 七层模型 + V1/V2 兼容别名)"""
        # V3 原始层
        assert MemoryLayer.L4_IDENTITY.value == "l4_identity"
        assert MemoryLayer.L2_FACT.value == "l2_fact"
        assert MemoryLayer.L3_SUMMARY.value == "l3_summary"
        assert MemoryLayer.L5_KNOWLEDGE.value == "l5_knowledge"
        assert MemoryLayer.L6_SCHEMA.value == "l6_schema"
        assert MemoryLayer.L1_RAW.value == "l1_raw"
        # V2 兼容别名（旧枚举名指向新值）
        assert MemoryLayer.L6_IDENTITY.value == "l4_identity"
        assert MemoryLayer.L4_KNOWLEDGE.value == "l5_knowledge"
        assert MemoryLayer.L5_SCHEMA.value == "l6_schema"
        # V1 兼容别名（值与 V3 对应层相同）
        assert MemoryLayer.PROFILE.value == "l4_identity"
        assert MemoryLayer.DIALOGUE.value == "l2_fact"
        assert MemoryLayer.SUMMARY.value == "l3_summary"
        assert MemoryLayer.KNOWLEDGE.value == "l5_knowledge"
        assert MemoryLayer.RAW.value == "l1_raw"
    
    def test_memory_layer_from_string(self):
        """测试从字符串创建记忆层"""
        assert MemoryLayer.from_string("profile") == MemoryLayer.L4_IDENTITY
        assert MemoryLayer.from_string("PROFILE") == MemoryLayer.L4_IDENTITY
        assert MemoryLayer.from_string("Profile") == MemoryLayer.L4_IDENTITY
        # V2 旧值兼容
        assert MemoryLayer.from_string("l6_identity") == MemoryLayer.L4_IDENTITY
        assert MemoryLayer.from_string("l5_schema") == MemoryLayer.L6_SCHEMA
        assert MemoryLayer.from_string("l4_knowledge") == MemoryLayer.L5_KNOWLEDGE
        assert MemoryLayer.from_string("l1_raw") == MemoryLayer.L1_RAW
    
    def test_memory_layer_invalid_string(self):
        """测试无效字符串创建记忆层"""
        with pytest.raises(ValueError):
            MemoryLayer.from_string("invalid_layer")
    
    def test_memory_input_type_values(self):
        """测试输入类型枚举值"""
        assert MemoryInputType.TEXT.value == "text"
        assert MemoryInputType.QA.value == "qa"
        assert MemoryInputType.DIALOGUE.value == "dialogue"
    
    def test_agent_process_mode_values(self):
        """测试 Agent 处理模式枚举值"""
        assert AgentProcessMode.DISABLED.value == "disabled"
        assert AgentProcessMode.FULL.value == "full"
    
    def test_task_status_values(self):
        """测试任务状态枚举值"""
        assert TaskStatus.PENDING.value == "pending"
        assert TaskStatus.PROCESSING.value == "processing"
        assert TaskStatus.COMPLETED.value == "completed"
        assert TaskStatus.FAILED.value == "failed"
    
    def test_delete_scope_values(self):
        """测试删除范围枚举值"""
        assert DeleteScope.MEMORY.value == "memory"
        assert DeleteScope.SCENE.value == "scene"
        assert DeleteScope.USER.value == "user"
        assert DeleteScope.APP.value == "app"


# ==================== QAPair 测试 ====================

class TestQAPair:
    """QAPair 测试"""
    
    def test_qa_pair_creation(self):
        """测试创建 QAPair"""
        qa = QAPair(
            question="你叫什么名字？",
            answer="我叫小明"
        )
        
        assert qa.question == "你叫什么名字？"
        assert qa.answer == "我叫小明"
    
    def test_qa_pair_to_dict(self):
        """测试 QAPair 转字典"""
        qa = QAPair(question="Q1", answer="A1")
        d = qa.to_dict()
        
        assert d == {"question": "Q1", "answer": "A1"}
    
    def test_qa_pair_from_dict(self):
        """测试从字典创建 QAPair"""
        d = {"question": "Q1", "answer": "A1"}
        qa = QAPair.from_dict(d)
        
        assert qa.question == "Q1"
        assert qa.answer == "A1"
    
    def test_qa_pair_to_content(self):
        """测试 QAPair 转内容字符串"""
        qa = QAPair(question="你好吗？", answer="我很好")
        content = qa.to_content()
        
        assert "Q:" in content
        assert "A:" in content
        assert "你好吗？" in content
        assert "我很好" in content


# ==================== AddRequest 测试 ====================

class TestAddRequest:
    """AddRequest 测试"""
    
    def test_add_request_text_basic(self):
        """测试基本文本请求"""
        request = AddRequest(
            uid="user1",
            agent_id="scene1",
            content="测试内容"
        )

        assert request.uid == "user1"
        assert request.agent_id == "scene1"
        assert request.content == "测试内容"
        assert request.input_type == MemoryInputType.TEXT
    
    def test_add_request_qa(self):
        """测试 QA 请求"""
        request = AddRequest(
            uid="user1",
            agent_id="scene1",
            input_type=MemoryInputType.QA,
            qa_pair=QAPair(question="Q", answer="A")
        )
        
        assert request.input_type == MemoryInputType.QA
        assert request.qa_pair is not None
    
    def test_add_request_get_content_text(self):
        """测试获取文本内容"""
        request = AddRequest(
            uid="user1",
            agent_id="scene1",
            content="文本内容"
        )
        
        assert request.get_content() == "文本内容"
    
    def test_add_request_get_content_qa(self):
        """测试获取 QA 内容"""
        request = AddRequest(
            uid="user1",
            agent_id="scene1",
            input_type=MemoryInputType.QA,
            qa_pair=QAPair(question="问题", answer="答案")
        )
        
        content = request.get_content()
        assert "问题" in content
        assert "答案" in content
    
    def test_add_request_validates_text_content(self):
        """测试验证文本内容"""
        with pytest.raises(ValueError):
            AddRequest(
                uid="user1",
                agent_id="scene1",
                input_type=MemoryInputType.TEXT,
                content=None  # 文本类型必须有 content
            )
    
    def test_add_request_validates_qa_pair(self):
        """测试验证 QA 对"""
        with pytest.raises(ValueError):
            AddRequest(
                uid="user1",
                agent_id="scene1",
                input_type=MemoryInputType.QA,
                qa_pair=None  # QA 类型必须有 qa_pair
            )
    
    def test_add_request_layer_normalization(self):
        """测试层名称规范化"""
        request = AddRequest(
            uid="user1",
            agent_id="scene1",
            content="内容",
            layer="profile"  # 字符串形式
        )
        
        assert request.layer == MemoryLayer.PROFILE
    
    def test_add_request_agent_mode_normalization(self):
        """测试 agent 模式规范化"""
        request = AddRequest(
            uid="user1",
            agent_id="scene1",
            content="内容",
            agent_mode="full"  # 字符串形式
        )

        assert request.agent_mode == AgentProcessMode.FULL
    
    def test_add_request_auto_extract_compatibility(self):
        """测试 auto_extract 兼容性"""
        request = AddRequest(
            uid="user1",
            agent_id="scene1",
            content="内容",
            auto_extract=True  # 旧参数
        )
        
        # auto_extract=True 应该等同于 agent_mode=full
        assert request.agent_mode == AgentProcessMode.FULL
    
    def test_add_request_to_dict(self):
        """测试转字典"""
        request = AddRequest(
            uid="user1",
            agent_id="scene1",
            content="内容",
            importance=0.8,
            tags=["tag1", "tag2"]
        )

        d = request.to_dict()

        assert d["uid"] == "user1"
        assert d["importance"] == 0.8
        assert d["tags"] == ["tag1", "tag2"]


# ==================== AddResponse 测试 ====================

class TestAddResponse:
    """AddResponse 测试"""
    
    def test_add_response_success(self):
        """测试成功响应"""
        response = AddResponse(
            success=True,
            memory_id="mem_123",
            layer=MemoryLayer.PROFILE,
            message="Added successfully"
        )
        
        assert response.success is True
        assert response.memory_id == "mem_123"
        assert response.layer == MemoryLayer.PROFILE
    
    def test_add_response_with_extracted_ids(self):
        """测试带提取 ID 的响应"""
        response = AddResponse(
            success=True,
            memory_id="mem_123",
            extracted_ids=["ext_1", "ext_2"],
            abstract_key_ids=["key_1", "key_2"]
        )
        
        assert len(response.extracted_ids) == 2
        assert len(response.abstract_key_ids) == 2
    
    def test_add_response_to_dict(self):
        """测试转字典"""
        response = AddResponse(
            success=True,
            memory_id="mem_123",
            layer=MemoryLayer.KNOWLEDGE
        )
        
        d = response.to_dict()
        
        assert d["success"] is True
        assert d["memory_id"] == "mem_123"
        assert d["layer"] == "l5_knowledge"


# ==================== AsyncAddResponse 测试 ====================

class TestAsyncAddResponse:
    """AsyncAddResponse 测试"""
    
    def test_async_response(self):
        """测试异步响应"""
        response = AsyncAddResponse(
            success=True,
            task_id="task_123",
            status=TaskStatus.PENDING,
            estimated_time=30
        )
        
        assert response.success is True
        assert response.task_id == "task_123"
        assert response.status == TaskStatus.PENDING
        assert response.estimated_time == 30
    
    def test_async_response_to_dict(self):
        """测试转字典"""
        response = AsyncAddResponse(
            success=True,
            task_id="task_123",
            status=TaskStatus.PROCESSING
        )
        
        d = response.to_dict()
        
        assert d["task_id"] == "task_123"
        assert d["status"] == "processing"


# ==================== RecallRequest 测试 ====================

class TestRecallRequest:
    """RecallRequest 测试"""
    
    def test_recall_request_basic(self):
        """测试基本召回请求"""
        request = RecallRequest(
            query="用户偏好",
            uid="user1"
        )
        
        assert request.query == "用户偏好"
        assert request.limit == 10  # 默认值
    
    def test_recall_request_with_filters(self):
        """测试带过滤条件的召回请求"""
        request = RecallRequest(
            query="电影",
            uid="user1",
            layers=[MemoryLayer.PROFILE, MemoryLayer.KNOWLEDGE],
            tags=["兴趣"],
            min_importance=0.5
        )
        
        assert len(request.layers) == 2
        assert "兴趣" in request.tags
        assert request.min_importance == 0.5
    
    def test_recall_request_weights(self):
        """测试权重参数"""
        request = RecallRequest(
            query="test",
            uid="user1",
            semantic_weight=0.6,
            recency_weight=0.2,
            importance_weight=0.15,
            access_weight=0.05
        )
        
        # 权重之和应该接近 1
        total = (request.semantic_weight + request.recency_weight + 
                 request.importance_weight + request.access_weight)
        assert abs(total - 1.0) < 0.01


# ==================== MemoryEntry 测试 ====================

class TestMemoryEntry:
    """MemoryEntry 测试 (V2: MemoryEntry 是 MemoryNode 的别名，字段扁平化)"""
    
    def test_memory_entry_creation(self):
        """测试创建 MemoryEntry"""
        entry = MemoryEntry(
            content="测试内容",
            user_id="user1",
            agent_id="scene1",
            layer=MemoryLayer.PROFILE,
        )
        
        assert entry.content == "测试内容"
        assert entry.layer == MemoryLayer.L4_IDENTITY  # PROFILE 是 L4_IDENTITY 的别名
    
    def test_memory_entry_build_isolation_key(self):
        """测试构建隔离键（两级: user_id + agent_id）"""
        key = MemoryEntry.build_isolation_key("user1", "scene1")

        assert "user1" in key
        assert "scene1" in key
    
    def test_memory_entry_to_dict(self):
        """测试转字典"""
        entry = MemoryEntry(
            content="内容",
            user_id="user1",
            agent_id="scene1",
            layer=MemoryLayer.DIALOGUE,
        )

        d = entry.to_dict()

        assert d["content"] == "内容"
        assert d["layer"] == "l2_fact"  # DIALOGUE -> l2_fact
        assert d["user_id"] == "user1"


# ==================== BatchDeleteRequest 测试 ====================

class TestBatchDeleteRequest:
    """BatchDeleteRequest 测试"""
    
    def test_batch_delete_by_ids(self):
        """测试按 ID 批量删除"""
        request = BatchDeleteRequest(
            scope=DeleteScope.MEMORY,
            memory_ids=["id1", "id2", "id3"]
        )
        
        assert request.scope == DeleteScope.MEMORY
        assert len(request.memory_ids) == 3
    
    def test_batch_delete_by_scene(self):
        """测试按场景批量删除"""
        request = BatchDeleteRequest(
            scope=DeleteScope.SCENE,
            uid="user1",
            agent_id="scene1"
        )
        
        assert request.scope == DeleteScope.SCENE
        assert request.uid == "user1"
        assert request.agent_id == "scene1"
    
    def test_batch_delete_dangerous_requires_confirm(self):
        """测试危险操作需要确认"""
        request = BatchDeleteRequest(
            scope=DeleteScope.USER,
            uid="user1",
            confirm=True
        )
        
        assert request.confirm is True


# ==================== 运行测试 ====================

if __name__ == "__main__":
    pytest.main([__file__, "-v"])