┌─────────────────────────────────────────────────────────────────────────────┐
│                      WEBRTC BRIDGE ARCHITECTURE                             │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│                              PSTN NETWORK                                   │
│                                   │                                         │
│                                   ▼                                         │
│   ┌─────────────────────────────────────────────────────────────────────┐   │
│   │                        GoToConnect                                   │   │
│   │                                                                      │   │
│   │  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐          │   │
│   │  │   SIP/PSTN   │───▶│   Media      │───▶│   WebRTC     │          │   │
│   │  │   Gateway    │    │   Server     │    │   Endpoint   │          │   │
│   │  └──────────────┘    └──────────────┘    └──────┬───────┘          │   │
│   │                                                  │                   │   │
│   └──────────────────────────────────────────────────┼───────────────────┘   │
│                                                      │                       │
│                                          WebRTC (DTLS-SRTP)                 │
│                                                      │                       │
│   ┌──────────────────────────────────────────────────┼───────────────────┐   │
│   │                     WEBRTC BRIDGE                │                   │   │
│   │                                                  │                   │   │
│   │   ┌──────────────────────────────────────────────▼─────────────┐    │   │
│   │   │                   GoTo Connection                           │    │   │
│   │   │                                                             │    │   │
│   │   │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │    │   │
│   │   │  │    SDP      │  │    ICE      │  │   Audio     │        │    │   │
│   │   │  │  Negotiator │  │   Agent     │  │   Track     │        │    │   │
│   │   │  └─────────────┘  └─────────────┘  └──────┬──────┘        │    │   │
│   │   │                                           │                │    │   │
│   │   └───────────────────────────────────────────┼────────────────┘    │   │
│   │                                               │                      │   │
│   │   ┌───────────────────────────────────────────▼────────────────┐    │   │
│   │   │                   AUDIO BRIDGE                              │    │   │
│   │   │                                                             │    │   │
│   │   │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │    │   │
│   │   │  │   Decoder   │  │  Resampler  │  │   Encoder   │        │    │   │
│   │   │  │  (Opus/G711)│  │  (48k↔16k)  │  │  (Opus)     │        │    │   │
│   │   │  └─────────────┘  └─────────────┘  └─────────────┘        │    │   │
│   │   │                                                             │    │   │
│   │   │  ┌─────────────────────────────────────────────────────┐   │    │   │
│   │   │  │              Bidirectional Buffer                    │   │    │   │
│   │   │  │         GoTo → Pipeline    Pipeline → GoTo           │   │    │   │
│   │   │  └─────────────────────────────────────────────────────┘   │    │   │
│   │   │                                                             │    │   │
│   │   └───────────────────────────────────────────┬────────────────┘    │   │
│   │                                               │                      │   │
│   │   ┌───────────────────────────────────────────▼────────────────┐    │   │
│   │   │                  LiveKit Connection                         │    │   │
│   │   │                                                             │    │   │
│   │   │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │    │   │
│   │   │  │    Room     │  │   Audio     │  │   Audio     │        │    │   │
│   │   │  │   Client    │  │   Source    │  │   Sink      │        │    │   │
│   │   │  └─────────────┘  └─────────────┘  └─────────────┘        │    │   │
│   │   │                                                             │    │   │
│   │   └─────────────────────────────────────────────────────────────┘    │   │
│   │                                                                      │   │
│   └──────────────────────────────────────────────────────────────────────┘   │
│                                                      │                       │
│                                          WebRTC (DTLS-SRTP)                 │
│                                                      │                       │
│   ┌──────────────────────────────────────────────────┼───────────────────┐   │
│   │                      LiveKit SFU                 │                   │   │
│   │                                                  ▼                   │   │
│   │  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐          │   │
│   │  │    Room      │◀──▶│   Selective  │◀──▶│   Agent      │          │   │
│   │  │   Manager    │    │   Forwarder  │    │   Worker     │          │   │
│   │  └──────────────┘    └──────────────┘    └──────────────┘          │   │
│   │                                                                      │   │
│   └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                         AUDIO DATA FLOW                                     │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   INBOUND (Caller → AI):                                                    │
│   ─────────────────────                                                     │
│                                                                             │
│   GoToConnect           Bridge                    LiveKit                   │
│       │                    │                         │                      │
│       │   RTP/Opus or      │                         │                      │
│       │   RTP/PCMU         │                         │                      │
│       │──────────────────▶ │                         │                      │
│       │                    │  decode                 │                      │
│       │                    │  ──────▶ PCM 48kHz      │                      │
│       │                    │         │               │                      │
│       │                    │  resample               │                      │
│       │                    │  ──────▶ PCM 16kHz      │                      │
│       │                    │         │               │                      │
│       │                    │         │──────────────▶│ (to STT)             │
│       │                    │         │               │                      │
│       │                    │  encode                 │                      │
│       │                    │  ──────▶ Opus 48kHz     │                      │
│       │                    │         │               │                      │
│       │                    │         │──────────────▶│ (to Room)            │
│       │                    │                         │                      │
│                                                                             │
│   OUTBOUND (AI → Caller):                                                   │
│   ──────────────────────                                                    │
│                                                                             │
│   GoToConnect           Bridge                    LiveKit                   │
│       │                    │                         │                      │
│       │                    │         │◀──────────────│ (from TTS)           │
│       │                    │         │               │                      │
│       │                    │  PCM 24kHz              │                      │
│       │                    │         │               │                      │
│       │                    │  resample               │                      │
│       │                    │  ──────▶ PCM 48kHz      │                      │
│       │                    │         │               │                      │
│       │                    │  encode                 │                      │
│       │                    │  ──────▶ Opus/PCMU      │                      │
│       │                    │         │               │                      │
│       │ ◀─────────────────────────────               │                      │
│       │   RTP                        │               │                      │
│       │                              │               │                      │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                         THREADING MODEL                                     │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   ┌─────────────────────────────────────────────────────────────────────┐   │
│   │                      MAIN ASYNCIO EVENT LOOP                        │   │
│   │                                                                     │   │
│   │   ┌─────────────┐  ┌─────────────┐  ┌─────────────┐               │   │
│   │   │  WebRTC     │  │  LiveKit    │  │  Control    │               │   │
│   │   │  Signaling  │  │  Signaling  │  │  Logic      │               │   │
│   │   └─────────────┘  └─────────────┘  └─────────────┘               │   │
│   │                                                                     │   │
│   └─────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│   ┌─────────────────────────────────────────────────────────────────────┐   │
│   │                      AIORTC MEDIA THREAD                            │   │
│   │                                                                     │   │
│   │   ┌─────────────┐  ┌─────────────┐  ┌─────────────┐               │   │
│   │   │  RTP        │  │  Codec      │  │  RTCP       │               │   │
│   │   │  Processing │  │  Encode/    │  │  Processing │               │   │
│   │   │             │  │  Decode     │  │             │               │   │
│   │   └─────────────┘  └─────────────┘  └─────────────┘               │   │
│   │                                                                     │   │
│   └─────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│   ┌─────────────────────────────────────────────────────────────────────┐   │
│   │                      AUDIO PROCESSING THREAD                        │   │
│   │                                                                     │   │
│   │   ┌─────────────┐  ┌─────────────┐  ┌─────────────┐               │   │
│   │   │  Resampling │  │  Buffer     │  │  Format     │               │   │
│   │   │             │  │  Management │  │  Conversion │               │   │
│   │   └─────────────┘  └─────────────┘  └─────────────┘               │   │
│   │                                                                     │   │
│   └─────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│   COMMUNICATION:                                                            │
│   • asyncio.Queue for cross-thread audio transfer                          │
│   • Thread-safe buffers for frame handoff                                  │
│   • Events for synchronization                                             │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# bridge/webrtc/core.py

