"""
QueryParser单元测试
"""

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

from query import QueryParser, ParsedQuery
from context import RequestContext, create_request_context


@pytest.mark.unit
class TestQueryParser:
    """QueryParser测试用例"""

    def test_parser_initialization(self, sample_customer_config):
        """测试QueryParser初始化"""
        parser = QueryParser(sample_customer_config)

        assert parser.config == sample_customer_config
        assert parser.query_config is not None
        assert parser.normalizer is not None
        assert parser.rewriter is not None
        assert parser.language_detector is not None
        assert parser.translator is not None

    @patch('query.query_parser.QueryNormalizer')
    @patch('query.query_parser.LanguageDetector')
    def test_parse_without_context(self, mock_detector_class, mock_normalizer_class, test_query_parser):
        """测试不带context的解析"""
        # 设置mock
        mock_normalizer = Mock()
        mock_normalizer_class.return_value = mock_normalizer
        mock_normalizer.normalize.return_value = "红色 连衣裙"
        mock_normalizer.extract_domain_query.return_value = ("default", "红色 连衣裙")

        mock_detector = Mock()
        mock_detector_class.return_value = mock_detector
        mock_detector.detect.return_value = "zh"

        result = test_query_parser.parse("红色连衣裙")

        assert isinstance(result, ParsedQuery)
        assert result.original_query == "红色连衣裙"
        assert result.normalized_query == "红色 连衣裙"
        assert result.rewritten_query == "红色 连衣裙"  # 没有重写
        assert result.detected_language == "zh"

    def test_parse_with_context(self, test_query_parser):
        """测试带context的解析"""
        context = create_request_context("parse-001", "parse-user")

        # Mock各种组件
        with patch.object(test_query_parser, 'normalizer') as mock_normalizer, \
             patch.object(test_query_parser, 'language_detector') as mock_detector, \
             patch.object(test_query_parser, 'translator') as mock_translator, \
             patch.object(test_query_parser, 'text_encoder') as mock_encoder:

            # 设置mock返回值
            mock_normalizer.normalize.return_value = "红色 连衣裙"
            mock_normalizer.extract_domain_query.return_value = ("default", "红色 连衣裙")
            mock_detector.detect.return_value = "zh"
            mock_translator.translate_multi.return_value = {"en": "red dress"}
            mock_encoder.encode.return_value = [np.array([0.1, 0.2, 0.3])]

            result = test_query_parser.parse("红色连衣裙", generate_vector=True, context=context)

            # 验证结果
            assert isinstance(result, ParsedQuery)
            assert result.original_query == "红色连衣裙"
            assert result.detected_language == "zh"
            assert result.translations["en"] == "red dress"
            assert result.query_vector is not None

            # 验证context被更新
            assert context.query_analysis.original_query == "红色连衣裙"
            assert context.query_analysis.normalized_query == "红色 连衣裙"
            assert context.query_analysis.detected_language == "zh"
            assert context.query_analysis.translations["en"] == "red dress"
            assert context.query_analysis.domain == "default"

            # 验证计时
            assert context.get_stage_duration("query_parsing") > 0

    @patch('query.query_parser.QueryRewriter')
    def test_query_rewriting(self, mock_rewriter_class, test_query_parser):
        """测试查询重写"""
        # 设置mock
        mock_rewriter = Mock()
        mock_rewriter_class.return_value = mock_rewriter
        mock_rewriter.rewrite.return_value = "红色 女 连衣裙"

        context = create_request_context()

        # 启用查询重写
        test_query_parser.query_config.enable_query_rewrite = True

        result = test_query_parser.parse("红色连衣裙", context=context)

        assert result.rewritten_query == "红色 女 连衣裙"
        assert context.query_analysis.rewritten_query == "红色 女 连衣裙"

    def test_language_detection(self, test_query_parser):
        """测试语言检测"""
        context = create_request_context()

        with patch.object(test_query_parser, 'language_detector') as mock_detector, \
             patch.object(test_query_parser, 'normalizer') as mock_normalizer:

            mock_normalizer.normalize.return_value = "red dress"
            mock_normalizer.extract_domain_query.return_value = ("default", "red dress")
            mock_detector.detect.return_value = "en"

            result = test_query_parser.parse("red dress", context=context)

            assert result.detected_language == "en"
            assert context.query_analysis.detected_language == "en"

    @patch('query.query_parser.Translator')
    def test_query_translation(self, mock_translator_class, test_query_parser):
        """测试查询翻译"""
        # 设置mock
        mock_translator = Mock()
        mock_translator_class.return_value = mock_translator
        mock_translator.get_translation_needs.return_value = ["en"]
        mock_translator.translate_multi.return_value = {"en": "red dress"}

        context = create_request_context()

        # 启用翻译
        test_query_parser.query_config.enable_translation = True
        test_query_parser.query_config.supported_languages = ["zh", "en"]

        with patch.object(test_query_parser, 'normalizer') as mock_normalizer, \
             patch.object(test_query_parser, 'language_detector') as mock_detector:

            mock_normalizer.normalize.return_value = "红色 连衣裙"
            mock_normalizer.extract_domain_query.return_value = ("default", "红色 连衣裙")
            mock_detector.detect.return_value = "zh"

            result = test_query_parser.parse("红色连衣裙", context=context)

            assert result.translations["en"] == "red dress"
            assert context.query_analysis.translations["en"] == "red dress"

    @patch('query.query_parser.BgeEncoder')
    def test_text_embedding(self, mock_encoder_class, test_query_parser):
        """测试文本向量化"""
        # 设置mock
        mock_encoder = Mock()
        mock_encoder_class.return_value = mock_encoder
        mock_encoder.encode.return_value = [np.array([0.1, 0.2, 0.3])]

        context = create_request_context()

        # 启用向量化
        test_query_parser.query_config.enable_text_embedding = True

        with patch.object(test_query_parser, 'normalizer') as mock_normalizer, \
             patch.object(test_query_parser, 'language_detector') as mock_detector:

            mock_normalizer.normalize.return_value = "红色 连衣裙"
            mock_normalizer.extract_domain_query.return_value = ("default", "红色 连衣裙")
            mock_detector.detect.return_value = "zh"

            result = test_query_parser.parse("红色连衣裙", generate_vector=True, context=context)

            assert result.query_vector is not None
            assert isinstance(result.query_vector, np.ndarray)
            assert context.query_analysis.query_vector is not None

    def test_domain_extraction(self, test_query_parser):
        """测试域名提取"""
        context = create_request_context()

        with patch.object(test_query_parser, 'normalizer') as mock_normalizer, \
             patch.object(test_query_parser, 'language_detector') as mock_detector:

            # 测试带域名的查询
            mock_normalizer.normalize.return_value = "brand:nike 鞋子"
            mock_normalizer.extract_domain_query.return_value = ("brand", "nike 鞋子")
            mock_detector.detect.return_value = "zh"

            result = test_query_parser.parse("brand:nike 鞋子", context=context)

            assert result.domain == "brand"
            assert context.query_analysis.domain == "brand"

    def test_parse_with_disabled_features(self, test_query_parser):
        """测试禁用功能的解析"""
        context = create_request_context()

        # 禁用所有功能
        test_query_parser.query_config.enable_query_rewrite = False
        test_query_parser.query_config.enable_translation = False
        test_query_parser.query_config.enable_text_embedding = False

        with patch.object(test_query_parser, 'normalizer') as mock_normalizer, \
             patch.object(test_query_parser, 'language_detector') as mock_detector:

            mock_normalizer.normalize.return_value = "红色 连衣裙"
            mock_normalizer.extract_domain_query.return_value = ("default", "红色 连衣裙")
            mock_detector.detect.return_value = "zh"

            result = test_query_parser.parse("红色连衣裙", generate_vector=False, context=context)

            assert result.original_query == "红色连衣裙"
            assert result.rewritten_query == "红色 连衣裙"  # 没有重写
            assert result.detected_language == "zh"
            assert len(result.translations) == 0  # 没有翻译
            assert result.query_vector is None  # 没有向量

    def test_get_search_queries(self, test_query_parser):
        """测试获取搜索查询列表"""
        parsed_query = ParsedQuery(
            original_query="红色连衣裙",
            normalized_query="红色 连衣裙",
            rewritten_query="红色 连衣裙",
            detected_language="zh",
            translations={"en": "red dress", "fr": "robe rouge"}
        )

        queries = test_query_parser.get_search_queries(parsed_query)

        assert len(queries) == 3
        assert "红色 连衣裙" in queries
        assert "red dress" in queries
        assert "robe rouge" in queries

    def test_empty_query_handling(self, test_query_parser):
        """测试空查询处理"""
        result = test_query_parser.parse("")

        assert result.original_query == ""
        assert result.normalized_query == ""

    def test_whitespace_query_handling(self, test_query_parser):
        """测试空白字符查询处理"""
        result = test_query_parser.parse("   ")

        assert result.original_query == "   "

    def test_error_handling_in_parsing(self, test_query_parser):
        """测试解析过程中的错误处理"""
        context = create_request_context()

        # Mock normalizer抛出异常
        with patch.object(test_query_parser, 'normalizer') as mock_normalizer:
            mock_normalizer.normalize.side_effect = Exception("Normalization failed")

            with pytest.raises(Exception, match="Normalization failed"):
                test_query_parser.parse("红色连衣裙", context=context)

    def test_performance_timing(self, test_query_parser):
        """测试性能计时"""
        context = create_request_context()

        with patch.object(test_query_parser, 'normalizer') as mock_normalizer, \
             patch.object(test_query_parser, 'language_detector') as mock_detector:

            mock_normalizer.normalize.return_value = "test"
            mock_normalizer.extract_domain_query.return_value = ("default", "test")
            mock_detector.detect.return_value = "zh"

            result = test_query_parser.parse("test", context=context)

            # 验证计时被记录
            assert context.get_stage_duration("query_parsing") > 0
            assert context.get_intermediate_result('parsed_query') == result