from functools import lru_cache

import httpx
from fastapi import Request

from app.ai.tool_generator import OpenAPIToolGenerator
from app.ai.tool_registry import ToolRegistry
from app.ai.wed_api_spec import wed_openapi_subset
from app.application.orchestrator import Orchestrator
from app.config import get_settings
from app.infrastructure.events import EventPublisher
from app.memory.context_builder import ContextBuilder
from app.memory.memory_manager import MemoryManager
from app.planner.llm_planner import HybridPlanner


@lru_cache
def context_builder() -> ContextBuilder:
    return ContextBuilder()


@lru_cache
def memory_manager() -> MemoryManager:
    manager = MemoryManager()
    manager.seed_demo()
    return manager


@lru_cache
def event_publisher() -> EventPublisher:
    return EventPublisher()


@lru_cache
def wed_api_spec() -> dict:
    settings = get_settings()
    if settings.wed_api_openapi_url:
        try:
            response = httpx.get(settings.wed_api_openapi_url, timeout=5)
            response.raise_for_status()
            return response.json()
        except Exception:
            return wed_openapi_subset()
    return wed_openapi_subset()


def tool_registry(request: Request) -> ToolRegistry:
    spec = wed_api_spec()
    tools = OpenAPIToolGenerator(spec).generate()
    filtered = [
        tool
        for tool in tools
        if tool.name
        in {
            "create_task",
            "update_task",
            "create_note",
            "update_note",
            "create_guest_reservation",
            "update_reservation",
        }
    ]
    return ToolRegistry(filtered)


def orchestrator(request: Request) -> Orchestrator:
    return Orchestrator(
        context=context_builder(),
        memory=memory_manager(),
        planner=HybridPlanner(),
        registry=tool_registry(request),
        publisher=event_publisher(),
    )