from aiortc import (
    RTCPeerConnection,
    RTCSessionDescription,
    RTCIceCandidate,
    RTCConfiguration,
    RTCIceServer,
    MediaStreamTrack,
)
from aiortc.contrib.media import MediaPlayer, MediaRecorder
from aiortc.mediastreams import AudioStreamTrack
import av

# Key aiortc classes we use:

# RTCPeerConnection - Main WebRTC connection object
# RTCSessionDescription - SDP offer/answer
# RTCIceCandidate - ICE candidate for connectivity
# RTCConfiguration - STUN/TURN server config
# MediaStreamTrack - Base class for audio/video tracks
# AudioStreamTrack - Audio-specific track implementation

┌─────────────────────────────────────────────────────────────────────────────┐
│                    RTCPeerConnection STATE MACHINE                          │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│                              ┌─────────┐                                    │
│                              │   new   │                                    │
│                              └────┬────┘                                    │
│                                   │                                         │
│                          createOffer() or                                   │
│                          setRemoteDescription()                             │
│                                   │                                         │
│                                   ▼                                         │
│                           ┌───────────────┐                                 │
│                           │  connecting   │                                 │
│                           └───────┬───────┘                                 │
│                                   │                                         │
│                          ICE + DTLS complete                                │
│                                   │                                         │
│                                   ▼                                         │
│                           ┌───────────────┐                                 │
│                           │   connected   │◀──────────┐                    │
│                           └───────┬───────┘           │                    │
│                                   │              ICE restart               │
│                          ICE disconnected             │                    │
│                                   │                   │                    │
│                                   ▼                   │                    │
│                          ┌────────────────┐           │                    │
│                          │  disconnected  │───────────┘                    │
│                          └────────┬───────┘                                │
│                                   │                                         │
│                          ICE failed or                                      │
│                          close() called                                     │
│                                   │                                         │
│                                   ▼                                         │
│                           ┌───────────────┐                                 │
│                           │    closed     │                                 │
│                           └───────────────┘                                 │
│                                                                             │
│   SIGNALING STATES:                                                         │
│   • stable - No offer/answer in progress                                   │
│   • have-local-offer - Local offer created, awaiting answer                │
│   • have-remote-offer - Remote offer received, need to answer              │
│   • have-local-pranswer - Local provisional answer                         │
│   • have-remote-pranswer - Remote provisional answer                       │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# bridge/webrtc/connection.py

import asyncio
from aiortc import (
    RTCPeerConnection,
    RTCConfiguration,
    RTCIceServer,
)
from dataclasses import dataclass
from typing import Optional, Callable, List

@dataclass
class WebRTCConfig:
    """Configuration for WebRTC connection."""
    stun_servers: List[str] = None
    turn_servers: List[dict] = None
    ice_transport_policy: str = "all"  # "all" or "relay"
    bundle_policy: str = "max-bundle"
    
    def __post_init__(self):
        if self.stun_servers is None:
            self.stun_servers = [
                "stun:stun.l.google.com:19302",
                "stun:stun1.l.google.com:19302",
            ]

class WebRTCConnection:
    """
    Wrapper around aiortc RTCPeerConnection.
    
    Provides a simplified interface for managing
    WebRTC connections with proper lifecycle handling.
    """
    
    def __init__(
        self,
        config: WebRTCConfig = None,
        call_id: str = None,
    ):
        self.config = config or WebRTCConfig()
        self.call_id = call_id
        
        self._pc: Optional[RTCPeerConnection] = None
        self._local_tracks: List[MediaStreamTrack] = []
        self._remote_tracks: List[MediaStreamTrack] = []
        
        # Event handlers
        self.on_track: Optional[Callable] = None
        self.on_ice_candidate: Optional[Callable] = None
        self.on_connection_state_change: Optional[Callable] = None
        self.on_ice_connection_state_change: Optional[Callable] = None
    
    async def initialize(self) -> None:
        """Initialize the peer connection."""
        ice_servers = self._build_ice_servers()
        
        rtc_config = RTCConfiguration(
            iceServers=ice_servers,
            iceTransportPolicy=self.config.ice_transport_policy,
            bundlePolicy=self.config.bundle_policy,
        )
        
        self._pc = RTCPeerConnection(configuration=rtc_config)
        
        # Set up event handlers
        self._pc.on("track", self._handle_track)
        self._pc.on("icecandidate", self._handle_ice_candidate)
        self._pc.on("connectionstatechange", self._handle_connection_state_change)
        self._pc.on("iceconnectionstatechange", self._handle_ice_connection_state_change)
        
        logger.info(f"[{self.call_id}] WebRTC connection initialized")
    
    def _build_ice_servers(self) -> List[RTCIceServer]:
        """Build ICE server configuration."""
        servers = []
        
        # Add STUN servers
        for url in self.config.stun_servers:
            servers.append(RTCIceServer(urls=[url]))
        
        # Add TURN servers
        if self.config.turn_servers:
            for turn in self.config.turn_servers:
                servers.append(RTCIceServer(
                    urls=[turn["url"]],
                    username=turn.get("username"),
                    credential=turn.get("credential"),
                ))
        
        return servers
    
    async def add_track(self, track: MediaStreamTrack) -> None:
        """Add a local track to the connection."""
        if self._pc:
            self._pc.addTrack(track)
            self._local_tracks.append(track)
            logger.debug(f"[{self.call_id}] Added track: {track.kind}")
    
    async def create_offer(self) -> str:
        """Create an SDP offer."""
        if not self._pc:
            raise RuntimeError("Connection not initialized")
        
        offer = await self._pc.createOffer()
        await self._pc.setLocalDescription(offer)
        
        logger.debug(f"[{self.call_id}] Created offer")
        return self._pc.localDescription.sdp
    
    async def create_answer(self) -> str:
        """Create an SDP answer."""
        if not self._pc:
            raise RuntimeError("Connection not initialized")
        
        answer = await self._pc.createAnswer()
        await self._pc.setLocalDescription(answer)
        
        logger.debug(f"[{self.call_id}] Created answer")
        return self._pc.localDescription.sdp
    
    async def set_remote_description(
        self,
        sdp: str,
        sdp_type: str,
    ) -> None:
        """Set the remote SDP description."""
        if not self._pc:
            raise RuntimeError("Connection not initialized")
        
        description = RTCSessionDescription(sdp=sdp, type=sdp_type)
        await self._pc.setRemoteDescription(description)
        
        logger.debug(f"[{self.call_id}] Set remote description: {sdp_type}")
    
    async def add_ice_candidate(
        self,
        candidate: str,
        sdp_mid: str,
        sdp_mline_index: int,
    ) -> None:
        """Add a remote ICE candidate."""
        if not self._pc:
            raise RuntimeError("Connection not initialized")
        
        ice_candidate = RTCIceCandidate(
            candidate=candidate,
            sdpMid=sdp_mid,
            sdpMLineIndex=sdp_mline_index,
        )
        
        await self._pc.addIceCandidate(ice_candidate)
        logger.debug(f"[{self.call_id}] Added ICE candidate")
    
    async def close(self) -> None:
        """Close the connection."""
        if self._pc:
            await self._pc.close()
            self._pc = None
        
        # Stop local tracks
        for track in self._local_tracks:
            track.stop()
        
        self._local_tracks.clear()
        self._remote_tracks.clear()
        
        logger.info(f"[{self.call_id}] WebRTC connection closed")
    
    # Event handlers
    
    def _handle_track(self, track: MediaStreamTrack) -> None:
        """Handle incoming track."""
        logger.info(f"[{self.call_id}] Received track: {track.kind}")
        self._remote_tracks.append(track)
        
        if self.on_track:
            asyncio.create_task(self.on_track(track))
    
    def _handle_ice_candidate(self, candidate: RTCIceCandidate) -> None:
        """Handle local ICE candidate."""
        if candidate and self.on_ice_candidate:
            asyncio.create_task(self.on_ice_candidate(candidate))
    
    def _handle_connection_state_change(self) -> None:
        """Handle connection state change."""
        state = self._pc.connectionState if self._pc else "closed"
        logger.info(f"[{self.call_id}] Connection state: {state}")
        
        if self.on_connection_state_change:
            asyncio.create_task(self.on_connection_state_change(state))
    
    def _handle_ice_connection_state_change(self) -> None:
        """Handle ICE connection state change."""
        state = self._pc.iceConnectionState if self._pc else "closed"
        logger.info(f"[{self.call_id}] ICE state: {state}")
        
        if self.on_ice_connection_state_change:
            asyncio.create_task(self.on_ice_connection_state_change(state))
    
    # Properties
    
    @property
    def connection_state(self) -> str:
        """Get current connection state."""
        return self._pc.connectionState if self._pc else "closed"
    
    @property
    def ice_connection_state(self) -> str:
        """Get current ICE connection state."""
        return self._pc.iceConnectionState if self._pc else "closed"
    
    @property
    def signaling_state(self) -> str:
        """Get current signaling state."""
        return self._pc.signalingState if self._pc else "closed"

