"""
Searcher单元测试
"""

import pytest
from unittest.mock import Mock, patch, MagicMock
import numpy as np

from search import Searcher
from query import ParsedQuery
from context import RequestContext, create_request_context


@pytest.mark.unit
class TestSearcher:
    """Searcher测试用例"""

    def test_searcher_initialization(self, sample_customer_config, mock_es_client):
        """测试Searcher初始化"""
        searcher = Searcher(sample_customer_config, mock_es_client)

        assert searcher.config == sample_customer_config
        assert searcher.es_client == mock_es_client
        assert searcher.query_parser is not None
        assert searcher.boolean_parser is not None
        assert searcher.ranking_engine is not None

    def test_search_without_context(self, test_searcher):
        """测试不带context的搜索（向后兼容）"""
        result = test_searcher.search("红色连衣裙", size=5)

        assert result.hits is not None
        assert result.total >= 0
        assert result.context is not None  # 应该自动创建context
        assert result.took_ms >= 0

    def test_search_with_context(self, test_searcher):
        """测试带context的搜索"""
        context = create_request_context("test-req", "test-user")

        result = test_searcher.search("红色连衣裙", context=context)

        assert result.hits is not None
        assert result.context == context
        assert context.reqid == "test-req"
        assert context.uid == "test-user"

    def test_search_with_parameters(self, test_searcher):
        """测试带各种参数的搜索"""
        context = create_request_context()

        result = test_searcher.search(
            query="红色连衣裙",
            size=15,
            from_=5,
            filters={"category_id": 1},
            enable_translation=False,
            enable_embedding=False,
            enable_rerank=False,
            min_score=1.0,
            context=context
        )

        assert result is not None
        assert context.metadata['search_params']['size'] == 15
        assert context.metadata['search_params']['from'] == 5
        assert context.metadata['search_params']['filters'] == {"category_id": 1}
        assert context.metadata['search_params']['min_score'] == 1.0

        # 验证feature flags
        assert context.metadata['feature_flags']['enable_translation'] is False
        assert context.metadata['feature_flags']['enable_embedding'] is False
        assert context.metadata['feature_flags']['enable_rerank'] is False

    @patch('search.searcher.QueryParser')
    def test_search_query_parsing(self, mock_query_parser_class, test_searcher):
        """测试查询解析流程"""
        # 设置mock
        mock_parser = Mock()
        mock_query_parser_class.return_value = mock_parser

        parsed_query = ParsedQuery(
            original_query="红色连衣裙",
            normalized_query="红色 连衣裙",
            rewritten_query="红色 女 连衣裙",
            detected_language="zh",
            domain="default"
        )
        mock_parser.parse.return_value = parsed_query

        context = create_request_context()
        test_searcher.search("红色连衣裙", context=context)

        # 验证query parser被调用
        mock_parser.parse.assert_called_once_with("红色连衣裙", generate_vector=True, context=context)

    def test_search_error_handling(self, test_searcher):
        """测试搜索错误处理"""
        # 设置ES客户端抛出异常
        test_searcher.es_client.search.side_effect = Exception("ES连接失败")

        context = create_request_context()

        with pytest.raises(Exception, match="ES连接失败"):
            test_searcher.search("红色连衣裙", context=context)

        # 验证错误被记录到context
        assert context.has_error()
        assert "ES连接失败" in context.metadata['error_info']['message']

    def test_search_result_processing(self, test_searcher):
        """测试搜索结果处理"""
        context = create_request_context()

        result = test_searcher.search("红色连衣裙", enable_rerank=True, context=context)

        # 验证结果结构
        assert hasattr(result, 'hits')
        assert hasattr(result, 'total')
        assert hasattr(result, 'max_score')
        assert hasattr(result, 'took_ms')
        assert hasattr(result, 'aggregations')
        assert hasattr(result, 'query_info')
        assert hasattr(result, 'context')

        # 验证context中有中间结果
        assert context.get_intermediate_result('es_response') is not None
        assert context.get_intermediate_result('raw_hits') is not None
        assert context.get_intermediate_result('processed_hits') is not None

    def test_boolean_query_handling(self, test_searcher):
        """测试布尔查询处理"""
        context = create_request_context()

        # 测试复杂布尔查询
        result = test_searcher.search("laptop AND (gaming OR professional)", context=context)

        assert result is not None
        # 对于复杂查询，应该调用boolean parser
        assert not context.query_analysis.is_simple_query

    def test_simple_query_handling(self, test_searcher):
        """测试简单查询处理"""
        context = create_request_context()

        # 测试简单查询
        result = test_searcher.search("红色连衣裙", context=context)

        assert result is not None
        # 简单查询应该标记为simple
        assert context.query_analysis.is_simple_query

    @patch('search.searcher.RankingEngine')
    def test_reranking(self, mock_ranking_engine_class, test_searcher):
        """测试重排序功能"""
        # 设置mock
        mock_ranking = Mock()
        mock_ranking_engine_class.return_value = mock_ranking
        mock_ranking.calculate_score.return_value = 2.0

        context = create_request_context()
        result = test_searcher.search("红色连衣裙", enable_rerank=True, context=context)

        # 验证重排序被调用
        hits = result.hits
        if hits:  # 如果有结果
            # 应该有自定义分数
            assert all('_custom_score' in hit for hit in hits)
            assert all('_original_score' in hit for hit in hits)

    def test_spu_collapse(self, test_searcher):
        """测试SPU折叠功能"""
        # 配置SPU
        test_searcher.config.spu_config.enabled = True
        test_searcher.config.spu_config.spu_field = "spu_id"
        test_searcher.config.spu_config.inner_hits_size = 3

        context = create_request_context()
        result = test_searcher.search("红色连衣裙", context=context)

        assert result is not None
        # 验证SPU折叠配置被应用
        assert context.get_intermediate_result('es_query') is not None

    def test_embedding_search(self, test_searcher):
        """测试向量搜索功能"""
        # 配置embedding字段
        test_searcher.text_embedding_field = "text_embedding"

        context = create_request_context()
        result = test_searcher.search("红色连衣裙", enable_embedding=True, context=context)

        assert result is not None
        # embedding搜索应该被启用

    def test_search_by_image(self, test_searcher):
        """测试图片搜索功能"""
        # 配置图片embedding字段
        test_searcher.image_embedding_field = "image_embedding"

        # Mock图片编码器
        with patch('search.searcher.CLIPImageEncoder') as mock_encoder_class:
            mock_encoder = Mock()
            mock_encoder_class.return_value = mock_encoder
            mock_encoder.encode_image_from_url.return_value = np.array([0.1, 0.2, 0.3])

            result = test_searcher.search_by_image("http://example.com/image.jpg")

            assert result is not None
            assert result.query_info['search_type'] == 'image_similarity'
            assert result.query_info['image_url'] == "http://example.com/image.jpg"

    def test_performance_monitoring(self, test_searcher):
        """测试性能监控"""
        context = create_request_context()

        result = test_searcher.search("红色连衣裙", context=context)

        # 验证各阶段都被计时
        assert context.get_stage_duration(RequestContextStage.QUERY_PARSING) >= 0
        assert context.get_stage_duration(RequestContextStage.QUERY_BUILDING) >= 0
        assert context.get_stage_duration(RequestContextStage.ELASTICSEARCH_SEARCH) >= 0
        assert context.get_stage_duration(RequestContextStage.RESULT_PROCESSING) >= 0

        # 验证总耗时
        assert context.performance_metrics.total_duration > 0

    def test_context_storage(self, test_searcher):
        """测试context存储功能"""
        context = create_request_context()

        result = test_searcher.search("红色连衣裙", context=context)

        # 验证查询分析结果被存储
        assert context.query_analysis.original_query == "红色连衣裙"
        assert context.query_analysis.domain is not None

        # 验证中间结果被存储
        assert context.get_intermediate_result('parsed_query') is not None
        assert context.get_intermediate_result('es_query') is not None
        assert context.get_intermediate_result('es_response') is not None
        assert context.get_intermediate_result('processed_hits') is not None