"""
  Search Tools for Product Discovery

  Provides text-based search via Search API, web search, and VLM style analysis

  """
  
  import base64
  import logging

  import os

  from pathlib import Path
  from typing import Optional
  

  import requests

  from langchain_core.tools import tool
  from openai import OpenAI
  
  from app.config import settings

  
  logger = logging.getLogger(__name__)
  

  _openai_client: Optional[OpenAI] = None
  
  

  def get_openai_client() -> OpenAI:
      global _openai_client
      if _openai_client is None:

          kwargs = {"api_key": settings.openai_api_key}
          if settings.openai_api_base_url:
              kwargs["base_url"] = settings.openai_api_base_url
          _openai_client = OpenAI(**kwargs)

      return _openai_client
  
  
  @tool

  def web_search(query: str) -> str:
      """使用 Tavily 进行通用 Web 搜索，补充外部/实时知识。
  
      触发场景（示例）：
      - 需要**外部知识**：流行趋势、新品信息、穿搭文化、品牌故事等
      - 需要**实时/及时信息**：某地某个时节的天气、当季流行元素、最新联名款
      - 需要**宏观参考**：不同城市/国家的穿衣习惯、节日穿搭建议
  
      Args:
          query: 要搜索的问题，自然语言描述（建议用中文）
  
      Returns:
          总结后的回答 + 若干来源链接，供模型继续推理使用。
      """
      try:
          api_key = os.getenv("TAVILY_API_KEY")
          if not api_key:
              logger.error("TAVILY_API_KEY is not set in environment variables")
              return (
                  "无法调用外部 Web 搜索：未检测到 TAVILY_API_KEY 环境变量。\n"
                  "请在运行环境中配置 TAVILY_API_KEY 后再重试。"
              )
  
          logger.info(f"Calling Tavily web search with query: {query!r}")
  
          url = "https://api.tavily.com/search"
          headers = {
              "Authorization": f"Bearer {api_key}",
              "Content-Type": "application/json",
          }
          payload = {
              "query": query,
              "search_depth": "advanced",
              "include_answer": True,
          }
  
          response = requests.post(url, json=payload, headers=headers, timeout=60)
  
          if response.status_code != 200:
              logger.error(
                  "Tavily API error: %s - %s",
                  response.status_code,
                  response.text,
              )
              return f"调用外部 Web 搜索失败：Tavily 返回状态码 {response.status_code}"
  
          data = response.json()
          answer = data.get("answer") or "（Tavily 未返回直接回答，仅返回了搜索结果。）"
          results = data.get("results") or []
  
          output_lines = [
              "【外部 Web 搜索结果（Tavily）】",
              "",
              "回答摘要：",
              answer.strip(),
          ]
  
          if results:
              output_lines.append("")
              output_lines.append("参考来源（部分）：")
              for idx, item in enumerate(results[:5], 1):
                  title = item.get("title") or "无标题"
                  url = item.get("url") or ""
                  output_lines.append(f"{idx}. {title}")
                  if url:
                      output_lines.append(f"   链接: {url}")
  
          return "\n".join(output_lines).strip()
  
      except requests.exceptions.RequestException as e:
          logger.error("Error calling Tavily web search (network): %s", e, exc_info=True)
          return f"调用外部 Web 搜索失败（网络错误）：{e}"
      except Exception as e:
          logger.error("Error calling Tavily web search: %s", e, exc_info=True)
          return f"调用外部 Web 搜索失败：{e}"
  
  
  @tool

  def search_products(query: str, limit: int = 5) -> str:
      """Search for fashion products using natural language descriptions.
  
      Use when users describe what they want:
      - "Find me red summer dresses"
      - "Show me blue running shoes"
      - "I want casual shirts for men"
  
      Args:
          query: Natural language product description
          limit: Maximum number of results (1-20)
  
      Returns:
          Formatted string with product information
      """
      try:
          logger.info(f"Searching products: '{query}', limit: {limit}")
  

          url = f"{settings.search_api_base_url.rstrip('/')}/search/"
          headers = {
              "Content-Type": "application/json",
              "X-Tenant-ID": settings.search_api_tenant_id,
          }
          payload = {
              "query": query,
              "size": min(limit, 20),
              "from": 0,
              "language": "zh",
          }
  
          response = requests.post(url, json=payload, headers=headers, timeout=60)
  
          if response.status_code != 200:
              logger.error(f"Search API error: {response.status_code} - {response.text}")
              return f"Error searching products: API returned {response.status_code}"
  
          data = response.json()
          results = data.get("results", [])

  
          if not results:
              return "No products found matching your search."
  
          output = f"Found {len(results)} product(s):\n\n"
  
          for idx, product in enumerate(results, 1):

              output += f"{idx}. {product.get('title', 'Unknown Product')}\n"
              output += f"   ID: {product.get('spu_id', 'N/A')}\n"
              output += f"   Category: {product.get('category_path', product.get('category_name', 'N/A'))}\n"
              if product.get("vendor"):
                  output += f"   Brand: {product.get('vendor')}\n"
              if product.get("price") is not None:
                  output += f"   Price: {product.get('price')}\n"
  
              # 规格/颜色信息
              specs = product.get("specifications", [])
              if specs:
                  color_spec = next(

                      (s for s in specs if s.get("name").lower() == "color"),

                      None,
                  )
                  if color_spec:
                      output += f"   Color: {color_spec.get('value', 'N/A')}\n"
  

              output += "\n"
  
          return output.strip()
  

      except requests.exceptions.RequestException as e:
          logger.error(f"Error searching products (network): {e}", exc_info=True)
          return f"Error searching products: {str(e)}"

      except Exception as e:
          logger.error(f"Error searching products: {e}", exc_info=True)
          return f"Error searching products: {str(e)}"
  
  
  @tool

  def analyze_image_style(image_path: str) -> str:
      """Analyze a fashion product image using AI vision to extract detailed style information.
  
      Use when you need to understand style/attributes from an image:
      - Understand the style, color, pattern of a product
      - Extract attributes like "casual", "formal", "vintage"
      - Get detailed descriptions for subsequent searches
  
      Args:
          image_path: Path to the image file
  
      Returns:
          Detailed text description of the product's visual attributes
      """
      try:
          logger.info(f"Analyzing image with VLM: '{image_path}'")
  
          img_path = Path(image_path)
          if not img_path.exists():
              return f"Error: Image file not found at '{image_path}'"
  
          with open(img_path, "rb") as image_file:
              image_data = base64.b64encode(image_file.read()).decode("utf-8")
  
          prompt = """Analyze this fashion product image and provide a detailed description.
  
  Include:
  - Product type (e.g., shirt, dress, shoes, pants, bag)
  - Primary colors
  - Style/design (e.g., casual, formal, sporty, vintage, modern)
  - Pattern or texture (e.g., plain, striped, checked, floral)
  - Key features (e.g., collar type, sleeve length, fit)
  - Material appearance (if obvious, e.g., denim, cotton, leather)
  - Suitable occasion (e.g., office wear, party, casual, sports)
  
  Provide a comprehensive yet concise description (3-4 sentences)."""
  
          client = get_openai_client()
          response = client.chat.completions.create(

              model=settings.openai_vision_model,

              messages=[
                  {
                      "role": "user",
                      "content": [
                          {"type": "text", "text": prompt},
                          {
                              "type": "image_url",
                              "image_url": {
                                  "url": f"data:image/jpeg;base64,{image_data}",
                                  "detail": "high",
                              },
                          },
                      ],
                  }
              ],
              max_tokens=500,
              temperature=0.3,
          )
  
          analysis = response.choices[0].message.content.strip()
          logger.info("VLM analysis completed")
  
          return analysis
  
      except Exception as e:
          logger.error(f"Error analyzing image: {e}", exc_info=True)
          return f"Error analyzing image: {str(e)}"
  
  
  def get_all_tools():
      """Get all available tools for the agent"""

      return [search_products, analyze_image_style, web_search]