# bridge/webrtc/tracks.py

import asyncio
import fractions
import time
from typing import Optional
from aiortc import MediaStreamTrack
from av import AudioFrame
import numpy as np

class AudioTrackSink(MediaStreamTrack):
    """
    Audio track that receives frames from a WebRTC peer.
    
    Captures incoming audio and makes it available
    for processing by the voice pipeline.
    """
    
    kind = "audio"
    
    def __init__(
        self,
        track: MediaStreamTrack,
        on_frame: callable = None,
    ):
        super().__init__()
        self._track = track
        self.on_frame = on_frame
        self._running = True
    
    async def recv(self) -> AudioFrame:
        """Receive and process audio frames."""
        frame = await self._track.recv()
        
        if self.on_frame and self._running:
            await self.on_frame(frame)
        
        return frame
    
    def stop(self) -> None:
        """Stop receiving frames."""
        self._running = False
        super().stop()


class AudioTrackSource(MediaStreamTrack):
    """
    Audio track that generates frames for a WebRTC peer.
    
    Receives audio from the voice pipeline and sends
    it to the remote peer.
    """
    
    kind = "audio"
    
    def __init__(
        self,
        sample_rate: int = 48000,
        channels: int = 1,
        samples_per_frame: int = 960,  # 20ms at 48kHz
    ):
        super().__init__()
        
        self.sample_rate = sample_rate
        self.channels = channels
        self.samples_per_frame = samples_per_frame
        
        # Frame timing
        self._frame_duration = samples_per_frame / sample_rate
        self._start_time: Optional[float] = None
        self._frame_count = 0
        
        # Audio buffer
        self._queue: asyncio.Queue[np.ndarray] = asyncio.Queue(maxsize=50)
        
        # Silence frame for when buffer is empty
        self._silence = np.zeros(
            (samples_per_frame, channels),
            dtype=np.int16,
        )
    
    async def recv(self) -> AudioFrame:
        """Generate the next audio frame."""
        # Initialize timing on first frame
        if self._start_time is None:
            self._start_time = time.time()
        
        # Calculate expected time for this frame
        expected_time = self._start_time + (self._frame_count * self._frame_duration)
        
        # Wait until it's time to send this frame
        now = time.time()
        if now < expected_time:
            await asyncio.sleep(expected_time - now)
        
        # Get audio data from queue or use silence
        try:
            audio_data = self._queue.get_nowait()
        except asyncio.QueueEmpty:
            audio_data = self._silence
        
        # Create AudioFrame
        frame = AudioFrame(
            format="s16",
            layout="mono" if self.channels == 1 else "stereo",
            samples=self.samples_per_frame,
        )
        
        # Set frame data
        frame.planes[0].update(audio_data.tobytes())
        frame.sample_rate = self.sample_rate
        frame.pts = self._frame_count * self.samples_per_frame
        frame.time_base = fractions.Fraction(1, self.sample_rate)
        
        self._frame_count += 1
        
        return frame
    
    async def push_audio(self, audio_data: np.ndarray) -> None:
        """
        Push audio data to be sent.
        
        Args:
            audio_data: Audio samples as numpy array (int16)
        """
        try:
            self._queue.put_nowait(audio_data)
        except asyncio.QueueFull:
            # Drop oldest frame
            try:
                self._queue.get_nowait()
                self._queue.put_nowait(audio_data)
            except asyncio.QueueEmpty:
                pass
    
    def clear_buffer(self) -> None:
        """Clear the audio buffer."""
        while not self._queue.empty():
            try:
                self._queue.get_nowait()
            except asyncio.QueueEmpty:
                break
    
    def stop(self) -> None:
        """Stop the track."""
        self.clear_buffer()
        super().stop()

┌─────────────────────────────────────────────────────────────────────────────┐
│                           SDP STRUCTURE                                     │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   SESSION LEVEL (v=, o=, s=, t=)                                           │
│   ├── Protocol version                                                      │
│   ├── Origin (session ID, username)                                        │
│   ├── Session name                                                          │
│   └── Timing (start/stop time)                                             │
│                                                                             │
│   MEDIA LEVEL (m=, c=, a=)                                                 │
│   ├── Media type (audio/video)                                             │
│   ├── Port number                                                           │
│   ├── Protocol (UDP/TLS/RTP/SAVPF)                                         │
│   ├── Format list (payload types)                                          │
│   ├── Connection info (IP address)                                         │
│   └── Attributes                                                            │
│       ├── rtpmap (codec mapping)                                           │
│       ├── fmtp (format parameters)                                         │
│       ├── ice-ufrag, ice-pwd (ICE credentials)                            │
│       ├── fingerprint (DTLS)                                               │
│       ├── setup (DTLS role)                                                │
│       ├── mid (media ID)                                                   │
│       ├── sendrecv/sendonly/recvonly                                       │
│       └── candidate (ICE candidates)                                       │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    SDP OFFER/ANSWER FLOW                                    │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   INBOUND CALL (GoTo initiates):                                           │
│   ─────────────────────────────                                             │
│                                                                             │
│   GoToConnect                     Bridge                                    │
│        │                            │                                       │
│        │  1. Webhook: call.ringing  │                                       │
│        │────────────────────────────▶                                       │
│        │                            │                                       │
│        │  2. POST /calls/{id}/answer│                                       │
│        │◀────────────────────────────                                       │
│        │                            │                                       │
│        │  3. SDP Offer              │                                       │
│        │────────────────────────────▶                                       │
│        │                            │  4. Parse offer                       │
│        │                            │  5. Create answer                     │
│        │                            │                                       │
│        │  6. SDP Answer             │                                       │
│        │◀────────────────────────────                                       │
│        │                            │                                       │
│        │  7. ICE Candidates         │                                       │
│        │◀───────────────────────────▶  (trickle ICE)                       │
│        │                            │                                       │
│        │  8. Media flows            │                                       │
│        │◀═══════════════════════════▶                                       │
│        │                            │                                       │
│                                                                             │
│   OUTBOUND CALL (Bridge initiates):                                         │
│   ─────────────────────────────────                                         │
│                                                                             │
│   GoToConnect                     Bridge                                    │
│        │                            │                                       │
│        │  1. POST /calls            │                                       │
│        │     (with SDP offer)       │                                       │
│        │◀────────────────────────────                                       │
│        │                            │                                       │
│        │  2. 200 OK with SDP answer │                                       │
│        │────────────────────────────▶                                       │
│        │                            │                                       │
│        │  3. ICE Candidates         │                                       │
│        │◀───────────────────────────▶                                       │
│        │                            │                                       │
│        │  4. Media flows            │                                       │
│        │◀═══════════════════════════▶                                       │
│        │                            │                                       │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# bridge/webrtc/sdp_negotiator.py

