from llm.bedrock import BedrockClient
from jarvis_mcp.client import MCPClient
from config import MCP_URL
from util.logger import get_logger
import asyncio
from pathlib import Path

# Import des neuen Web-Search Tools und der IR Sender Api
from tools.web_search import web_search_tool, web_search
from tools.script_api_tool import script_api_tool

class Agent:
    def __init__(self):
        self.logger = get_logger("NORA")

        self.llm = BedrockClient()
        self.mcp = MCPClient(MCP_URL)

        self.tools = []

        # Personality / System-Prompt (als User-Message für Nova 2 Lite)
        self.system_prompt = self._load_system_prompt()

        self.messages = [
            {
                "role": "user",
                "content": [{"text": self.system_prompt}]
            }
        ]

    def _load_system_prompt(self) -> str:
        """Lädt Personality aus externer Datei"""
        try:
            prompt_path = Path("prompts/nora_system.txt")
            if prompt_path.exists():
                return prompt_path.read_text(encoding="utf-8").strip()
            else:
                self.logger.warning("System-Prompt-Datei nicht gefunden. Verwende Standard.")
                return (
                    "Du bist N.O.R.A (Neural Operations for Residential Automation), "
                    "ein freundlicher, kompetenter und leicht ironischer Smart-Home Assistent. "
                    "Du antwortest natürlich und auf Deutsch. Nutze Tools wenn sinnvoll."
                )
        except Exception:
            return "Du bist N.O.R.A, ein hilfreicher Smart-Home Assistent."

    # -------------------------
    # TOOL LOADING
    # -------------------------
    async def load_tools(self):
        try:
            # 1. OpenHAB Tools vom MCP Server laden
            res = await self.mcp.list_tools()

            self.tools = []
            for t in res.tools:
                schema = t.inputSchema
                # Bedrock-kompatibles Format
                if isinstance(schema, dict) and "json" not in schema:
                    bedrock_schema = {"json": schema}
                else:
                    bedrock_schema = schema
                    
                self.tools.append(script_api_tool)

                self.tools.append({
                    "toolSpec": {
                        "name": t.name,
                        "description": t.description,
                        "inputSchema": bedrock_schema
                    }
                })


            self.logger.info(f"{len(self.tools)} OpenHAB-Tools erfolgreich geladen")

            # 2. Web-Search Tool manuell hinzufügen
            if not any(t.get("toolSpec", {}).get("name") == "web_search" for t in self.tools):
                self.tools.append(web_search_tool)
                self.logger.info("Web-Search Tool hinzugefügt (DuckDuckGo)")

            self.logger.info(f"Gesamt: {len(self.tools)} Tools geladen")

        except Exception as e:
            self.logger.error(f"Tool Load Error: {e}")
            self.tools = []

    # -------------------------
    # TOOL EXECUTION
    # -------------------------
    async def _run_tool(self, tool):
        try:
            tool_use = tool.get("toolUse", tool)
            name = tool_use.get("name")
            args = tool_use.get("input", {}) or {}

            self.logger.info(f"Tool Call → {name} | args={args}")

            # Web-Search Tool
            if name == "web_search":
                return await web_search(**args)
            if tool_name == "run_script":

                result = await run_script(
                arguments["command"],
                arguments.get("args")
            )

            # Normale MCP Tools (OpenHAB)
            result = await self.mcp.call_tool(name, args)

            if hasattr(result, "content"):
                return result.content
            return result

        except Exception as e:
            self.logger.error(f"Tool Error ({name}): {e}")
            return f"ERROR: {e}"

    # -------------------------
    # MAIN LOOP
    # -------------------------
    async def run(self, user_input: str):
        self.messages.append({
            "role": "user",
            "content": [{"text": user_input}]
        })

        for iteration in range(12):
            try:
                response = await self.llm.chat(
                    messages=self.messages,
                    tools=self.tools if self.tools else None
                )
            except Exception as e:
                self.logger.error(f"LLM Error: {e}")
                return f"LLM Fehler: {e}"

            output = response.get("output", {})
            message = output.get("message", {})
            content = message.get("content", [])

            tool_uses = []
            final_text = []

            for c in content:
                if "toolUse" in c:
                    tool_uses.append(c)
                elif "text" in c:
                    final_text.append(c["text"])

            if tool_uses:
                self.logger.info(f"{len(tool_uses)} Tool(s) detected")

                self.messages.append({
                    "role": "assistant",
                    "content": content
                })

                tool_results = []
                for tool in tool_uses:
                    result = await self._run_tool(tool)
                    tool_results.append({
                        "toolResult": {
                            "toolUseId": tool.get("toolUse", tool).get("toolUseId"),
                            "content": [{"text": str(result)}]
                        }
                    })

                self.messages.append({
                    "role": "user",
                    "content": tool_results
                })
                continue

            # Finale Antwort
            if final_text:
                text = "\n".join(final_text)
                self.messages.append({
                    "role": "assistant",
                    "content": [{"text": text}]
                })
                return text

        return "Tool Loop Limit erreicht. Bitte versuche es erneut."