import json

from llm.base import LLMBase
from mcp.client import MCPClient


class Agent:
    def __init__(self, llm: LLMBase):
        self.llm = llm
        self.mcp = MCPClient()

        self.tools = []
        self.messages = [
            {
                "role": "system",
                "content": (
                    "Du bist JARVIS, ein Smart-Home Assistent. "
                    "Du steuerst ein Haus über MCP Tools. "
                    "Wenn nötig, verwende Tools."
                )
            }
        ]
    async def load_tools(self):
        """
        Holt MCP Tools und konvertiert sie für Amazon Nova (Bedrock Converse API)
        """

        res = await self.mcp.list_tools()

        self.tools = []

        for t in res.tools:
            self.tools.append({
                "toolSpec": {
                    "name": t.name,
                    "description": t.description,
                    "inputSchema": {
                        "json": t.inputSchema
                    }
                }
            })

        print(f"[JARVIS] {len(self.tools)} Tools geladen")
    async def _run_tool(self, tool_use):
        """
        Führt MCP Tool aus
        """

        name = tool_use["name"]
        args = tool_use.get("input", {})

        result = await self.mcp.call_tool(name, args)

        return result
    async def run(self, user_input: str):

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

        for _ in range(8):

            response = await self.llm.chat(
                messages=self.messages,
                tools=self.tools
            )

            # 🧠 Bedrock Nova Response parsing
            output = response.get("output", {})

            message = output.get("message", {})

            content = message.get("content", [])
            tool_uses = []

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

                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["toolUseId"],
                            "content": [
                                {
                                    "text": str(result)
                                }
                            ]
                        }
                    })

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

                continue 
            final_text = ""

            for c in content:
                if "text" in c:
                    final_text += c["text"]

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

                return final_text

        return "Tool Loop Limit erreicht"