from types import SimpleNamespace
  

  import pytest
  

  from config import QueryConfig
  from query.style_intent import DetectedStyleIntent, StyleIntentProfile, StyleIntentRegistry
  from search.sku_intent_selector import StyleSkuSelector
  

  pytestmark = [pytest.mark.intent, pytest.mark.regression]
  

  
  def test_style_sku_selector_matches_first_sku_by_attribute_terms():
      registry = StyleIntentRegistry.from_query_config(
          QueryConfig(
              style_intent_terms={
                  "color": [{"en_terms": ["navy"], "zh_terms": ["藏青"], "attribute_terms": ["navy"]}],
                  "size": [{"en_terms": ["xl"], "zh_terms": ["加大码"], "attribute_terms": ["x-large"]}],
              },
              style_intent_dimension_aliases={
                  "color": ["color", "颜色"],
                  "size": ["size", "尺码"],
              },
          )
      )
      selector = StyleSkuSelector(registry)
      parsed_query = SimpleNamespace(
          style_intent_profile=StyleIntentProfile(
              intents=(
                  DetectedStyleIntent(
                      intent_type="color",
                      canonical_value="navy",
                      matched_term="藏青",
                      matched_query_text="藏青",
                      attribute_terms=("navy",),
                      dimension_aliases=("color", "颜色"),
                  ),
                  DetectedStyleIntent(
                      intent_type="size",
                      canonical_value="x-large",
                      matched_term="xl",
                      matched_query_text="xl",
                      attribute_terms=("x-large",),
                      dimension_aliases=("size", "尺码"),
                  ),
              ),
          )
      )
      source = {
          "option1_name": "Color",
          "option2_name": "Size",
          "skus": [
              {"sku_id": "1", "option1_value": "Black", "option2_value": "M"},
              {"sku_id": "2", "option1_value": "Navy Blue", "option2_value": "X-Large", "image_src": "matched.jpg"},
              {"sku_id": "3", "option1_value": "Navy", "option2_value": "XL"},
          ],
      }
      hits = [{"_id": "spu-1", "_source": source}]
  
      decisions = selector.prepare_hits(hits, parsed_query)
      decision = decisions["spu-1"]
  
      assert decision.selected_sku_id == "2"
      assert decision.selected_text == "Navy Blue X-Large"

      assert decision.final_source == "option"
      assert decision.matched_sources == {"color": "option", "size": "option"}
      assert decision.matched_stage == "option"  # back-compat alias

  
      selector.apply_precomputed_decisions(hits, decisions)
  
      assert source["skus"][0]["sku_id"] == "2"
      assert source["image_url"] == "matched.jpg"
  
  
  def test_style_sku_selector_returns_no_match_without_attribute_contains():
      registry = StyleIntentRegistry.from_query_config(
          QueryConfig(
              style_intent_terms={
                  "color": [{"en_terms": ["beige"], "zh_terms": ["米色"], "attribute_terms": ["beige"]}],
              },
              style_intent_dimension_aliases={"color": ["color", "颜色"]},
          )
      )
      selector = StyleSkuSelector(registry)
      parsed_query = SimpleNamespace(
          style_intent_profile=StyleIntentProfile(
              intents=(
                  DetectedStyleIntent(
                      intent_type="color",
                      canonical_value="beige",
                      matched_term="米色",
                      matched_query_text="米色",
                      attribute_terms=("beige",),
                      dimension_aliases=("color", "颜色"),
                  ),
              ),
          )
      )
      hits = [{
          "_id": "spu-1",
          "_source": {
              "option1_name": "Color",
              "skus": [
                  {"sku_id": "1", "option1_value": "Khaki"},
                  {"sku_id": "2", "option1_value": "Light Brown"},
              ],
          },
      }]
  
      decisions = selector.prepare_hits(hits, parsed_query)
  
      assert decisions["spu-1"].selected_sku_id is None

      assert decisions["spu-1"].final_source == "none"

  
  
  def test_is_text_match_uses_token_boundaries_for_sizes():
      registry = StyleIntentRegistry.from_query_config(
          QueryConfig(
              style_intent_terms={
                  "size": [{"en_terms": ["l"], "zh_terms": ["大码"], "attribute_terms": ["l"]}],
              },
              style_intent_dimension_aliases={"size": ["size", "尺码"]},
          )
      )
      selector = StyleSkuSelector(registry)
      style_profile = StyleIntentProfile(
          intents=(
              DetectedStyleIntent(
                  intent_type="size",
                  canonical_value="l",
                  matched_term="l",
                  matched_query_text="l",
                  attribute_terms=("l",),
                  dimension_aliases=("size", "尺码"),
              ),
          ),
      )
      selection_context = selector._build_selection_context(style_profile)
  
      assert selector._is_text_match("size", selection_context, normalized_value="l")
      assert not selector._is_text_match("size", selection_context, normalized_value="xl")
      assert not selector._is_text_match("size", selection_context, normalized_value="xxl")
  
  
  def test_is_text_match_handles_punctuation_and_descriptive_attribute_values():
      registry = StyleIntentRegistry.from_query_config(
          QueryConfig(
              style_intent_terms={
                  "color": [{"en_terms": ["blue"], "zh_terms": ["蓝色"], "attribute_terms": ["blue"]}],
                  "style": [{"en_terms": ["off-white"], "zh_terms": ["米白"], "attribute_terms": ["off-white"]}],
                  "accessory": [{"en_terms": ["headscarf"], "zh_terms": ["头巾"], "attribute_terms": ["headscarf"]}],
                  "size": [{"en_terms": ["2xl"], "zh_terms": ["2xl"], "attribute_terms": ["2xl"]}],
              },
              style_intent_dimension_aliases={
                  "color": ["color", "颜色"],
                  "style": ["style", "风格"],
                  "accessory": ["accessory", "配饰"],
                  "size": ["size", "尺码"],
              },
          )
      )
      selector = StyleSkuSelector(registry)
      style_profile = StyleIntentProfile(
          intents=(
              DetectedStyleIntent(
                  intent_type="color",
                  canonical_value="blue",
                  matched_term="blue",
                  matched_query_text="blue",
                  attribute_terms=("blue",),
                  dimension_aliases=("color", "颜色"),
              ),
              DetectedStyleIntent(
                  intent_type="style",
                  canonical_value="off-white",
                  matched_term="off-white",
                  matched_query_text="off-white",
                  attribute_terms=("off-white",),
                  dimension_aliases=("style", "风格"),
              ),
              DetectedStyleIntent(
                  intent_type="accessory",
                  canonical_value="headscarf",
                  matched_term="headscarf",
                  matched_query_text="headscarf",
                  attribute_terms=("headscarf",),
                  dimension_aliases=("accessory", "配饰"),
              ),
              DetectedStyleIntent(
                  intent_type="size",
                  canonical_value="2xl",
                  matched_term="2xl",
                  matched_query_text="2xl",
                  attribute_terms=("2xl",),
                  dimension_aliases=("size", "尺码"),
              ),
          ),
      )
      selection_context = selector._build_selection_context(style_profile)
  
      assert selector._is_text_match("color", selection_context, normalized_value="gray blue")
      assert selector._is_text_match("style", selection_context, normalized_value="off-white/lined")
      assert selector._is_text_match("accessory", selection_context, normalized_value="army green + headscarf")
      assert selector._is_text_match("size", selection_context, normalized_value="2xl recommended 65-70kg")

  
  
  def _khaki_intent() -> DetectedStyleIntent:
      """Mirrors what StyleIntentDetector now emits (all_terms union of zh/en/attribute)."""
      return DetectedStyleIntent(
          intent_type="color",
          canonical_value="beige",
          matched_term="卡其色",
          matched_query_text="卡其色",
          attribute_terms=("beige", "khaki"),
          dimension_aliases=("color", "颜色"),
          all_terms=("米色", "卡其色", "beige", "khaki"),
      )
  
  
  def _color_registry() -> StyleIntentRegistry:
      return StyleIntentRegistry.from_query_config(
          QueryConfig(
              style_intent_terms={
                  "color": [
                      {
                          "en_terms": ["beige", "khaki"],
                          "zh_terms": ["米色", "卡其色"],
                          "attribute_terms": ["beige", "khaki"],
                      }
                  ],
              },
              style_intent_dimension_aliases={"color": ["color", "颜色"]},
          )
      )
  
  
  def test_zh_color_intent_matches_noisy_option_value():
      """卡其色裙子 → SKU 的 option1_value 以"卡其色"开头但带 V 领等后缀，也应命中。"""
      selector = StyleSkuSelector(_color_registry())
      parsed_query = SimpleNamespace(
          style_intent_profile=StyleIntentProfile(intents=(_khaki_intent(),))
      )
      hits = [
          {
              "_id": "spu-1",
              "_source": {
                  "option1_name": "颜色",
                  "skus": [
                      {"sku_id": "1", "option1_value": "黑色长裙"},
                      {"sku_id": "2", "option1_value": "卡其色v领收腰长裙【常规款】"},
                  ],
              },
          }
      ]
      decisions = selector.prepare_hits(hits, parsed_query)
      assert decisions["spu-1"].selected_sku_id == "2"
      assert decisions["spu-1"].final_source == "option"
  
  
  @pytest.mark.parametrize(
      "option_value",
      [
          "卡其色（无内衬）",
          "卡其色(无内衬)",
          "卡其色【常规款】",
          "卡其色/常规款",
          "卡其色·无内衬",
          "卡其色 - 常规",
          "卡其色,常规",
          "卡其色｜常规",
          "卡其色—加厚",
      ],
  )
  def test_zh_color_intent_matches_various_brackets_and_separators(option_value: str):
      selector = StyleSkuSelector(_color_registry())
      parsed_query = SimpleNamespace(
          style_intent_profile=StyleIntentProfile(intents=(_khaki_intent(),))
      )
      hits = [
          {
              "_id": "spu-1",
              "_source": {
                  "option1_name": "颜色",
                  "skus": [
                      {"sku_id": "441670", "option1_value": "白色（无内衬）"},
                      {"sku_id": "441679", "option1_value": option_value},
                  ],
              },
          }
      ]
      assert selector.prepare_hits(hits, parsed_query)["spu-1"].selected_sku_id == "441679"
  
  
  def test_zh_color_intent_matches_noisy_option_value_with_fullwidth_parens():
      """卡其色（无内衬） 是前面 taxonomy-override bug 的实地复现；option 分支现在必须命中。"""
      selector = StyleSkuSelector(_color_registry())
      parsed_query = SimpleNamespace(
          style_intent_profile=StyleIntentProfile(intents=(_khaki_intent(),))
      )
      hits = [
          {
              "_id": "spu-1",
              "_source": {
                  "option1_name": "颜色",
                  # Even if SPU-level taxonomy existed, white SKU must NOT leak in.
                  "enriched_taxonomy_attributes": [
                      {"name": "Color", "value": {"zh": "卡其色"}}
                  ],
                  "skus": [
                      {"sku_id": "441670", "option1_value": "白色（无内衬）"},
                      {"sku_id": "441679", "option1_value": "卡其色（无内衬）"},
                  ],
              },
          }
      ]
      decisions = selector.prepare_hits(hits, parsed_query)
      d = decisions["spu-1"]
      assert d.selected_sku_id == "441679"
      assert d.selected_text == "卡其色（无内衬）"
      assert d.final_source == "option"
      assert d.matched_sources == {"color": "option"}
  
  
  def test_taxonomy_attribute_extends_text_matching_source():
      """即使 optionN 无法区分 SKU，enriched_taxonomy_attributes 的 Color 也可让 SPU 全部 SKU 通过文本
      匹配，之后由图像 pick（若有）决定具体 SKU；无图像则取首个。"""
      selector = StyleSkuSelector(_color_registry())
      parsed_query = SimpleNamespace(
          style_intent_profile=StyleIntentProfile(intents=(_khaki_intent(),))
      )
      hits = [
          {
              "_id": "spu-1",
              "_source": {
                  "option1_name": "Style",  # unrelated dimension → slot unresolved
                  "enriched_taxonomy_attributes": [
                      {"name": "Color", "value": {"zh": "卡其色", "en": "khaki"}}
                  ],
                  "skus": [
                      {"sku_id": "a", "option1_value": "A"},
                      {"sku_id": "b", "option1_value": "B"},
                  ],
              },
          }
      ]
      decisions = selector.prepare_hits(hits, parsed_query)
      # Taxonomy matches → both SKUs text-matched; no image pick → first one wins.
      d = decisions["spu-1"]
      assert d.selected_sku_id == "a"
      assert d.final_source == "taxonomy"
      # selected_text reflects the real matched taxonomy value, not SKU's unrelated option.
      assert d.selected_text == "卡其色"
      assert d.matched_sources == {"color": "taxonomy"}
  
  
  def test_taxonomy_does_not_override_contradicting_sku_option_value():
      """SPU 级 taxonomy 说"卡其色"，但 SKU 自己的 option1_value 是"白色（无内衬）"，
      该 SKU 不应被视作文本命中——避免 SPU 级信号把错色 SKU 顶上去。"""
      selector = StyleSkuSelector(_color_registry())
      parsed_query = SimpleNamespace(
          style_intent_profile=StyleIntentProfile(intents=(_khaki_intent(),))
      )
      hits = [
          {
              "_id": "spu-1",
              "_source": {
                  "option1_name": "颜色",
                  "enriched_taxonomy_attributes": [
                      {"name": "Color", "value": {"zh": "卡其色", "en": "khaki"}}
                  ],
                  "skus": [
                      {"sku_id": "white", "option1_value": "白色（无内衬）"},
                      {"sku_id": "khaki", "option1_value": "卡其色棉"},
                  ],
              },
          }
      ]
      decisions = selector.prepare_hits(hits, parsed_query)
      # 只有 khaki 自有值匹配；taxonomy 不会把 white 顶出来。
      assert decisions["spu-1"].selected_sku_id == "khaki"
      assert decisions["spu-1"].final_source == "option"
  
  
  def test_taxonomy_fills_in_only_when_sku_self_value_is_empty():
      """混合场景：SKU 1 无 option1_value → taxonomy 接管；SKU 2 自带白色 → 不匹配。"""
      selector = StyleSkuSelector(_color_registry())
      parsed_query = SimpleNamespace(
          style_intent_profile=StyleIntentProfile(intents=(_khaki_intent(),))
      )
      hits = [
          {
              "_id": "spu-1",
              "_source": {
                  "option1_name": "颜色",
                  "enriched_taxonomy_attributes": [
                      {"name": "Color", "value": {"zh": "卡其色"}}
                  ],
                  "skus": [
                      {"sku_id": "no-value", "option1_value": ""},
                      {"sku_id": "white", "option1_value": "白色"},
                  ],
              },
          }
      ]
      decisions = selector.prepare_hits(hits, parsed_query)
      d = decisions["spu-1"]
      assert d.selected_sku_id == "no-value"
      assert d.final_source == "taxonomy"
      assert d.selected_text == "卡其色"
  
  
  def test_image_pick_serves_as_visual_tiebreak_within_text_matched():
      selector = StyleSkuSelector(_color_registry())
      parsed_query = SimpleNamespace(
          style_intent_profile=StyleIntentProfile(intents=(_khaki_intent(),))
      )
      hits = [
          {
              "_id": "spu-1",
              "_source": {
                  "option1_name": "颜色",
                  "skus": [
                      {
                          "sku_id": "khaki-cotton",
                          "option1_value": "卡其色棉",
                          "image_src": "https://cdn/x/khaki-cotton.jpg",
                      },
                      {
                          "sku_id": "khaki-linen",
                          "option1_value": "卡其色麻",
                          "image_src": "https://cdn/x/khaki-linen.jpg",
                      },
                  ],
              },
              "inner_hits": {
                  "exact_image_knn_query_hits": {
                      "hits": {
                          "hits": [
                              {
                                  "_score": 0.87,
                                  "_source": {"url": "https://cdn/x/khaki-linen.jpg"},
                              }
                          ]
                      }
                  }
              },
          }
      ]
      decisions = selector.prepare_hits(hits, parsed_query)
      decision = decisions["spu-1"]
      assert decision.selected_sku_id == "khaki-linen"
      assert decision.final_source == "option"
      assert decision.image_pick_sku_id == "khaki-linen"
      assert decision.image_pick_score == 0.87
  
  
  def test_image_only_selection_when_no_style_intent():
      """无款式意图：仅凭 image_embedding 最近邻 SKU，直接把该 SKU 置顶。"""
      selector = StyleSkuSelector(_color_registry())
      parsed_query = SimpleNamespace(style_intent_profile=None)
      hits = [
          {
              "_id": "spu-1",
              "_source": {
                  "option1_name": "Color",
                  "image_url": "https://cdn/x/default.jpg",
                  "skus": [
                      {
                          "sku_id": "red",
                          "option1_value": "Red",
                          "image_src": "https://cdn/x/red.jpg",
                      },
                      {
                          "sku_id": "blue",
                          "option1_value": "Blue",
                          "image_src": "https://cdn/x/blue.jpg",
                      },
                  ],
              },
              "inner_hits": {
                  "image_knn_query_hits": {
                      "hits": {
                          "hits": [
                              {"_score": 0.74, "_source": {"url": "https://cdn/x/blue.jpg"}}
                          ]
                      }
                  }
              },
          }
      ]
      decisions = selector.prepare_hits(hits, parsed_query)
      decision = decisions["spu-1"]
      assert decision.selected_sku_id == "blue"
      assert decision.final_source == "image"
  
      selector.apply_precomputed_decisions(hits, decisions)
      source = hits[0]["_source"]
      assert source["skus"][0]["sku_id"] == "blue"
      assert source["image_url"] == "https://cdn/x/blue.jpg"
  
  
  def test_image_pick_ignored_when_text_matches_but_visual_url_not_in_text_set():
      """文本命中优先：image-pick 若落在非文本命中 SKU，则不接管。"""
      selector = StyleSkuSelector(_color_registry())
      parsed_query = SimpleNamespace(
          style_intent_profile=StyleIntentProfile(intents=(_khaki_intent(),))
      )
      hits = [
          {
              "_id": "spu-1",
              "_source": {
                  "option1_name": "颜色",
                  "skus": [
                      {
                          "sku_id": "khaki",
                          "option1_value": "卡其色",
                          "image_src": "https://cdn/x/khaki.jpg",
                      },
                      {
                          "sku_id": "black",
                          "option1_value": "黑色",
                          "image_src": "https://cdn/x/black.jpg",
                      },
                  ],
              },
              "inner_hits": {
                  "exact_image_knn_query_hits": {
                      "hits": {
                          "hits": [
                              {"_score": 0.9, "_source": {"url": "https://cdn/x/black.jpg"}}
                          ]
                      }
                  }
              },
          }
      ]
      decisions = selector.prepare_hits(hits, parsed_query)
      decision = decisions["spu-1"]
      # Hard text-first: khaki stays, though image pointed at black.
      assert decision.selected_sku_id == "khaki"
      assert decision.final_source == "option"
      assert decision.image_pick_sku_id == "black"

  
  
  def test_image_pick_matches_when_inner_hit_url_has_query_string():
      """inner_hits 带 ?v=1，SKU 无 query —— 应用归一化后应对齐。"""
      selector = StyleSkuSelector(_color_registry())
      parsed_query = SimpleNamespace(style_intent_profile=None)
      hits = [
          {
              "_id": "spu-1",
              "_source": {
                  "skus": [
                      {
                          "sku_id": "s1",
                          "image_src": "https://cdn/img/p.jpg",
                      },
                  ],
              },
              "inner_hits": {
                  "exact_image_knn_query_hits": {
                      "hits": {
                          "hits": [
                              {
                                  "_score": 0.8,
                                  "_source": {"url": "https://cdn/img/p.jpg?width=800&quality=85"},
                              }
                          ]
                      }
                  }
              },
          }
      ]
      d = selector.prepare_hits(hits, parsed_query)["spu-1"]
      assert d.selected_sku_id == "s1"
      assert d.final_source == "image"
  
  
  def test_image_pick_uses_nested_offset_and_image_embedding_when_needed():
      """_source.url 与 sku 写法不一致时，用 offset 从 image_embedding 取 canonical url。"""
      selector = StyleSkuSelector(_color_registry())
      parsed_query = SimpleNamespace(style_intent_profile=None)
      hits = [
          {
              "_id": "spu-1",
              "_source": {
                  "image_embedding": [
                      {"url": "https://cdn/a/spu.jpg"},
                      {"url": "https://cdn/b/sku-match.jpg"},
                  ],
                  "skus": [
                      {"sku_id": "sku-a", "image_src": "//cdn/b/sku-match.jpg"},
                  ],
              },
              "inner_hits": {
                  "exact_image_knn_query_hits": {
                      "hits": {
                          "hits": [
                              {
                                  "_score": 0.91,
                                  "_nested": {"field": "image_embedding", "offset": 1},
                                  "_source": {"url": "https://wrong.example/x.jpg"},
                              }
                          ]
                      }
                  }
              },
          }
      ]
      d = selector.prepare_hits(hits, parsed_query)["spu-1"]
      assert d.selected_sku_id == "sku-a"
      assert d.image_pick_url == "https://cdn/b/sku-match.jpg"