import asyncio
import json
import logging
import os
import time
from typing import Any
from urllib import error, request

from dotenv import load_dotenv
from livekit import agents
from livekit.agents import Agent, AgentServer, AgentSession, RunContext, function_tool
from livekit.plugins import google

load_dotenv(".env.local")
if not os.getenv("GOOGLE_API_KEY") and os.getenv("GEMINI_API_KEY"):
    os.environ["GOOGLE_API_KEY"] = os.environ["GEMINI_API_KEY"]

logger = logging.getLogger("podman-live-conversation")

AGENT_NAME = "podman-live-conversation"
MODEL = os.getenv("GEMINI_CONVERSATION_MODEL", "gemini-3.1-flash-live-preview")
VOICE = os.getenv("GEMINI_CONVERSATION_VOICE", "Aoede")
BACKEND_URL = os.getenv("PODMAN_BACKEND_URL", "http://127.0.0.1:8787").rstrip("/")
INTERNAL_AGENT_TOKEN = os.getenv("INTERNAL_AGENT_TOKEN", "")

INSTRUCTIONS = """You are PodMan, a concise real-time engineering teammate.
You are in a private 1:1 voice conversation with one developer.

Use PodMan tools before making claims about current work, git state, collisions, blockers,
team memory, or recent decisions. Keep spoken answers short. Prefer one useful next step.
If a critical collision event arrives, stop the current turn and state the alert immediately.
For complex repository, terminal, GitHub, MongoDB, build, install, deploy, or multi-step tasks,
call delegate_to_hermes. Do not run those actions directly. If the user says stop, wait, cancel,
or change of plans while Hermes is running, call abort_active_hermes_job immediately.
Do not reveal raw secrets, API keys, private tokens, or another teammate's private notes."""


def parse_metadata(raw: str | None) -> dict[str, str]:
    try:
        data = json.loads(raw or "{}")
    except json.JSONDecodeError:
        return {}
    return {str(k): str(v) for k, v in data.items() if v is not None}


def request_json(path: str, *, method: str = "GET", body: dict[str, Any] | None = None) -> Any:
    if not INTERNAL_AGENT_TOKEN:
        raise RuntimeError("INTERNAL_AGENT_TOKEN is not configured")
    data = None if body is None else json.dumps(body).encode("utf-8")
    req = request.Request(
        f"{BACKEND_URL}{path}",
        data=data,
        method=method,
        headers={
            "authorization": f"Bearer {INTERNAL_AGENT_TOKEN}",
            "content-type": "application/json",
        },
    )
    try:
        with request.urlopen(req, timeout=5) as res:
            payload = res.read().decode("utf-8")
            return json.loads(payload) if payload else {}
    except error.HTTPError as exc:
        detail = exc.read().decode("utf-8", "replace")
        raise RuntimeError(f"PodMan backend returned {exc.code}: {detail}") from exc