import re
from dataclasses import dataclass, field
from typing import List, Optional, Dict
from enum import Enum

class SDPType(Enum):
    OFFER = "offer"
    ANSWER = "answer"
    PRANSWER = "pranswer"

@dataclass
class CodecInfo:
    """Information about a codec in SDP."""
    payload_type: int
    name: str
    clock_rate: int
    channels: int = 1
    fmtp: Optional[str] = None

@dataclass
class MediaDescription:
    """Parsed media section from SDP."""
    media_type: str  # audio, video
    port: int
    protocol: str
    formats: List[int]
    codecs: List[CodecInfo] = field(default_factory=list)
    direction: str = "sendrecv"
    ice_ufrag: Optional[str] = None
    ice_pwd: Optional[str] = None
    fingerprint: Optional[str] = None
    setup: Optional[str] = None
    mid: Optional[str] = None
    candidates: List[str] = field(default_factory=list)

@dataclass
class ParsedSDP:
    """Fully parsed SDP."""
    version: int
    origin: str
    session_name: str
    timing: str
    media: List[MediaDescription] = field(default_factory=list)
    ice_ufrag: Optional[str] = None
    ice_pwd: Optional[str] = None
    fingerprint: Optional[str] = None
    groups: List[str] = field(default_factory=list)

class SDPNegotiator:
    """
    Handles SDP parsing, modification, and generation.
    
    Manages codec negotiation and ensures compatibility
    between GoToConnect and our WebRTC implementation.
    """
    
    # Preferred codecs in order
    PREFERRED_AUDIO_CODECS = [
        ("opus", 48000, 2),    # Opus stereo
        ("PCMU", 8000, 1),     # G.711 μ-law
        ("PCMA", 8000, 1),     # G.711 A-law
    ]
    
    def __init__(self):
        self._local_ice_ufrag: Optional[str] = None
        self._local_ice_pwd: Optional[str] = None
    
    def parse_sdp(self, sdp: str) -> ParsedSDP:
        """
        Parse an SDP string into structured data.
        
        Args:
            sdp: Raw SDP string
        
        Returns:
            Parsed SDP structure
        """
        lines = sdp.strip().split('\r\n')
        if not lines[0].startswith('v='):
            lines = sdp.strip().split('\n')
        
        parsed = ParsedSDP(
            version=0,
            origin="",
            session_name="",
            timing="",
        )
        
        current_media: Optional[MediaDescription] = None
        
        for line in lines:
            if not line or '=' not in line:
                continue
            
            key, value = line[0], line[2:]
            
            # Session-level attributes
            if key == 'v':
                parsed.version = int(value)
            elif key == 'o':
                parsed.origin = value
            elif key == 's':
                parsed.session_name = value
            elif key == 't':
                parsed.timing = value
            elif key == 'm':
                # New media section
                if current_media:
                    parsed.media.append(current_media)
                current_media = self._parse_media_line(value)
            elif key == 'a' and current_media:
                # Media-level attribute
                self._parse_attribute(current_media, value)
            elif key == 'a':
                # Session-level attribute
                self._parse_session_attribute(parsed, value)
        
        if current_media:
            parsed.media.append(current_media)
        
        return parsed
    
    def _parse_media_line(self, value: str) -> MediaDescription:
        """Parse m= line."""
        parts = value.split()
        media_type = parts[0]
        port = int(parts[1])
        protocol = parts[2]
        formats = [int(f) for f in parts[3:]]
        
        return MediaDescription(
            media_type=media_type,
            port=port,
            protocol=protocol,
            formats=formats,
        )
    
    def _parse_attribute(
        self,
        media: MediaDescription,
        value: str,
    ) -> None:
        """Parse media-level attribute."""
        if value.startswith("rtpmap:"):
            codec = self._parse_rtpmap(value[7:])
            if codec:
                media.codecs.append(codec)
        elif value.startswith("fmtp:"):
            self._parse_fmtp(media, value[5:])
        elif value.startswith("ice-ufrag:"):
            media.ice_ufrag = value[10:]
        elif value.startswith("ice-pwd:"):
            media.ice_pwd = value[8:]
        elif value.startswith("fingerprint:"):
            media.fingerprint = value[12:]
        elif value.startswith("setup:"):
            media.setup = value[6:]
        elif value.startswith("mid:"):
            media.mid = value[4:]
        elif value.startswith("candidate:"):
            media.candidates.append(value)
        elif value in ("sendrecv", "sendonly", "recvonly", "inactive"):
            media.direction = value
    
    def _parse_session_attribute(
        self,
        parsed: ParsedSDP,
        value: str,
    ) -> None:
        """Parse session-level attribute."""
        if value.startswith("ice-ufrag:"):
            parsed.ice_ufrag = value[10:]
        elif value.startswith("ice-pwd:"):
            parsed.ice_pwd = value[8:]
        elif value.startswith("fingerprint:"):
            parsed.fingerprint = value[12:]
        elif value.startswith("group:"):
            parsed.groups.append(value[6:])
    
    def _parse_rtpmap(self, value: str) -> Optional[CodecInfo]:
        """Parse rtpmap attribute."""
        match = re.match(r'(\d+)\s+(\w+)/(\d+)(?:/(\d+))?', value)
        if match:
            return CodecInfo(
                payload_type=int(match.group(1)),
                name=match.group(2),
                clock_rate=int(match.group(3)),
                channels=int(match.group(4)) if match.group(4) else 1,
            )
        return None
    
    def _parse_fmtp(
        self,
        media: MediaDescription,
        value: str,
    ) -> None:
        """Parse fmtp attribute and attach to codec."""
        parts = value.split(' ', 1)
        if len(parts) == 2:
            payload_type = int(parts[0])
            for codec in media.codecs:
                if codec.payload_type == payload_type:
                    codec.fmtp = parts[1]
                    break
    
    def negotiate_codecs(
        self,
        offered: List[CodecInfo],
    ) -> List[CodecInfo]:
        """
        Negotiate codecs from an offer.
        
        Returns codecs in our preferred order that are
        also supported by the remote peer.
        """
        negotiated = []
        
        for pref_name, pref_rate, pref_channels in self.PREFERRED_AUDIO_CODECS:
            for offered_codec in offered:
                if (offered_codec.name.lower() == pref_name.lower() and
                    offered_codec.clock_rate == pref_rate):
                    negotiated.append(offered_codec)
                    break
        
        return negotiated
    
    def generate_answer(
        self,
        offer: ParsedSDP,
        local_fingerprint: str,
        local_ice_ufrag: str,
        local_ice_pwd: str,
    ) -> str:
        """
        Generate an SDP answer for an offer.
        
        Args:
            offer: Parsed SDP offer
            local_fingerprint: Our DTLS fingerprint
            local_ice_ufrag: Our ICE username fragment
            local_ice_pwd: Our ICE password
        
        Returns:
            SDP answer string
        """
        lines = [
            "v=0",
            f"o=- {int(time.time())} 1 IN IP4 0.0.0.0",
            "s=-",
            "t=0 0",
        ]
        
        # Session-level attributes
        if offer.groups:
            for group in offer.groups:
                lines.append(f"a=group:{group}")
        
        lines.append("a=msid-semantic: WMS *")
        
        # Generate media sections
        for media in offer.media:
            if media.media_type == "audio":
                media_lines = self._generate_audio_answer(
                    media,
                    local_fingerprint,
                    local_ice_ufrag,
                    local_ice_pwd,
                )
                lines.extend(media_lines)
        
        return '\r\n'.join(lines) + '\r\n'
    
    def _generate_audio_answer(
        self,
        offer_media: MediaDescription,
        fingerprint: str,
        ice_ufrag: str,
        ice_pwd: str,
    ) -> List[str]:
        """Generate audio media section for answer."""
        # Negotiate codecs
        negotiated = self.negotiate_codecs(offer_media.codecs)
        
        if not negotiated:
            raise ValueError("No compatible audio codecs found")
        
        # Build format list
        formats = [str(c.payload_type) for c in negotiated]
        
        lines = [
            f"m=audio 9 UDP/TLS/RTP/SAVPF {' '.join(formats)}",
            "c=IN IP4 0.0.0.0",
        ]
        
        # ICE credentials
        lines.append(f"a=ice-ufrag:{ice_ufrag}")
        lines.append(f"a=ice-pwd:{ice_pwd}")
        
        # DTLS
        lines.append(f"a=fingerprint:{fingerprint}")
        
        # Setup role (we're answering, so passive or active based on offer)
        if offer_media.setup == "actpass":
            lines.append("a=setup:active")
        elif offer_media.setup == "active":
            lines.append("a=setup:passive")
        else:
            lines.append("a=setup:active")
        
        # Media ID
        if offer_media.mid:
            lines.append(f"a=mid:{offer_media.mid}")
        
        # Direction (mirror the offer)
        lines.append(f"a={offer_media.direction}")
        
        # RTP/RTCP
        lines.append("a=rtcp-mux")
        
        # Codec descriptions
        for codec in negotiated:
            if codec.channels > 1:
                lines.append(
                    f"a=rtpmap:{codec.payload_type} "
                    f"{codec.name}/{codec.clock_rate}/{codec.channels}"
                )
            else:
                lines.append(
                    f"a=rtpmap:{codec.payload_type} "
                    f"{codec.name}/{codec.clock_rate}"
                )
            
            if codec.fmtp:
                lines.append(f"a=fmtp:{codec.payload_type} {codec.fmtp}")
        
        return lines
    
    def generate_offer(
        self,
        local_fingerprint: str,
        local_ice_ufrag: str,
        local_ice_pwd: str,
    ) -> str:
        """
        Generate an SDP offer for outbound calls.
        
        Args:
            local_fingerprint: Our DTLS fingerprint
            local_ice_ufrag: Our ICE username fragment
            local_ice_pwd: Our ICE password
        
        Returns:
            SDP offer string
        """
        lines = [
            "v=0",
            f"o=- {int(time.time())} 1 IN IP4 0.0.0.0",
            "s=-",
            "t=0 0",
            "a=group:BUNDLE 0",
            "a=msid-semantic: WMS *",
            
            # Audio media section
            "m=audio 9 UDP/TLS/RTP/SAVPF 111 0 8",
            "c=IN IP4 0.0.0.0",
            f"a=ice-ufrag:{local_ice_ufrag}",
            f"a=ice-pwd:{local_ice_pwd}",
            f"a=fingerprint:{local_fingerprint}",
            "a=setup:actpass",
            "a=mid:0",
            "a=sendrecv",
            "a=rtcp-mux",
            
            # Opus
            "a=rtpmap:111 opus/48000/2",
            "a=fmtp:111 minptime=10;useinbandfec=1",
            
            # G.711 μ-law
            "a=rtpmap:0 PCMU/8000",
            
            # G.711 A-law
            "a=rtpmap:8 PCMA/8000",
        ]
        
        return '\r\n'.join(lines) + '\r\n'


