"""
WebRTC signaling — relay SDP/ICE between browser and node.

The hub NEVER touches content. This is pure signaling: < 1 KB per message,
stateless relay. After the SDP exchange completes, the browser and node
communicate P2P via WebRTC DataChannel — hub is out of the loop.

Flow:
  Browser → Hub : POST /v1/nodes/{node_id}/webrtc/offer  {sdp, ice_candidates}
  Hub → Node    : WS push {type: "webrtc_offer", sdp, ice_candidates, peer_id}
  Node → Hub    : WS reply {type: "webrtc_answer", sdp, ice_candidates, peer_id}
  Hub → Browser : HTTP response {sdp, ice_candidates}
"""

import asyncio
import json
import logging
import uuid

from fastapi import APIRouter, Depends, HTTPException, Request
from pydantic import BaseModel
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from meshbay_hub.api.deps import get_current_user
from meshbay_hub.api.middleware import limiter
from meshbay_hub.db.engine import get_db
from meshbay_hub.db.models import Group, GroupMember, User

log = logging.getLogger(__name__)

router = APIRouter(prefix="/v1/nodes", tags=["signaling"])

_webrtc_answers: dict[str, asyncio.Future] = {}


class WebRTCOfferRequest(BaseModel):
    sdp: str
    ice_candidates: list[dict] = []


class WebRTCOfferResponse(BaseModel):
    sdp: str
    ice_candidates: list[dict] = []
    peer_id: str


MAX_SDP_BYTES = 16 * 1024          # an SDP offer is ~2 KB
MAX_PENDING_PER_USER = 3           # concurrent in-flight offers per account

_pending_per_user: dict[str, int] = {}


@router.post("/{node_id}/webrtc/offer", response_model=WebRTCOfferResponse)
@limiter.limit("30/minute")
async def webrtc_offer(
    node_id: str,
    body: WebRTCOfferRequest,
    request: Request,
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
):
    """
    Browser sends WebRTC SDP offer for a node. Hub relays via WebSocket.
    Returns the node's SDP answer once received.

    Finding H6: this was reachable by any authenticated user, for any node, with no
    rate limit and no membership check. Each call makes the node allocate an
    aiortc RTCPeerConnection and gather ICE, so it was a remote resource-exhaustion
    primitive against an arbitrary third party's machine.

    Finding H4: it also ignored group status, so "suspend a group" did not stop new
    connections from being brokered to nodes hosting it.
    """
    from meshbay_hub.api.revocation import _connected_nodes, _node_groups

    if len(body.sdp) > MAX_SDP_BYTES:
        raise HTTPException(status_code=413, detail="SDP too large")

    ws = _connected_nodes.get(node_id)
    if not ws:
        raise HTTPException(status_code=404, detail="Node not connected")

    # The caller must share at least one active group with the target node.
    node_group_ids = set(_node_groups.get(node_id, []))
    if node_group_ids:
        result = await db.execute(
            select(GroupMember.group_id).where(
                GroupMember.user_id == current_user.id,
                GroupMember.group_id.in_(node_group_ids),
            ))
        shared = [gid for (gid,) in result.all()]
        if not shared:
            raise HTTPException(status_code=403, detail="Not a member of any group on this node")

        active = await db.execute(
            select(Group.id).where(Group.id.in_(shared), Group.status == "active"))
        if not active.first():
            raise HTTPException(status_code=403, detail="Group is not active")

    if _pending_per_user.get(current_user.id, 0) >= MAX_PENDING_PER_USER:
        raise HTTPException(status_code=429, detail="Too many pending connections")

    peer_id = str(uuid.uuid4())
    answer_future: asyncio.Future = asyncio.get_event_loop().create_future()
    _webrtc_answers[peer_id] = answer_future
    _pending_per_user[current_user.id] = _pending_per_user.get(current_user.id, 0) + 1

    try:
        await ws.send_text(json.dumps({
            "type": "webrtc_offer",
            "peer_id": peer_id,
            "user_id": current_user.id,
            "sdp": body.sdp,
            "ice_candidates": body.ice_candidates,
        }))

        try:
            answer = await asyncio.wait_for(answer_future, timeout=15.0)
        except asyncio.TimeoutError:
            raise HTTPException(
                status_code=504, detail="Node did not respond with WebRTC answer")

        return WebRTCOfferResponse(
            sdp=answer["sdp"],
            ice_candidates=answer.get("ice_candidates", []),
            peer_id=peer_id,
        )
    finally:
        _webrtc_answers.pop(peer_id, None)
        remaining = _pending_per_user.get(current_user.id, 1) - 1
        if remaining > 0:
            _pending_per_user[current_user.id] = remaining
        else:
            _pending_per_user.pop(current_user.id, None)


def handle_webrtc_answer(msg: dict) -> None:
    """Called from the node WebSocket message loop when a webrtc_answer arrives."""
    peer_id = msg.get("peer_id")
    if not peer_id:
        log.warning("webrtc_answer without peer_id")
        return

    future = _webrtc_answers.get(peer_id)
    if future and not future.done():
        future.set_result({
            "sdp": msg.get("sdp", ""),
            "ice_candidates": msg.get("ice_candidates", []),
        })
    else:
        log.warning("webrtc_answer for unknown peer_id: %s", peer_id)