"""CyberBrain26 - modularni monolit (Faze 4).

Spojuje webapp a safe_oi do jednoho FastAPI procesu s mount pointy:
  - /safe-oi/*   -> safe_oi (bezpecnostni API)
  - /v1/*, /ui, / -> webapp (worktree, terminal, openclaw, UI)
  - /health       -> agregovany stav vsech sluzeb

LiteLLM proxy zustava oddeleny proces (vlastni CLI, subprocess).

Monolit se defaultne spousti na portu 8080 (CB26_MONOLITH_PORT).
"""
from __future__ import annotations

import os

import httpx
from fastapi import FastAPI

from cyberbrain26.services.safe_oi.app import app as _safe_oi_app
from cyberbrain26.services.webapp.app import app as _webapp_app

VERSION = "4.0.0"

MONOLITH_PORT = int(os.environ.get("CB26_MONOLITH_PORT", "8080"))
LITELLM_PORT = int(os.environ.get("CB26_LITELLM_PORT", "4100"))


async def _check_external(name: str, url: str, timeout: float = 1.0) -> dict:
    """Zavola health endpoint externi sluzby (litellm)."""
    try:
        async with httpx.AsyncClient(timeout=timeout) as c:
            r = await c.get(url)
            return {
                "status": "ok" if r.status_code < 500 else "error",
                "http": r.status_code,
            }
    except Exception as e:
        return {"status": "unavailable", "error": type(e).__name__}


def _check_internal(name: str) -> dict:
    """Interni kontrola sub-app (safe_oi, webapp) - jsou soucasti monolitu."""
    try:
        if name == "safe_oi":
            from cyberbrain26.services.safe_oi import app as _safe_oi_mod
            n = len(_safe_oi_mod.app.routes)
        elif name == "webapp":
            from cyberbrain26.services.webapp import app as _webapp_mod
            n = len(_webapp_mod.app.routes)
        else:
            return {"status": "unknown"}
        return {"status": "ok", "routes": n, "type": "internal"}
    except Exception as e:
        return {"status": "error", "error": type(e).__name__}


def create_app() -> FastAPI:
    app = FastAPI(
        title="CyberBrain26",
        version=VERSION,
        description="Modularni monolit (Faze 4) - webapp + safe_oi",
    )

    # --- Agregovany /health - MUSI byt registrovan PRED mount("/") ---
    @app.get("/health", tags=["meta"])
    async def aggregate_health() -> dict:
        """Vrati stav vsech sluzeb (safe_oi, webapp, litellm)."""
        # Litellm je externi proces
        ext_result = await _check_external(
            "litellm",
            f"http://127.0.0.1:{LITELLM_PORT}/health/liveliness",
        )
        # safe_oi a webapp jsou interni sub-app (soucast monolitu)
        services = {
            "litellm": ext_result,
            "safe_oi": _check_internal("safe_oi"),
            "webapp": _check_internal("webapp"),
        }
        overall = (
            "ok" if all(s.get("status") == "ok" for s in services.values())
            else "degraded"
        )
        return {
            "status": overall,
            "version": VERSION,
            "monolith_port": MONOLITH_PORT,
            "services": services,
        }

    # --- Mount sub-apps ---
    # Poradi: safe_oi prvni (/safe-oi/*), pak webapp na rootu
    app.mount("/safe-oi", _safe_oi_app)
    app.mount("/", _webapp_app)

    return app


app = create_app()


if __name__ == "__main__":
    import uvicorn
    print(f"CyberBrain26 monolit na portu {MONOLITH_PORT}")
    uvicorn.run(app, host="0.0.0.0", port=MONOLITH_PORT, log_level="info")