class SDPModifier:
    """
    Utilities for modifying existing SDP.
    """
    
    @staticmethod
    def add_candidate(sdp: str, candidate: str, mid: str) -> str:
        """Add an ICE candidate to SDP."""
        lines = sdp.split('\r\n')
        result = []
        in_target_media = False
        
        for line in lines:
            result.append(line)
            
            if line.startswith(f"a=mid:{mid}"):
                in_target_media = True
            elif line.startswith("m=") and in_target_media:
                in_target_media = False
            elif in_target_media and line.startswith("a=") and not line.startswith("a=candidate"):
                # Insert candidate before other attributes
                pass
        
        # Add candidate at end of media section
        result.insert(-1, f"a={candidate}")
        
        return '\r\n'.join(result)
    
    @staticmethod
    def set_direction(sdp: str, direction: str) -> str:
        """Set media direction in SDP."""
        directions = ["sendrecv", "sendonly", "recvonly", "inactive"]
        
        for d in directions:
            sdp = sdp.replace(f"a={d}", f"a={direction}")
        
        return sdp
    
    @staticmethod
    def remove_video(sdp: str) -> str:
        """Remove video media from SDP."""
        lines = sdp.split('\r\n')
        result = []
        skip_until_next_media = False
        
        for line in lines:
            if line.startswith("m=video"):
                skip_until_next_media = True
            elif line.startswith("m=") and skip_until_next_media:
                skip_until_next_media = False
                result.append(line)
            elif not skip_until_next_media:
                result.append(line)
        
        return '\r\n'.join(result)

# Example GoToConnect SDP Offer

v=0
o=- 7058047285456728323 2 IN IP4 127.0.0.1
s=-
t=0 0
a=group:BUNDLE 0
a=msid-semantic: WMS stream
m=audio 9 UDP/TLS/RTP/SAVPF 111 0 8
c=IN IP4 0.0.0.0
a=rtcp:9 IN IP4 0.0.0.0
a=ice-ufrag:abc123
a=ice-pwd:supersecretpassword12345678
a=fingerprint:sha-256 AB:CD:EF:12:34:56:78:90...
a=setup:actpass
a=mid:0
a=sendrecv
a=rtcp-mux
a=rtpmap:111 opus/48000/2
a=fmtp:111 minptime=10;useinbandfec=1
a=rtpmap:0 PCMU/8000
a=rtpmap:8 PCMA/8000
a=candidate:1 1 UDP 2122262783 192.168.1.100 54321 typ host
a=candidate:2 1 UDP 1686052863 203.0.113.50 54322 typ srflx raddr 192.168.1.100 rport 54321