class PodManLiveAgent(Agent):
    def __init__(self, pod_id: str, identity: str, session_id: str, conversation_room: str) -> None:
        super().__init__(instructions=INSTRUCTIONS)
        self.pod_id = pod_id
        self.identity = identity
        self.session_id = session_id
        self.conversation_room = conversation_room
        self.active_hermes_job_id: str | None = None
        self.last_spoken_progress_at = 0.0

    @function_tool()
    async def get_active_pod_context(self, context: RunContext) -> str:
        """Get the current PodMan context for this developer and pod."""
        data = await asyncio.to_thread(
            request_json,
            f"/api/internal/pods/{self.pod_id}/live-context?identity={self.identity}",
        )
        return json.dumps(data, ensure_ascii=True)[:12000]

    @function_tool()
    async def record_conversation_note(self, context: RunContext, note: str, kind: str = "summary") -> str:
        """Store a useful decision, outcome, or preference learned during this conversation."""
        await asyncio.to_thread(
            request_json,
            f"/api/internal/pods/{self.pod_id}/live-conversation/{self.session_id}/note",
            method="POST",
            body={"identity": self.identity, "kind": kind, "note": note},
        )
        return "Saved to PodMan memory."

    @function_tool()
    async def get_recent_changes(self, context: RunContext) -> str:
        """Get recent local git and activity signals for this developer."""
        data = await asyncio.to_thread(
            request_json,
            f"/api/internal/pods/{self.pod_id}/live-context?identity={self.identity}",
        )
        focused = {
            "identity": data.get("identity"),
            "currentGitState": data.get("currentGitState"),
            "memberHistory": data.get("memberHistory"),
            "recentCollisions": data.get("recentCollisions"),
        }
        return json.dumps(focused, ensure_ascii=True)[:8000]

    @function_tool()
    async def search_team_memory(self, context: RunContext, query: str) -> str:
        """Search current compact team memory for information relevant to a query."""
        data = await asyncio.to_thread(
            request_json,
            f"/api/internal/pods/{self.pod_id}/live-context?identity={self.identity}",
        )
        haystack = json.dumps(data, ensure_ascii=True)
        query_terms = [term.lower() for term in query.split() if len(term) > 2]
        if not query_terms:
            return haystack[:6000]
        snippets = []
        lower = haystack.lower()
        for term in query_terms[:8]:
            idx = lower.find(term)
            if idx >= 0:
                snippets.append(haystack[max(0, idx - 400) : idx + 1200])
        return "\n---\n".join(snippets)[:8000] or haystack[:6000]

    @function_tool()
    async def delegate_to_hermes(
        self,
        context: RunContext,
        prompt: str,
        context_scope: str = "current_repo",
        target_repository: str = "",
        risk_level: str = "read_only",
        requires_confirmation: bool = False,
        success_criteria: list[str] | None = None,
    ) -> str:
        """Hand off a complex engineering task to Hermes, PodMan's autonomous backend execution engine.

        Use this for filesystem, terminal, GitHub, MongoDB, build, install, deploy, test,
        or multi-step repository tasks. Do not use this for simple conversational answers.
        """
        body = {
            "prompt": prompt,
            "contextScope": context_scope,
            "targetRepository": target_repository or "karti-ai/podman",
            "riskLevel": risk_level,
            "requiresConfirmation": requires_confirmation,
            "successCriteria": success_criteria or ["Hermes completes the requested inspection."],
            "podId": self.pod_id,
            "identity": self.identity,
            "sessionId": self.session_id,
            "conversationRoom": self.conversation_room,
        }
        job = await asyncio.to_thread(request_json, "/api/internal/hermes/jobs", method="POST", body=body)
        self.active_hermes_job_id = str(job["id"])
        return json.dumps(
            {
                "status": "accepted",
                "job_id": self.active_hermes_job_id,
                "spoken_ack": "Hermes is starting that now. I will keep you posted.",
            },
            ensure_ascii=True,
        )

    @function_tool()
    async def abort_active_hermes_job(self, context: RunContext, reason: str = "User changed plans") -> str:
        """Abort the currently running Hermes job immediately."""
        if not self.active_hermes_job_id:
            return "No active Hermes job is running."
        job = await asyncio.to_thread(
            request_json,
            f"/api/internal/hermes/jobs/{self.active_hermes_job_id}/abort",
            method="POST",
            body={"reason": reason},
        )
        return json.dumps(
            {
                "status": job.get("status", "aborting"),
                "job_id": self.active_hermes_job_id,
                "spoken_ack": "Stopped. Hermes is aborting the job before making further changes.",
            },
            ensure_ascii=True,
        )

    def should_speak_progress(self, event: dict[str, Any]) -> bool:
        event_type = event.get("type")
        if event_type in {"completed", "failed", "aborted", "needs_confirmation"}:
            return True
        if event_type not in {"heartbeat", "step_started", "step_completed"}:
            return False
        monotonic = time.monotonic()
        if monotonic - self.last_spoken_progress_at < 8:
            return False
        self.last_spoken_progress_at = monotonic
        return True


server = AgentServer()


@server.rtc_session(agent_name=AGENT_NAME)
async def entrypoint(ctx: agents.JobContext):
    metadata = parse_metadata(getattr(ctx.job, "metadata", None))
    pod_id = metadata.get("podId", "demo-pod")
    identity = metadata.get("identity", "developer")
    session_id = metadata.get("sessionId", "unknown")

    session = AgentSession(
        llm=google.realtime.RealtimeModel(
            model=MODEL,
            voice=VOICE,
        ),
    )
    agent = PodManLiveAgent(
        pod_id=pod_id,
        identity=identity,
        session_id=session_id,
        conversation_room=ctx.room.name,
    )

    def on_data_received(*args: Any):
        payload = args[0] if args else b""
        if isinstance(payload, str):
            raw = payload
        else:
            raw = bytes(payload).decode("utf-8", "replace")
        try:
            msg = json.loads(raw)
        except json.JSONDecodeError:
            return
        msg_type = msg.get("type")
        if msg_type == "HERMES_JOB_EVENT":
            event = msg.get("event") or {}
            summary = str(event.get("message") or "").strip()
            if str(event.get("type")) in {"completed", "failed", "aborted"}:
                agent.active_hermes_job_id = None
        elif msg_type == "LIVE_CONVERSATION_EVENT":
            event = msg.get("event") or {}
            summary = str(event.get("summary") or "").strip()
        else:
            return
        if not summary:
            return

        async def interrupt_and_say() -> None:
            try:
                if msg_type == "LIVE_CONVERSATION_EVENT":
                    await session.interrupt(force=True)
            except Exception as exc:
                logger.warning("interrupt failed: %s", exc)
            if msg_type == "LIVE_CONVERSATION_EVENT" or agent.should_speak_progress(event):
                await session.say(summary, allow_interruptions=True, add_to_chat_ctx=True)

        asyncio.create_task(interrupt_and_say())

    ctx.room.on("data_received", on_data_received)
    await session.start(room=ctx.room, agent=agent)
    await ctx.connect()


if __name__ == "__main__":
    agents.cli.run_app(server)