"""
  OmniShopAgent - 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
  
  # 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="OmniShopAgent",
      page_icon="👗",
      layout="centered",
      initial_sidebar_state="collapsed",
  )
  
  # Custom CSS - ChatGPT-like style
  st.markdown(
      """
      <style>
      /* Hide default Streamlit elements */
      #MainMenu {visibility: hidden;}
      footer {visibility: hidden;}
      header {visibility: 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
  
  
  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 extract_products_from_response(response: str) -> list:
      """Extract product information from agent response
  
      Returns list of dicts with product info
      """
      products = []
  
      # Pattern to match product blocks in the response
      # Looking for ID, name, and other details
      lines = response.split("\n")
      current_product = {}
  
      for line in lines:
          line = line.strip()
  
          # Match product number (e.g., "1. Product Name" or "**1. Product Name**")
          if re.match(r"^\*?\*?\d+\.\s+", line):
              if current_product:
                  products.append(current_product)
              current_product = {}
              # Extract product name
              name = re.sub(r"^\*?\*?\d+\.\s+", "", line)
              name = name.replace("**", "").strip()
              current_product["name"] = name
  
          # Match ID
          elif "ID:" in line or "id:" in line:
              id_match = re.search(r"(?:ID|id):\s*(\d+)", line)
              if id_match:
                  current_product["id"] = id_match.group(1)
  
          # Match Category
          elif "Category:" in line:
              cat_match = re.search(r"Category:\s*(.+?)(?:\n|$)", line)
              if cat_match:
                  current_product["category"] = cat_match.group(1).strip()
  
          # Match Color
          elif "Color:" in line:
              color_match = re.search(r"Color:\s*(\w+)", line)
              if color_match:
                  current_product["color"] = color_match.group(1)
  
          # Match Gender
          elif "Gender:" in line:
              gender_match = re.search(r"Gender:\s*(\w+)", line)
              if gender_match:
                  current_product["gender"] = gender_match.group(1)
  
          # Match Season
          elif "Season:" in line:
              season_match = re.search(r"Season:\s*(\w+)", line)
              if season_match:
                  current_product["season"] = season_match.group(1)
  
          # Match Usage
          elif "Usage:" in line:
              usage_match = re.search(r"Usage:\s*(\w+)", line)
              if usage_match:
                  current_product["usage"] = usage_match.group(1)
  
          # Match Similarity/Relevance score
          elif "Similarity:" in line or "Relevance:" in line:
              score_match = re.search(r"(?:Similarity|Relevance):\s*([\d.]+)%", line)
              if score_match:
                  current_product["score"] = score_match.group(1)
  
      # Add last product
      if current_product:
          products.append(current_product)
  
      return products
  
  
  def display_product_card(product: dict):
      """Display a product card with image and name"""
      product_id = product.get("id", "")
      name = product.get("name", "Unknown Product")
      
      # Debug: log what we got
      logger.info(f"Displaying product: ID={product_id}, Name={name}")
  
      # Try to load image from data/images directory
      if product_id:
          image_path = Path(f"data/images/{product_id}.jpg")
          
          if image_path.exists():
              try:
                  img = Image.open(image_path)
                  # Fixed size for all images
                  target_size = (200, 200)
                  try:
                      # Try new Pillow API
                      img_processed = ImageOps.fit(
                          img, target_size, method=Image.Resampling.LANCZOS
                      )
                  except AttributeError:
                      # Fallback for older Pillow versions
                      img_processed = ImageOps.fit(
                          img, target_size, method=Image.LANCZOS
                      )
                  
                  # Display image with fixed width
                  st.image(img_processed, use_container_width=False, width=200)
                  st.markdown(f"**{name}**")
                  st.caption(f"ID: {product_id}")
                  return
              except Exception as e:
                  logger.warning(f"Failed to load image {image_path}: {e}")
          else:
              logger.warning(f"Image not found: {image_path}")
      
      # Fallback: no image
      st.markdown(f"**📷 {name}**")
      if product_id:
          st.caption(f"ID: {product_id}")
      else:
          st.caption("ID not available")
  
  
  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", [])
  
      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
          # Display tool calls horizontally - only tool names
          if tool_calls:
              tool_names = [tc['name'] for tc in tool_calls]
              st.caption(" → ".join(tool_names))
              st.markdown("")
          
          # Extract and display products if any
          products = extract_products_from_response(content)
          
          # Debug logging
          logger.info(f"Extracted {len(products)} products from response")
          for p in products:
              logger.info(f"Product: {p}")
  
          if products:
              def parse_score(product: dict) -> float:
                  score = product.get("score")
                  if score is None:
                      return 0.0
                  try:
                      return float(score)
                  except (TypeError, ValueError):
                      return 0.0
  
              # Sort by score and limit to 3
              products = sorted(products, key=parse_score, reverse=True)[:3]
              
              logger.info(f"Displaying top {len(products)} products")
  
              # Display the text response first (without product details)
              text_lines = []
              for line in content.split("\n"):
                  # Skip product detail lines
                  if not any(
                      keyword in line
                      for keyword in [
                          "ID:",
                          "Category:",
                          "Color:",
                          "Gender:",
                          "Season:",
                          "Usage:",
                          "Similarity:",
                          "Relevance:",
                      ]
                  ):
                      if not re.match(r"^\*?\*?\d+\.\s+", line):
                          text_lines.append(line)
  
              intro_text = "\n".join(text_lines).strip()
              if intro_text:
                  st.markdown(intro_text)
  
              # Display product cards in grid
              st.markdown("<br>", unsafe_allow_html=True)
  
              # Create exactly 3 columns with equal width
              cols = st.columns(3)
              for j, product in enumerate(products[:3]):  # Ensure max 3
                  with cols[j]:
                      display_product_card(product)
          else:
              # No products found, display full content
              st.markdown(content)
  
          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">Text Search</div>
                  <div>Describe what you want</div>
              </div>
              """,
              unsafe_allow_html=True,
          )
  
      with col2:
          st.markdown(
              """
              <div class="feature-card">
                  <div class="feature-icon">📸</div>
                  <div class="feature-title">Image Search</div>
                  <div>Upload product photos</div>
              </div>
              """,
              unsafe_allow_html=True,
          )
  
      with col3:
          st.markdown(
              """
              <div class="feature-card">
                  <div class="feature-icon">🔍</div>
                  <div class="feature-title">Visual Analysis</div>
                  <div>AI analyzes prodcut style</div>
              </div>
              """,
              unsafe_allow_html=True,
          )
  
      with col4:
          st.markdown(
              """
              <div class="feature-card">
                  <div class="feature-icon">💭</div>
                  <div class="feature-title">Conversational</div>
                  <div>Remembers context</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">👗 OmniShopAgent</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", use_container_width=True):
              if "shopping_agent" in st.session_state:
                  st.session_state.shopping_agent.clear_history()
              st.session_state.messages = []
              st.session_state.uploaded_image = None
              st.rerun()
  
          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", use_container_width=True):
                  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
              query_lower = user_query.lower().strip()
              if query_lower in ["hi", "hello", "hey"]:
                  response = """Hello! 👋 I'm your fashion shopping assistant.
  
  I can help you:
  - Search for products by description
  - Find items similar to images you upload
  - Analyze product styles
  
  What are you looking for today?"""
                  tool_calls = []
              else:
                  # Process with agent
                  result = shopping_agent.chat(
                      query=user_query,
                      image_path=image_path,
                  )
                  response = result["response"]
                  tool_calls = result.get("tool_calls", [])
  
              # Add assistant message
              st.session_state.messages.append(
                  {
                      "role": "assistant",
                      "content": response,
                      "tool_calls": tool_calls,
                  }
              )
  
              # 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()