# Example Bridge SDP Answer

v=0
o=- 1705408234 1 IN IP4 0.0.0.0
s=-
t=0 0
a=group:BUNDLE 0
a=msid-semantic: WMS *
m=audio 9 UDP/TLS/RTP/SAVPF 111 0
c=IN IP4 0.0.0.0
a=ice-ufrag:xyz789
a=ice-pwd:ouricecredentials12345678
a=fingerprint:sha-256 12:34:56:78:90:AB:CD:EF...
a=setup:active
a=mid:0
a=sendrecv
a=rtcp-mux
a=rtpmap:111 opus/48000/2
a=fmtp:111 minptime=10;useinbandfec=1
a=rtpmap:0 PCMU/8000

┌─────────────────────────────────────────────────────────────────────────────┐
│                         ICE CANDIDATE TYPES                                 │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   TYPE        PRIORITY    DESCRIPTION                                       │
│   ────────────────────────────────────────────────────────────────────     │
│                                                                             │
│   host        Highest     Direct local IP address                           │
│                           • 192.168.1.100:54321                            │
│                           • Best latency, works on same network            │
│                                                                             │
│   srflx       Medium      Server Reflexive (STUN-discovered public IP)     │
│                           • 203.0.113.50:54322                             │
│                           • Works across most NATs                          │
│                                                                             │
│   prflx       Medium      Peer Reflexive (discovered during ICE)           │
│                           • Dynamic discovery                               │
│                           • Found during connectivity checks               │
│                                                                             │
│   relay       Lowest      TURN relay server                                 │
│                           • turn.example.com:443                           │
│                           • Always works, but adds latency                 │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                       ICE CONNECTION PROCESS                                │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   GATHERING PHASE:                                                          │
│   ─────────────────                                                         │
│                                                                             │
│   1. Collect host candidates (local interfaces)                            │
│   2. Query STUN servers for srflx candidates                               │
│   3. Allocate TURN relay candidates (if configured)                        │
│   4. Send candidates to remote peer (trickle ICE)                          │
│                                                                             │
│   CONNECTIVITY CHECKING:                                                    │
│   ──────────────────────                                                    │
│                                                                             │
│   For each local/remote candidate pair:                                     │
│   1. Send STUN binding request                                             │
│   2. Await response                                                         │
│   3. Calculate round-trip time                                             │
│   4. Mark pair as succeeded/failed                                         │
│                                                                             │
│   NOMINATION:                                                               │
│   ───────────                                                               │
│                                                                             │
│   1. Rank successful pairs by priority                                     │
│   2. Controlling agent nominates best pair                                 │
│   3. Both sides switch to nominated pair                                   │
│                                                                             │
│                                                                             │
│   ┌─────────┐        ┌─────────┐        ┌─────────┐                       │
│   │  new    │───────▶│gathering│───────▶│checking │                       │
│   └─────────┘        └─────────┘        └────┬────┘                       │
│                                              │                             │
│                      ┌───────────────────────┼───────────────────────┐    │
│                      │                       │                       │    │
│                      ▼                       ▼                       ▼    │
│               ┌───────────┐          ┌───────────┐          ┌─────────┐  │
│               │ connected │          │disconnected│         │ failed  │  │
│               └───────────┘          └───────────┘          └─────────┘  │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# bridge/webrtc/ice_manager.py

import asyncio
from dataclasses import dataclass
from typing import Optional, List, Callable
from enum import Enum

class ICEGatheringState(Enum):
    NEW = "new"
    GATHERING = "gathering"
    COMPLETE = "complete"

class ICEConnectionState(Enum):
    NEW = "new"
    CHECKING = "checking"
    CONNECTED = "connected"
    COMPLETED = "completed"
    DISCONNECTED = "disconnected"
    FAILED = "failed"
    CLOSED = "closed"

@dataclass
class ICECandidate:
    """Parsed ICE candidate."""
    foundation: str
    component: int
    protocol: str
    priority: int
    ip: str
    port: int
    type: str  # host, srflx, prflx, relay
    related_address: Optional[str] = None
    related_port: Optional[int] = None
    tcp_type: Optional[str] = None
    
    @classmethod
    def parse(cls, candidate_str: str) -> "ICECandidate":
        """Parse ICE candidate string."""
        # candidate:foundation component protocol priority ip port typ type [extensions]
        parts = candidate_str.split()
        
        if parts[0].startswith("candidate:"):
            parts[0] = parts[0][10:]
        
        candidate = cls(
            foundation=parts[0],
            component=int(parts[1]),
            protocol=parts[2].upper(),
            priority=int(parts[3]),
            ip=parts[4],
            port=int(parts[5]),
            type=parts[7],
        )
        
        # Parse extensions
        i = 8
        while i < len(parts) - 1:
            if parts[i] == "raddr":
                candidate.related_address = parts[i + 1]
            elif parts[i] == "rport":
                candidate.related_port = int(parts[i + 1])
            elif parts[i] == "tcptype":
                candidate.tcp_type = parts[i + 1]
            i += 2
        
        return candidate
    
    def to_string(self) -> str:
        """Convert to SDP candidate string."""
        s = (
            f"candidate:{self.foundation} {self.component} "
            f"{self.protocol} {self.priority} "
            f"{self.ip} {self.port} typ {self.type}"
        )
        
        if self.related_address:
            s += f" raddr {self.related_address}"
        if self.related_port:
            s += f" rport {self.related_port}"
        if self.tcp_type:
            s += f" tcptype {self.tcp_type}"
        
        return s


