"""
  Conversational Shopping Agent with LangGraph
  True ReAct agent with autonomous tool calling and message accumulation
  """
  
  import logging
  from pathlib import Path
  from typing import Optional, Sequence
  
  from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
  from langchain_openai import ChatOpenAI
  from langgraph.checkpoint.memory import MemorySaver
  from langgraph.graph import END, START, StateGraph
  from langgraph.graph.message import add_messages
  from langgraph.prebuilt import ToolNode
  from typing_extensions import Annotated, TypedDict
  
  from app.config import settings
  from app.tools.search_tools import get_all_tools
  
  logger = logging.getLogger(__name__)
  
  
  def _extract_message_text(msg) -> str:
      """Extract text from message content.
      LangChain 1.0: content may be str or content_blocks (list) for multimodal."""
      content = getattr(msg, "content", "")
      if isinstance(content, str):
          return content
      if isinstance(content, list):
          parts = []
          for block in content:
              if isinstance(block, dict):
                  parts.append(block.get("text", block.get("content", "")))
              else:
                  parts.append(str(block))
          return "".join(str(p) for p in parts)
      return str(content) if content else ""
  
  
  class AgentState(TypedDict):
      """State for the shopping agent with message accumulation"""
  
      messages: Annotated[Sequence[BaseMessage], add_messages]
      current_image_path: Optional[str]  # Track uploaded image
  

  print("settings")

  class ShoppingAgent:
      """True ReAct agent with autonomous decision making"""
  
      def __init__(self, session_id: Optional[str] = None):
          self.session_id = session_id or "default"
  
          # Initialize LLM

          llm_kwargs = dict(

              model=settings.openai_model,
              temperature=settings.openai_temperature,
              api_key=settings.openai_api_key,
          )

          if settings.openai_api_base_url:
              llm_kwargs["base_url"] = settings.openai_api_base_url

          
          print("llm_kwargs")
          print(llm_kwargs)
  

          self.llm = ChatOpenAI(**llm_kwargs)

  
          # Get tools and bind to model
          self.tools = get_all_tools()
          self.llm_with_tools = self.llm.bind_tools(self.tools)
  
          # Build graph
          self.graph = self._build_graph()
  
          logger.info(f"Shopping agent initialized for session: {self.session_id}")
  
      def _build_graph(self):
          """Build the LangGraph StateGraph"""
  
          # System prompt for the agent

          system_prompt = """你是一位智能时尚购物助手，你可以：
  1. 根据文字描述搜索商品（使用 search_products）
  2. 分析图片风格和属性（使用 analyze_image_style）
  
  当用户咨询商品时：
  - 文字提问：直接使用 search_products 搜索
  - 图片上传：先用 analyze_image_style 理解商品，再用提取的描述调用 search_products 搜索
  - 可按需连续调用多个工具
  - 始终保持有用、友好的回复风格
  
  关键格式规则：
  展示商品结果时，每个商品必须严格按以下格式输出：
  
  1. [标题 title]
     ID: [商品ID]
     分类: [category_path]
     中文名: [title_cn]（如有）
     标签: [tags]（如有）
  
  示例：

  1. Puma Men White 3/4 Length Pants
     ID: 12345

     分类: 服饰 > 裤装 > 运动裤
     中文名: 彪马男士白色九分运动裤
     标签: 运动,夏季,白色

  不可省略 ID 字段！它是展示商品图片的关键。
  介绍要口语化，但必须保持上述商品格式。"""

  
          def agent_node(state: AgentState):
              """Agent decision node - decides which tools to call or when to respond"""
              messages = state["messages"]
  
              # Add system prompt if first message
              if not any(isinstance(m, SystemMessage) for m in messages):
                  messages = [SystemMessage(content=system_prompt)] + list(messages)
  
              # Handle image context
              if state.get("current_image_path"):
                  # Inject image path context for tool calls
                  # The agent can reference this in its reasoning
                  pass
  
              # Invoke LLM with tools
              response = self.llm_with_tools.invoke(messages)
              return {"messages": [response]}
  
          # Create tool node
          tool_node = ToolNode(self.tools)
  
          def should_continue(state: AgentState):
              """Determine if agent should continue or end"""
              messages = state["messages"]
              last_message = messages[-1]
  
              # If LLM made tool calls, continue to tools
              if hasattr(last_message, "tool_calls") and last_message.tool_calls:
                  return "tools"
              # Otherwise, end (agent has final response)
              return END
  
          # Build graph
          workflow = StateGraph(AgentState)
  
          workflow.add_node("agent", agent_node)
          workflow.add_node("tools", tool_node)
  
          workflow.add_edge(START, "agent")
          workflow.add_conditional_edges("agent", should_continue, ["tools", END])
          workflow.add_edge("tools", "agent")
  
          # Compile with memory
          checkpointer = MemorySaver()
          return workflow.compile(checkpointer=checkpointer)
  
      def chat(self, query: str, image_path: Optional[str] = None) -> dict:
          """Process user query with the agent
  
          Args:
              query: User's text query
              image_path: Optional path to uploaded image
  
          Returns:

              Dict with response and metadata, including:
                  - tool_calls: list of tool calls with args and (truncated) results
                  - debug_steps: detailed intermediate reasoning & tool execution steps

          """
          try:
              logger.info(
                  f"[{self.session_id}] Processing: '{query}' (image={'Yes' if image_path else 'No'})"
              )
  
              # Validate image
              if image_path and not Path(image_path).exists():
                  return {
                      "response": f"Error: Image file not found at '{image_path}'",
                      "error": True,
                  }
  
              # Build input message
              message_content = query
              if image_path:
                  message_content = f"{query}\n[User uploaded image: {image_path}]"
  
              # Invoke agent
              config = {"configurable": {"thread_id": self.session_id}}
              input_state = {
                  "messages": [HumanMessage(content=message_content)],
                  "current_image_path": image_path,
              }
  

              # Track tool calls (high-level) and detailed debug steps

              tool_calls = []

              debug_steps = []

              # Stream events to capture tool calls and intermediate reasoning

              for event in self.graph.stream(input_state, config=config):
                  logger.info(f"Event: {event}")

  
                  # Agent node: LLM reasoning & tool decisions

                  if "agent" in event:
                      agent_output = event["agent"]

                      messages = agent_output.get("messages", [])
  
                      step_messages = []
                      step_tool_calls = []
  
                      for msg in messages:
                          msg_text = _extract_message_text(msg)
                          msg_entry = {
                              "type": getattr(msg, "type", "assistant"),
                              "content": msg_text[:500],  # truncate for safety
                          }
                          step_messages.append(msg_entry)
  
                          # Capture tool calls from this agent message
                          if hasattr(msg, "tool_calls") and msg.tool_calls:
                              for tc in msg.tool_calls:
                                  tc_entry = {
                                      "name": tc.get("name"),
                                      "args": tc.get("args", {}),
                                  }
                                  tool_calls.append(tc_entry)
                                  step_tool_calls.append(tc_entry)
  
                      debug_steps.append(
                          {
                              "node": "agent",
                              "messages": step_messages,
                              "tool_calls": step_tool_calls,
                          }
                      )
  
                  # Tool node: actual tool execution results

                  if "tools" in event:
                      tools_output = event["tools"]

                      messages = tools_output.get("messages", [])
  
                      step_tool_results = []
  
                      for i, msg in enumerate(messages):
                          content_text = _extract_message_text(msg)
                          result_preview = content_text[:500] + ("..." if len(content_text) > 500 else "")
  
                          if i < len(tool_calls):
                              tool_calls[i]["result"] = result_preview
  
                          step_tool_results.append(
                              {
                                  "content": result_preview,
                              }
                          )
  
                      debug_steps.append(
                          {
                              "node": "tools",
                              "results": step_tool_results,
                          }
                      )

  
              # Get final state
              final_state = self.graph.get_state(config)
              final_message = final_state.values["messages"][-1]
              response_text = _extract_message_text(final_message)
  
              logger.info(f"[{self.session_id}] Response generated with {len(tool_calls)} tool calls")
  
              return {
                  "response": response_text,
                  "tool_calls": tool_calls,

                  "debug_steps": debug_steps,

                  "error": False,
              }
  
          except Exception as e:
              logger.error(f"Error in agent chat: {e}", exc_info=True)
              return {
                  "response": f"I apologize, I encountered an error: {str(e)}",
                  "error": True,
              }
  
      def get_conversation_history(self) -> list:
          """Get conversation history for this session"""
          try:
              config = {"configurable": {"thread_id": self.session_id}}
              state = self.graph.get_state(config)
  
              if not state or not state.values.get("messages"):
                  return []
  
              messages = state.values["messages"]
              result = []
  
              for msg in messages:
                  # Skip system messages and tool messages
                  if isinstance(msg, SystemMessage):
                      continue
                  if hasattr(msg, "type") and msg.type in ["system", "tool"]:
                      continue
  
                  role = "user" if msg.type == "human" else "assistant"
                  result.append({"role": role, "content": _extract_message_text(msg)})
  
              return result
  
          except Exception as e:
              logger.error(f"Error getting history: {e}")
              return []
  
      def clear_history(self):
          """Clear conversation history for this session"""
          # With MemorySaver, we can't easily clear, but we can log
          logger.info(f"[{self.session_id}] History clear requested")
          # In production, implement proper clearing or use new thread_id
  
  
  def create_shopping_agent(session_id: Optional[str] = None) -> ShoppingAgent:
      """Factory function to create a shopping agent"""
      return ShoppingAgent(session_id=session_id)