"""

  ShopAgent - Streamlit UI

  Multi-modal fashion shopping assistant with conversational AI
  """
  
  import logging
  import re
  import uuid
  from pathlib import Path
  from typing import Optional
  
  import streamlit as st
  from PIL import Image, ImageOps
  
  from app.agents.shopping_agent import ShoppingAgent

  from app.search_registry import ProductItem, SearchResult, global_registry
  
  # Matches [SEARCH_REF:sr_xxxxxxxx] tokens embedded in AI responses.
  # Case-insensitive, optional spaces around the id.
  SEARCH_REF_PATTERN = re.compile(r"\[SEARCH_REF:\s*([a-zA-Z0-9_]+)\s*\]", re.IGNORECASE)

  
  # Configure logging
  logging.basicConfig(
      level=logging.INFO,
      format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
  )
  logger = logging.getLogger(__name__)
  
  # Page config
  st.set_page_config(

      page_title="ShopAgent",

      page_icon="👗",
      layout="centered",
      initial_sidebar_state="collapsed",
  )
  
  # Custom CSS - ChatGPT-like style
  st.markdown(
      """
      <style>

      /* Show default Streamlit elements (sidebar toggle, etc.) */
      /* #MainMenu, footer, header no longer hidden */

      
      /* Body and root container */
      .main .block-container {
          padding-bottom: 180px !important;
          padding-top: 2rem;
          max-width: 900px;
          margin: 0 auto;
      }
      
      /* Fixed input container at bottom */
      .fixed-input-container {
          position: fixed;
          bottom: 0;
          left: 0;
          right: 0;
          background: white;
          border-top: 1px solid #e5e5e5;
          padding: 1rem 0;
          z-index: 1000;
          box-shadow: 0 -2px 10px rgba(0,0,0,0.05);
      }
      
      .fixed-input-container .block-container {
          max-width: 900px;
          margin: 0 auto;
          padding: 0 1rem !important;
      }
      
      /* Message bubbles */
      .message {
          margin: 1rem 0;
          padding: 1rem 1.5rem;
          border-radius: 1rem;
          animation: fadeIn 0.3s ease-in;
      }
      
      @keyframes fadeIn {
          from { opacity: 0; transform: translateY(10px); }
          to { opacity: 1; transform: translateY(0); }
      }
      
      .user-message {
          background: transparent;
          margin: 0 0 1rem 0;
          padding: 0;
          border-radius: 0;
      }
      
      .assistant-message {
          background: white;
          border: 1px solid #e5e5e5;
          margin-right: 3rem;
      }
      
      /* Product cards - simplified */
      .stImage {
          border-radius: 0px;
          overflow: hidden;
      }
      
      .stImage img {
          transition: transform 0.2s;
      }
      
      .stImage:hover img {
          transform: scale(1.05);
      }
      
      /* Scroll to bottom behavior */
      html {
          scroll-behavior: smooth;
      }
      
      /* Header */
      .app-header {
          text-align: center;
          padding: 2rem 1rem;
          background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
          color: white;
          border-radius: 1rem;
          margin-bottom: 2rem;
      }
      
      .app-title {
          font-size: 2rem;
          font-weight: 700;
          margin: 0;
      }
      
      .app-subtitle {
          font-size: 1rem;
          opacity: 0.9;
          margin-top: 0.5rem;
      }
      
      /* Welcome screen */
      .welcome-container {
          text-align: center;
          padding: 4rem 2rem;
          color: #666;
      }
      
      .welcome-title {
          font-size: 2rem;
          font-weight: 600;
          color: #1a1a1a;
          margin-bottom: 1rem;
      }
      
      .welcome-features {
          display: grid;
          grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
          gap: 1.5rem;
          margin: 2rem 0;
      }
      
      .feature-card {
          background: #f7f7f8;
          padding: 1.5rem;
          border-radius: 12px;
          transition: all 0.2s;
      }
      
      .feature-card:hover {
          background: #efefef;
          transform: translateY(-2px);
      }
      
      .feature-icon {
          font-size: 2rem;
          margin-bottom: 0.5rem;
      }
      
      .feature-title {
          font-weight: 600;
          margin-bottom: 0.25rem;
      }
      
      /* Image preview */
      .image-preview {
          position: relative;
          display: inline-block;
          margin: 0.5rem 0;
      }
      
      .image-preview img {
          max-width: 200px;
          border-radius: 8px;
          border: 2px solid #e5e5e5;
      }
      
      .remove-image-btn {
          position: absolute;
          top: 5px;
          right: 5px;
          background: rgba(0,0,0,0.6);
          color: white;
          border: none;
          border-radius: 50%;
          width: 24px;
          height: 24px;
          cursor: pointer;
          font-size: 14px;
      }
      
      /* Buttons */
      .stButton>button {
          border-radius: 8px;
          border: 1px solid #e5e5e5;
          padding: 0.5rem 1rem;
          transition: all 0.2s;
      }
      
      .stButton>button:hover {
          background: #f0f0f0;
          border-color: #d0d0d0;
      }
      
      /* Hide upload button label */
      .uploadedFile {
          display: none;
      }
      </style>
      """,
      unsafe_allow_html=True,
  )
  
  
  # Initialize session state
  def initialize_session():
      """Initialize session state variables"""
      if "session_id" not in st.session_state:
          st.session_state.session_id = str(uuid.uuid4())
  
      if "shopping_agent" not in st.session_state:
          st.session_state.shopping_agent = ShoppingAgent(
              session_id=st.session_state.session_id
          )
  
      if "messages" not in st.session_state:
          st.session_state.messages = []
  
      if "uploaded_image" not in st.session_state:
          st.session_state.uploaded_image = None
  
      if "show_image_upload" not in st.session_state:
          st.session_state.show_image_upload = False
  

      # Debug panel toggle (default True so 显示调试过程 is checked by default)

      if "show_debug" not in st.session_state:

          st.session_state.show_debug = True

  
  def save_uploaded_image(uploaded_file) -> Optional[str]:
      """Save uploaded image to temp directory"""
      if uploaded_file is None:
          return None
  
      try:
          temp_dir = Path("temp_uploads")
          temp_dir.mkdir(exist_ok=True)
  
          image_path = temp_dir / f"{st.session_state.session_id}_{uploaded_file.name}"
          with open(image_path, "wb") as f:
              f.write(uploaded_file.getbuffer())
  
          logger.info(f"Saved uploaded image to {image_path}")
          return str(image_path)
  
      except Exception as e:
          logger.error(f"Error saving uploaded image: {e}")
          st.error(f"Failed to save image: {str(e)}")
          return None
  
  

  def _load_product_image(product: ProductItem) -> Optional[Image.Image]:

      """Try to load a product image: image_url from API (normalized when stored) → local data/images → None."""

      if product.image_url:
          try:
              import requests
              resp = requests.get(product.image_url, timeout=10)
              if resp.status_code == 200:
                  import io
                  return Image.open(io.BytesIO(resp.content))
          except Exception as e:
              logger.debug(f"Remote image fetch failed for {product.spu_id}: {e}")
  
      local = Path(f"data/images/{product.spu_id}.jpg")
      if local.exists():
          try:
              return Image.open(local)
          except Exception as e:
              logger.debug(f"Local image load failed {local}: {e}")
      return None
  
  
  def display_product_card_from_item(product: ProductItem) -> None:
      """Render a single product card from a ProductItem (registry entry)."""
      img = _load_product_image(product)
  
      if img:
          target = (220, 220)
          try:
              img = ImageOps.fit(img, target, method=Image.Resampling.LANCZOS)
          except AttributeError:
              img = ImageOps.fit(img, target, method=Image.LANCZOS)

          st.image(img, width="stretch")

      else:
          st.markdown(
              '<div style="height:120px;background:#f5f5f5;border-radius:6px;'
              'display:flex;align-items:center;justify-content:center;'
              'color:#bbb;font-size:2rem;">🛍️</div>',
              unsafe_allow_html=True,
          )
  
      title = product.title or "未知商品"
      st.markdown(f"**{title[:40]}**" + ("…" if len(title) > 40 else ""))
  
      if product.price is not None:
          st.caption(f"¥{product.price:.2f}")
  

      label_style = "⭐" if product.match_label == "Relevant" else "✦"

      st.caption(f"{label_style} {product.match_label}")

  
  def render_search_result_block(result: SearchResult) -> None:

      """

      Render a full search result block in place of a [SEARCH_REF:xxx] token.
  
      Shows:

      - A styled header with query + match counts + quality_summary (if any)

      - A grid of product cards (Relevant first, then Partially Relevant; max 6)

      """

      summary_line = f'  · {result.quality_summary}' if result.quality_summary else ''

      header_html = (
          f'<div style="border:1px solid #e0e0e0;border-radius:8px;padding:10px 14px;'
          f'margin:8px 0 4px 0;background:#fafafa;">'
          f'<span style="font-size:0.8rem;color:#555;">'
          f'🔍 <b>{result.query}</b>'

          f' · Relevant {result.perfect_count} 件'

          f' · Partially Relevant {result.partial_count} 件'
          f'{summary_line}'

          f'</span></div>'
      )
      st.markdown(header_html, unsafe_allow_html=True)
  
      # Perfect matches first, fall back to partials if none

      perfect = [p for p in result.products if p.match_label == "Relevant"]

      partial = [p for p in result.products if p.match_label == "Partially Relevant"]

      to_show = (perfect + partial)[:6] if perfect else partial[:6]
  
      if not to_show:
          st.caption("（本次搜索未找到可展示的商品）")
          return
  
      cols = st.columns(min(len(to_show), 3))
      for i, product in enumerate(to_show):
          with cols[i % 3]:
              display_product_card_from_item(product)
  
  

  def render_message_with_refs(
      content: str,
      session_id: str,
      fallback_refs: Optional[dict] = None,
  ) -> None:

      """
      Render an assistant message that may contain [SEARCH_REF:xxx] tokens.
  
      Text segments are rendered as markdown.
      [SEARCH_REF:xxx] tokens are replaced with full product card blocks

      loaded from the global registry, or from fallback_refs (e.g. refs stored
      with the message so they survive reruns / different workers).

      """

      fallback_refs = fallback_refs or {}

      # re.split with a capture group alternates: [text, ref_id, text, ref_id, ...]
      parts = SEARCH_REF_PATTERN.split(content)
  
      for i, segment in enumerate(parts):
          if i % 2 == 0:
              # Text segment
              text = segment.strip()
              if text:
                  st.markdown(text)

          else:

              # ref_id segment
              ref_id = segment.strip()

              result = global_registry.get(session_id, ref_id) or fallback_refs.get(ref_id)

              if result:
                  render_search_result_block(result)
              else:
                  # ref not found (e.g. old session after restart)
                  st.caption(f"[搜索结果 {ref_id} 不可用]")

  
  
  def display_message(message: dict):
      """Display a chat message"""
      role = message["role"]
      content = message["content"]
      image_path = message.get("image_path")
      tool_calls = message.get("tool_calls", [])

      debug_steps = message.get("debug_steps", [])

  
      if role == "user":
          st.markdown('<div class="message user-message">', unsafe_allow_html=True)
  
          if image_path and Path(image_path).exists():
              try:
                  img = Image.open(image_path)
                  st.image(img, width=200)
              except Exception:
                  logger.warning(f"Failed to load user uploaded image: {image_path}")
  
          st.markdown(content)
          st.markdown("</div>", unsafe_allow_html=True)
  
      else:  # assistant

          # Tool call breadcrumb

          if tool_calls:

              tool_names = [tc["name"] for tc in tool_calls]

              st.caption(" → ".join(tool_names))
              st.markdown("")

          # Debug panel

          if debug_steps and st.session_state.get("show_debug"):
              with st.expander("思考 & 工具调用详细过程", expanded=False):
                  for idx, step in enumerate(debug_steps, 1):
                      node = step.get("node", "unknown")
                      st.markdown(f"**Step {idx} – {node}**")
  
                      if node == "agent":
                          msgs = step.get("messages", [])
                          if msgs:
                              st.markdown("**Agent Messages**")
                              for m in msgs:

                                  st.markdown(f"- `{m.get('type', 'assistant')}`: {m.get('content', '')}")

  
                          tcs = step.get("tool_calls", [])
                          if tcs:
                              st.markdown("**Planned Tool Calls**")
                              for j, tc in enumerate(tcs, 1):
                                  st.markdown(f"- **{j}. {tc.get('name')}**")
                                  st.code(tc.get("args", {}), language="json")
  
                      elif node == "tools":
                          results = step.get("results", [])
                          if results:
                              st.markdown("**Tool Results**")
                              for j, r in enumerate(results, 1):
                                  st.markdown(f"- **Result {j}:**")
                                  st.code(r.get("content", ""), language="text")
  
                      st.markdown("---")

  
          # Render message: expand [SEARCH_REF:xxx] tokens into product card blocks
          session_id = st.session_state.get("session_id", "")

          render_message_with_refs(
              content, session_id, fallback_refs=message.get("search_refs")
          )

  
          st.markdown("</div>", unsafe_allow_html=True)
  
  
  def display_welcome():
      """Display welcome screen"""
  
      col1, col2, col3, col4 = st.columns(4)
  
      with col1:
          st.markdown(
              """
              <div class="feature-card">

                  <div class="feature-icon">💗</div>
                  <div class="feature-title">懂你</div>
                  <div>能记住你的偏好，给你推荐适合的</div>

              </div>
              """,
              unsafe_allow_html=True,
          )
  
      with col2:
          st.markdown(
              """
              <div class="feature-card">

                  <div class="feature-icon">🛍️</div>
                  <div class="feature-title">懂商品</div>
                  <div>深度理解店铺内所有商品，智能匹配你的需求</div>

              </div>
              """,
              unsafe_allow_html=True,
          )
  
      with col3:
          st.markdown(
              """
              <div class="feature-card">

                  <div class="feature-icon">💭</div>
                  <div class="feature-title">贴心</div>
                  <div>任意聊</div>

              </div>
              """,
              unsafe_allow_html=True,
          )
  
      with col4:
          st.markdown(
              """
              <div class="feature-card">

                  <div class="feature-icon">👗</div>
                  <div class="feature-title">懂时尚</div>
                  <div>穿搭顾问 + 轻松对比</div>

              </div>
              """,
              unsafe_allow_html=True,
          )
  
      st.markdown("<br><br>", unsafe_allow_html=True)
  
  
  def main():
      """Main Streamlit app"""
      initialize_session()
  
      # Header
      st.markdown(
          """
          <div class="app-header">

              <div class="app-title">👗 ShopAgent</div>

              <div class="app-subtitle">AI Fashion Shopping Assistant</div>
          </div>
          """,
          unsafe_allow_html=True,
      )
  
      # Sidebar (collapsed by default, but accessible)
      with st.sidebar:
          st.markdown("### ⚙️ Settings")
  

          if st.button("🗑️ Clear Chat", width="stretch"):

              if "shopping_agent" in st.session_state:
                  st.session_state.shopping_agent.clear_history()

              # Clear search result registry for this session
              session_id = st.session_state.get("session_id", "")
              if session_id:
                  global_registry.clear_session(session_id)

              st.session_state.messages = []
              st.session_state.uploaded_image = None
              st.rerun()
  

          # Debug toggle
          st.markdown("---")
          st.checkbox(
              "显示调试过程 (debug)",
              key="show_debug",

              value=True,

              help="展开后可查看中间思考过程及工具调用详情",
          )
  

          st.markdown("---")
          st.caption(f"Session: `{st.session_state.session_id[:8]}...`")
  
      # Chat messages container
      messages_container = st.container()
  
      with messages_container:
          if not st.session_state.messages:
              display_welcome()
          else:
              for message in st.session_state.messages:
                  display_message(message)
  
      # Fixed input area at bottom (using container to simulate fixed position)
      st.markdown('<div class="fixed-input-container">', unsafe_allow_html=True)
  
      input_container = st.container()
  
      with input_container:
          # Image upload area (shown when + is clicked)
          if st.session_state.show_image_upload:
              uploaded_file = st.file_uploader(
                  "Choose an image",
                  type=["jpg", "jpeg", "png"],
                  key="file_uploader",
              )
  
              if uploaded_file:
                  st.session_state.uploaded_image = uploaded_file
                  # Show preview
                  col1, col2 = st.columns([1, 4])
                  with col1:
                      img = Image.open(uploaded_file)
                      st.image(img, width=100)
                  with col2:
                      if st.button("❌ Remove"):
                          st.session_state.uploaded_image = None
                          st.session_state.show_image_upload = False
                          st.rerun()
  
          # Input row
          col1, col2 = st.columns([1, 12])
  
          with col1:
              # Image upload toggle button

              if st.button("➕", help="Add image", width="stretch"):

                  st.session_state.show_image_upload = (
                      not st.session_state.show_image_upload
                  )
                  st.rerun()
  
          with col2:
              # Text input
              user_query = st.chat_input(
                  "Ask about fashion products...",
                  key="chat_input",
              )
  
      st.markdown("</div>", unsafe_allow_html=True)
  
      # Process user input
      if user_query:
          # Ensure shopping agent is initialized
          if "shopping_agent" not in st.session_state:
              st.error("Session not initialized. Please refresh the page.")
              st.stop()
  
          # Save uploaded image if present, or get from recent history
          image_path = None
          if st.session_state.uploaded_image:
              # User explicitly uploaded an image for this query
              image_path = save_uploaded_image(st.session_state.uploaded_image)
          else:
              # Check if query refers to a previous image
              query_lower = user_query.lower()
              if any(
                  ref in query_lower
                  for ref in [
                      "this",
                      "that",
                      "the image",
                      "the shirt",
                      "the product",
                      "it",
                  ]
              ):
                  # Find the most recent message with an image
                  for msg in reversed(st.session_state.messages):
                      if msg.get("role") == "user" and msg.get("image_path"):
                          image_path = msg["image_path"]
                          logger.info(f"Using image from previous message: {image_path}")
                          break
  
          # Add user message
          st.session_state.messages.append(
              {
                  "role": "user",
                  "content": user_query,
                  "image_path": image_path,
              }
          )
  
          # Display user message immediately
          with messages_container:
              display_message(st.session_state.messages[-1])
  
          # Process with shopping agent
          try:
              shopping_agent = st.session_state.shopping_agent
              

              # Handle greetings without invoking the agent

              query_lower = user_query.lower().strip()

              # Process with agent
              result = shopping_agent.chat(
                  query=user_query,
                  image_path=image_path,
              )
              response = result["response"]
              tool_calls = result.get("tool_calls", [])
              debug_steps = result.get("debug_steps", [])

              # Add assistant message (store search_refs so refs resolve after rerun)

              st.session_state.messages.append(
                  {
                      "role": "assistant",
                      "content": response,
                      "tool_calls": tool_calls,

                      "debug_steps": debug_steps,

                      "search_refs": result.get("search_refs", {}),

                  }
              )
  
              # Clear uploaded image and hide upload area after sending
              st.session_state.uploaded_image = None
              st.session_state.show_image_upload = False
  
              # Auto-scroll to bottom with JavaScript
              st.markdown(
                  """
                  <script>
                  window.scrollTo(0, document.body.scrollHeight);
                  </script>
                  """,
                  unsafe_allow_html=True,
              )
  
          except Exception as e:
              logger.error(f"Error processing query: {e}", exc_info=True)
              error_msg = f"I apologize, I encountered an error: {str(e)}"
  
              st.session_state.messages.append(
                  {
                      "role": "assistant",
                      "content": error_msg,
                  }
              )
  
          # Rerun to update UI
          st.rerun()
  
  
  if __name__ == "__main__":
      main()