class ICEManager:
    """
    Manages ICE candidate gathering and connectivity.
    
    Handles trickle ICE with GoToConnect, ensuring
    candidates are exchanged efficiently.
    """
    
    def __init__(
        self,
        call_id: str,
        goto_client: "GoToCallControlClient",
    ):
        self.call_id = call_id
        self.goto_client = goto_client
        
        # State
        self._gathering_state = ICEGatheringState.NEW
        self._connection_state = ICEConnectionState.NEW
        
        # Candidates
        self._local_candidates: List[ICECandidate] = []
        self._remote_candidates: List[ICECandidate] = []
        self._pending_remote: List[dict] = []
        
        # Event handlers
        self.on_gathering_state_change: Optional[Callable] = None
        self.on_connection_state_change: Optional[Callable] = None
        self.on_candidate: Optional[Callable] = None
        
        # Candidate buffering for trickle ICE
        self._candidate_buffer: List[dict] = []
        self._buffer_timer: Optional[asyncio.Task] = None
        self._buffer_delay = 0.1  # 100ms batching
    
    async def handle_local_candidate(
        self,
        candidate: "RTCIceCandidate",
    ) -> None:
        """
        Handle a locally gathered ICE candidate.
        
        Buffers candidates briefly to batch them for
        more efficient signaling.
        """
        if candidate is None:
            # Gathering complete
            await self._flush_candidates()
            self._gathering_state = ICEGatheringState.COMPLETE
            if self.on_gathering_state_change:
                await self.on_gathering_state_change(self._gathering_state)
            return
        
        parsed = ICECandidate.parse(candidate.candidate)
        self._local_candidates.append(parsed)
        
        # Buffer candidate
        self._candidate_buffer.append({
            "candidate": candidate.candidate,
            "sdpMid": candidate.sdpMid,
            "sdpMLineIndex": candidate.sdpMLineIndex,
        })
        
        # Start/reset buffer timer
        if self._buffer_timer:
            self._buffer_timer.cancel()
        
        self._buffer_timer = asyncio.create_task(
            self._flush_candidates_after_delay()
        )
        
        logger.debug(f"[{self.call_id}] Local candidate: {parsed.type} {parsed.ip}:{parsed.port}")
    
    async def _flush_candidates_after_delay(self) -> None:
        """Flush buffered candidates after delay."""
        await asyncio.sleep(self._buffer_delay)
        await self._flush_candidates()
    
    async def _flush_candidates(self) -> None:
        """Send buffered candidates to GoToConnect."""
        if not self._candidate_buffer:
            return
        
        candidates = self._candidate_buffer.copy()
        self._candidate_buffer.clear()
        
        try:
            for candidate in candidates:
                await self.goto_client.send_ice_candidate(
                    call_id=self.call_id,
                    candidate=candidate["candidate"],
                    sdp_mid=candidate["sdpMid"],
                    sdp_mline_index=candidate["sdpMLineIndex"],
                )
            
            logger.info(f"[{self.call_id}] Sent {len(candidates)} ICE candidates")
            
        except Exception as e:
            logger.error(f"[{self.call_id}] Failed to send ICE candidates: {e}")
    
    async def handle_remote_candidate(
        self,
        candidate_data: dict,
        pc: "RTCPeerConnection",
    ) -> None:
        """
        Handle a remote ICE candidate from GoToConnect.
        
        Args:
            candidate_data: Candidate data from event
            pc: PeerConnection to add candidate to
        """
        candidate_str = candidate_data.get("candidate")
        
        if not candidate_str:
            # End of candidates
            logger.info(f"[{self.call_id}] Remote ICE gathering complete")
            return
        
        try:
            parsed = ICECandidate.parse(candidate_str)
            self._remote_candidates.append(parsed)
            
            # Add to peer connection
            ice_candidate = RTCIceCandidate(
                candidate=candidate_str,
                sdpMid=candidate_data.get("sdpMid", "0"),
                sdpMLineIndex=candidate_data.get("sdpMLineIndex", 0),
            )
            
            await pc.addIceCandidate(ice_candidate)
            
            logger.debug(
                f"[{self.call_id}] Remote candidate: "
                f"{parsed.type} {parsed.ip}:{parsed.port}"
            )
            
        except Exception as e:
            logger.error(f"[{self.call_id}] Failed to add remote candidate: {e}")
    
    def update_connection_state(self, state: str) -> None:
        """Update ICE connection state."""
        try:
            self._connection_state = ICEConnectionState(state)
        except ValueError:
            self._connection_state = ICEConnectionState.NEW
        
        logger.info(f"[{self.call_id}] ICE connection state: {state}")
        
        if self.on_connection_state_change:
            asyncio.create_task(
                self.on_connection_state_change(self._connection_state)
            )
    
    @property
    def is_connected(self) -> bool:
        """Check if ICE is connected."""
        return self._connection_state in (
            ICEConnectionState.CONNECTED,
            ICEConnectionState.COMPLETED,
        )
    
    @property
    def local_candidates(self) -> List[ICECandidate]:
        """Get gathered local candidates."""
        return self._local_candidates.copy()
    
    @property
    def remote_candidates(self) -> List[ICECandidate]:
        """Get received remote candidates."""
        return self._remote_candidates.copy()


class ICERestartManager:
    """
    Handles ICE restart scenarios.
    
    ICE restart is needed when connectivity is lost
    but the call should continue.
    """
    
    def __init__(
        self,
        ice_manager: ICEManager,
        pc: "RTCPeerConnection",
    ):
        self.ice_manager = ice_manager
        self.pc = pc
        
        self._restart_count = 0
        self._max_restarts = 3
        self._restart_cooldown = 5.0  # seconds
        self._last_restart: Optional[float] = None
    
    async def check_and_restart(self) -> bool:
        """
        Check if ICE restart is needed and perform it.
        
        Returns:
            True if restart was performed
        """
        if not self._should_restart():
            return False
        
        if self._restart_count >= self._max_restarts:
            logger.warning(
                f"[{self.ice_manager.call_id}] "
                f"Max ICE restarts ({self._max_restarts}) reached"
            )
            return False
        
        # Check cooldown
        if self._last_restart:
            elapsed = time.time() - self._last_restart
            if elapsed < self._restart_cooldown:
                return False
        
        await self._perform_restart()
        return True
    
    def _should_restart(self) -> bool:
        """Determine if ICE restart is needed."""
        state = self.ice_manager._connection_state
        return state in (
            ICEConnectionState.DISCONNECTED,
            ICEConnectionState.FAILED,
        )
    
    async def _perform_restart(self) -> None:
        """Perform ICE restart."""
        logger.info(f"[{self.ice_manager.call_id}] Performing ICE restart")
        
        self._restart_count += 1
        self._last_restart = time.time()
        
        # Create new offer with ice-restart
        offer = await self.pc.createOffer(iceRestart=True)
        await self.pc.setLocalDescription(offer)
        
        # Send to GoToConnect
        # (Implementation depends on GoTo API)
        
        logger.info(
            f"[{self.ice_manager.call_id}] "
            f"ICE restart initiated (attempt {self._restart_count})"
        )

┌─────────────────────────────────────────────────────────────────────────────┐
│                        TRICKLE ICE FLOW                                     │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   Bridge                              GoToConnect                           │
│      │                                     │                                │
│      │  SDP Offer (no candidates)          │                                │
│      │────────────────────────────────────▶│                                │
│      │                                     │                                │
│      │  SDP Answer (no candidates)         │                                │
│      │◀────────────────────────────────────│                                │
│      │                                     │                                │
│      │                                     │  Start gathering               │
│      │  Start gathering                    │                                │
│      │                                     │                                │
│      │  candidate (host)                   │                                │
│      │────────────────────────────────────▶│                                │
│      │                                     │                                │
│      │                    candidate (host) │                                │
│      │◀────────────────────────────────────│                                │
│      │                                     │                                │
│      │  candidate (srflx)                  │                                │
│      │────────────────────────────────────▶│                                │
│      │                                     │                                │
│      │                   candidate (srflx) │                                │
│      │◀────────────────────────────────────│                                │
│      │                                     │                                │
│      │  end-of-candidates                  │                                │
│      │────────────────────────────────────▶│                                │
│      │                                     │                                │
│      │               end-of-candidates     │                                │
│      │◀────────────────────────────────────│                                │
│      │                                     │                                │
│      │  ═══════ ICE Connected ═══════════  │                                │
│      │                                     │                                │
│      │  ═══════ Media Flowing ═══════════  │                                │
│      │                                     │                                │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                       AUDIO FRAME STRUCTURE                                 │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   FRAME PARAMETERS:                                                         │
│   ─────────────────                                                         │
│                                                                             │
│   Sample Rate:     8000 Hz (G.711) / 48000 Hz (Opus)                       │
│   Bit Depth:       16-bit signed integer (PCM)                             │
│   Channels:        1 (mono) or 2 (stereo)                                  │
│   Frame Duration:  10ms, 20ms, 40ms, or 60ms                               │
│                                                                             │
│   SAMPLES PER FRAME:                                                        │
│   ──────────────────                                                        │
│                                                                             │
│   │ Duration │ 8kHz  │ 16kHz │ 48kHz │                                     │
│   │──────────│───────│───────│───────│                                     │
│   │ 10ms     │ 80    │ 160   │ 480   │                                     │
│   │ 20ms     │ 160   │ 320   │ 960   │  ◀── Most common                   │
│   │ 40ms     │ 320   │ 640   │ 1920  │                                     │
│   │ 60ms     │ 480   │ 960   │ 2880  │                                     │
│                                                                             │
│   FRAME SIZE IN BYTES (16-bit mono):                                        │
│   ──────────────────────────────────                                        │
│                                                                             │
│   │ Duration │ 8kHz  │ 16kHz │ 48kHz │                                     │
│   │──────────│───────│───────│───────│                                     │
│   │ 10ms     │ 160   │ 320   │ 960   │                                     │
│   │ 20ms     │ 320   │ 640   │ 1920  │                                     │
│   │ 40ms     │ 640   │ 1280  │ 3840  │                                     │
│   │ 60ms     │ 960   │ 1920  │ 5760  │                                     │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# bridge/audio/frames.py

import av
import numpy as np
from typing import Tuple
import fractions

class AudioFrameProcessor:
    """
    Utilities for working with PyAV AudioFrames.
    
    Handles conversion between AudioFrame and numpy arrays,
    as well as common audio manipulations.
    """
    
    @staticmethod
    def frame_to_numpy(frame: av.AudioFrame) -> np.ndarray:
        """
        Convert AudioFrame to numpy array.
        
        Args:
            frame: PyAV AudioFrame
        
        Returns:
            numpy array of shape (samples, channels)
        """
        # Get raw data from frame
        # frame.to_ndarray() returns shape (channels, samples)
        data = frame.to_ndarray()
        
        # Transpose to (samples, channels)
        if data.ndim == 2:
            data = data.T
        
        return data
    
    @staticmethod
    def numpy_to_frame(
        data: np.ndarray,
        sample_rate: int,
        pts: int = 0,
        format: str = "s16",
        layout: str = "mono",
    ) -> av.AudioFrame:
        """
        Convert numpy array to AudioFrame.
        
        Args:
            data: numpy array (samples,) or (samples, channels)
            sample_rate: Sample rate in Hz
            pts: Presentation timestamp
            format: Audio format (s16, s32, flt, etc.)
            layout: Channel layout (mono, stereo)
        
        Returns:
            PyAV AudioFrame
        """
        # Ensure 2D array
        if data.ndim == 1:
            data = data.reshape(-1, 1)
        
        samples = data.shape[0]
        channels = data.shape[1]
        
        # Determine layout
        if channels == 1:
            layout = "mono"
        elif channels == 2:
            layout = "stereo"
        
        # Create frame
        frame = av.AudioFrame(
            format=format,
            layout=layout,
            samples=samples,
        )
        
        # Set frame data
        # PyAV expects (channels, samples) for plane data
        frame.planes[0].update(data.T.tobytes())
        
        frame.sample_rate = sample_rate
        frame.pts = pts
        frame.time_base = fractions.Fraction(1, sample_rate)
        
        return frame
    
    @staticmethod
    def get_frame_info(frame: av.AudioFrame) -> dict:
        """Get information about an audio frame."""
        return {
            "samples": frame.samples,
            "sample_rate": frame.sample_rate,
            "channels": len(frame.layout.channels),
            "format": frame.format.name,
            "pts": frame.pts,
            "duration_ms": (frame.samples / frame.sample_rate) * 1000,
            "size_bytes": sum(len(p) for p in frame.planes),
        }
    
    @staticmethod
    def normalize_frame(
        frame: av.AudioFrame,
        target_format: str = "s16",
        target_layout: str = "mono",
        target_rate: int = None,
    ) -> av.AudioFrame:
        """
        Normalize frame to target format.
        
        Args:
            frame: Input frame
            target_format: Target sample format
            target_layout: Target channel layout
            target_rate: Target sample rate (None to keep original)
        
        Returns:
            Normalized frame
        """
        resampler = av.AudioResampler(
            format=target_format,
            layout=target_layout,
            rate=target_rate or frame.sample_rate,
        )
        
        return resampler.resample(frame)[0]


class AudioBuffer:
    """
    Ring buffer for audio frames.
    
    Provides smooth audio flow by buffering frames
    and handling timing variations.
    """
    
    def __init__(
        self,
        max_duration_ms: float = 500,
        sample_rate: int = 48000,
        channels: int = 1,
    ):
        self.sample_rate = sample_rate
        self.channels = channels
        
        # Calculate buffer size
        max_samples = int(sample_rate * max_duration_ms / 1000)
        self._buffer = np.zeros((max_samples, channels), dtype=np.int16)
        
        self._write_pos = 0
        self._read_pos = 0
        self._available = 0
        self._lock = asyncio.Lock()
    
    async def write(self, data: np.ndarray) -> int:
        """
        Write audio data to buffer.
        
        Args:
            data: Audio samples (samples, channels)
        
        Returns:
            Number of samples written
        """
        async with self._lock:
            samples = data.shape[0]
            buffer_size = self._buffer.shape[0]
            
            # Check available space
            space = buffer_size - self._available
            if samples > space:
                # Buffer full - drop oldest data
                drop = samples - space
                self._read_pos = (self._read_pos + drop) % buffer_size
                self._available -= drop
            
            # Write data
            end_pos = self._write_pos + samples
            
            if end_pos <= buffer_size:
                self._buffer[self._write_pos:end_pos] = data
            else:
                # Wrap around
                first_part = buffer_size - self._write_pos
                self._buffer[self._write_pos:] = data[:first_part]
                self._buffer[:end_pos - buffer_size] = data[first_part:]
            
            self._write_pos = end_pos % buffer_size
            self._available += samples
            
            return samples
    
    async def read(self, samples: int) -> np.ndarray:
        """
        Read audio data from buffer.
        
        Args:
            samples: Number of samples to read
        
        Returns:
            Audio data or silence if not enough available
        """
        async with self._lock:
            buffer_size = self._buffer.shape[0]
            
            if self._available < samples:
                # Not enough data - return silence
                return np.zeros((samples, self.channels), dtype=np.int16)
            
            # Read data
            end_pos = self._read_pos + samples
            
            if end_pos <= buffer_size:
                data = self._buffer[self._read_pos:end_pos].copy()
            else:
                # Wrap around
                first_part = buffer_size - self._read_pos
                data = np.concatenate([
                    self._buffer[self._read_pos:],
                    self._buffer[:end_pos - buffer_size],
                ])
            
            self._read_pos = end_pos % buffer_size
            self._available -= samples
            
            return data
    
    @property
    def available_samples(self) -> int:
        """Number of samples available to read."""
        return self._available
    
    @property
    def available_ms(self) -> float:
        """Duration of audio available in milliseconds."""
        return (self._available / self.sample_rate) * 1000
    
    def clear(self) -> None:
        """Clear the buffer."""
        self._write_pos = 0
        self._read_pos = 0
        self._available = 0