/**
 * MediaStreamHandler
 *
 * Manages MediaStream connections including:
 * - Stream setup for sending/receiving media
 * - Track lifecycle management (add/remove)
 * - Frame activity monitoring for stale connection detection
 * - Persistent stream abstraction across reconnections
 */

import { PeerConnectionManager, PeerConnectionManagerOptions } from './peer-connection-manager';
import {
  IceServersProvider,
  TwinTransport,
  TurnServerConfig,
  PhygridMediaStream,
  MediaStreamOptions,
  MediaTrackKind,
  MissingMediaTrackError,
  PeerConnectionConfig,
  ExtendedMediaStreamTrack,
  SignalingSink,
} from './types';
import { DEFAULT_WEBRTC_OPTIONS } from './webrtc-manager';

const FRAME_INACTIVITY_TIMEOUT = 5000; // 5 seconds without frames = stale

// Liveness backstop for a SENDONLY peer (a responder serving media to a viewer).
// Such a peer receives no media, so the frame monitor never runs; and
// @roamhq/wrtc does not reliably transition pc.connectionState when the remote
// viewer silently vanishes (page reload/crash). We instead watch inbound
// transport activity via getStats — a live remote keeps sending STUN consent +
// RTCP back, so a prolonged freeze means it's gone.
const OUTBOUND_LIVENESS_CHECK_INTERVAL_MS = 5000;
const OUTBOUND_STALE_TIMEOUT_MS = 20000; // inbound silent this long ⇒ remote gone

export interface MediaStreamHandlerOptions extends Partial<PeerConnectionManagerOptions> {
  /** Use STUN servers. Default: true */
  useStun?: boolean;

  /** STUN server URLs */
  stunServers?: string[];

  /** TURN server configs for relay fallback */
  turnServers?: TurnServerConfig[];

  /** ICE transport policy. Default: 'all' */
  iceTransportPolicy?: RTCIceTransportPolicy;

  /** Optional async source for the full ICE server list. See WebRTCManagerOptions.iceServersProvider. */
  iceServersProvider?: IceServersProvider;

  /** Media options */
  mediaOptions?: MediaStreamOptions;

  /** Per-session peer id (responder fan-out: the peer this handler serves). */
  peerId?: string;

  /**
   * When true, signaling is owned by an external dispatcher (responder fan-out)
   * which feeds messages via ingestSignalingMessage(). See PeerConnectionConfig.
   */
  selfManagedSignaling?: boolean;

  /**
   * When set, this peer's outbound answer/ice is handed to the sink instead of
   * published to the transport (one-shot HTTP-signaled answer). See
   * PeerConnectionConfig.signalingSink.
   */
  signalingSink?: SignalingSink;
}

export class MediaStreamHandler {
  private targetTwinId: string;
  private channelName: string;
  private isInitiator: boolean;
  private transport: TwinTransport;
  private options: Required<
    Omit<
      MediaStreamHandlerOptions,
      'mediaOptions' | 'peerId' | 'selfManagedSignaling' | 'iceServersProvider' | 'signalingSink'
    >
  > & {
    mediaOptions: MediaStreamOptions;
  };
  private peerId?: string;
  private selfManagedSignaling: boolean;
  private iceServersProvider?: IceServersProvider;
  private signalingSink?: SignalingSink;

  private pcManager: PeerConnectionManager | null = null;
  private remoteStream: MediaStream | null = null;
  private localStream: MediaStream | null = null;
  private isClosed = false;
  private isReceiving = false;
  private isConnecting = false;

  // Track management
  private tracks: MediaStreamTrack[] = [];
  private trackLastFrameTime: Map<string, number> = new Map();
  private frameActivityInterval: NodeJS.Timeout | null = null;

  // Outbound (sendonly) liveness backstop state
  private outboundLivenessInterval: NodeJS.Timeout | null = null;
  private lastInboundTotal = 0;
  private lastInboundProgressAt = 0;
  private everReceivedInbound = false;

  // Event listeners
  private trackListeners: Set<(track: MediaStreamTrack) => void> = new Set();
  private frameListeners: Set<(frameData: any) => void> = new Set();
  private closeListeners: Set<() => void> = new Set();

  // Callbacks for WebRTCManager
  private onConnectedCallback?: () => void;
  private onDisconnectedCallback?: () => void;
  private onErrorCallback?: (error: Error) => void;
  private onReconnectingCallback?: (attempt: number) => void;
  private onReconnectedCallback?: (attempt: number) => void;

  // Guard against duplicate connect() calls (e.g. React StrictMode double-effect)
  private connectPromise: Promise<PhygridMediaStream> | null = null;

  constructor(
    targetTwinId: string,
    isInitiator: boolean,
    transport: TwinTransport,
    options: MediaStreamHandlerOptions = {},
    channelName: string = 'default',
  ) {
    this.targetTwinId = targetTwinId;
    this.channelName = channelName;
    this.isInitiator = isInitiator;
    this.transport = transport;
    this.options = {
      useStun: options.useStun ?? DEFAULT_WEBRTC_OPTIONS.useStun,
      stunServers: options.stunServers ?? DEFAULT_WEBRTC_OPTIONS.stunServers,
      turnServers: options.turnServers ?? DEFAULT_WEBRTC_OPTIONS.turnServers,
      iceTransportPolicy: options.iceTransportPolicy ?? DEFAULT_WEBRTC_OPTIONS.iceTransportPolicy,
      connectionTimeout: options.connectionTimeout ?? DEFAULT_WEBRTC_OPTIONS.connectionTimeout,
      initialRetryDelay: options.initialRetryDelay ?? DEFAULT_WEBRTC_OPTIONS.initialRetryDelay,
      maxRetryDelay: options.maxRetryDelay ?? DEFAULT_WEBRTC_OPTIONS.maxRetryDelay,
      mediaOptions: {
        direction: options.mediaOptions?.direction ?? (isInitiator ? 'recvonly' : 'sendrecv'),
        localStream: options.mediaOptions?.localStream,
        kinds: options.mediaOptions?.kinds,
      },
    };
    this.peerId = options.peerId;
    this.selfManagedSignaling = options.selfManagedSignaling ?? false;
    this.iceServersProvider = options.iceServersProvider;
    this.signalingSink = options.signalingSink;

    // Create local stream for non-initiator if not provided
    if (!isInitiator && !this.options.mediaOptions.localStream) {
      this.localStream = new MediaStream();
      this.options.mediaOptions.localStream = this.localStream;
    } else {
      this.localStream = this.options.mediaOptions.localStream ?? null;
    }
  }

  /**
   * Set callbacks for connection events
   */
  setCallbacks(callbacks: {
    onConnected?: () => void;
    onDisconnected?: () => void;
    onError?: (error: Error) => void;
    onReconnecting?: (attempt: number) => void;
    onReconnected?: (attempt: number) => void;
  }): void {
    this.onConnectedCallback = callbacks.onConnected;
    this.onDisconnectedCallback = callbacks.onDisconnected;
    this.onErrorCallback = callbacks.onError;
    this.onReconnectingCallback = callbacks.onReconnecting;
    this.onReconnectedCallback = callbacks.onReconnected;
  }

  /** Whether close() has been called. A closed handler cannot reconnect. */
  isHandlerClosed(): boolean {
    return this.isClosed;
  }

  /**
   * Connect and return a PhygridMediaStream.
   * Idempotent: if already connecting, returns the same promise.
   */
  async connect(): Promise<PhygridMediaStream> {
    if (this.isClosed) {
      throw new Error('MediaStreamHandler has been closed');
    }

    // Return existing connect promise to prevent duplicate PeerConnectionManagers
    if (this.connectPromise) {
      return this.connectPromise;
    }

    this.connectPromise = this.doConnect();
    return this.connectPromise;
  }

  private async doConnect(): Promise<PhygridMediaStream> {
    this.isConnecting = true;
    // Channel prefix includes name for unique signaling per channel
    const channelPrefix = `media-${this.channelName}`;

    const pcConfig: PeerConnectionConfig = {
      targetTwinId: this.targetTwinId,
      isInitiator: this.isInitiator,
      connectionType: 'mediastream',
      channelPrefix,
      useStun: this.options.useStun,
      stunServers: this.options.stunServers,
      turnServers: this.options.turnServers,
      iceTransportPolicy: this.options.iceTransportPolicy,
      iceServersProvider: this.iceServersProvider,
      peerId: this.peerId,
      selfManagedSignaling: this.selfManagedSignaling,
      signalingSink: this.signalingSink,
      onConnected: () => this.handlePeerConnected(),
      onDisconnected: () => this.handlePeerDisconnected(),
      onError: (err) => this.handleError(err),
      onReconnecting: (attempt) => {
        this.isConnecting = true;
        this.isReceiving = false;
        // pc is being rebuilt — pause the backstop; handlePeerConnected re-arms it.
        this.stopOutboundLivenessMonitor();
        this.onReconnectingCallback?.(attempt);
      },
      onReconnected: (attempt) => this.handleReconnected(attempt),
      // Setup transceivers/tracks BEFORE offer is created (critical for ICE gathering)
      onPeerConnectionCreated: (pc) => {
        if (this.isInitiator) {
          if (this.localStream && this.localStream.getTracks().length > 0) {
            // Initiator with local stream: Add actual tracks before offer
            this.localStream.getTracks().forEach((track) => {
              pc.addTrack(track, this.localStream!);
            });
          } else {
            // Initiator without local stream: add one receiving transceiver per
            // requested kind. Default ['video'] preserves the legacy behaviour
            // for every caller that predates MediaStreamOptions.kinds.
            const kinds = this.options.mediaOptions.kinds ?? ['video'];
            for (const kind of kinds) {
              pc.addTransceiver(kind, { direction: this.options.mediaOptions.direction });
            }
          }
        } else if (this.localStream) {
          // Responder: Add local tracks before answer is sent
          this.localStream.getTracks().forEach((track) => {
            pc.addTrack(track, this.localStream!);
          });
        }

        // Handle incoming tracks (both sides)
        pc.ontrack = (event) => {
          // Keep a SINGLE stable remoteStream object across reconnects: an app that
          // captured getStream() as a <video>.srcObject must keep working after the
          // peer reloads. On reconnect event.streams[0] is a brand-new MediaStream,
          // so we copy its track into our own stable stream rather than replacing it.
          if (!this.remoteStream) {
            this.remoteStream = new MediaStream();
          }
          const stream = this.remoteStream;
          // Prune only genuinely-ended tracks (the previous session's tracks end
          // when its pc closes during reconnect). Never remove a live track — a
          // peer may legitimately send multiple tracks of the same kind.
          stream.getTracks().forEach((t) => {
            if (t.readyState === 'ended') {
              stream.removeTrack(t);
            }
          });
          if (!stream.getTrackById(event.track.id)) {
            stream.addTrack(event.track);
          }

          this.handleRemoteStream(stream);
        };
      },
    };

    this.pcManager = new PeerConnectionManager(pcConfig, this.transport, {
      connectionTimeout: this.options.connectionTimeout,
      initialRetryDelay: this.options.initialRetryDelay,
      maxRetryDelay: this.options.maxRetryDelay,
    });

    const pc = await this.pcManager.connect();
    try {
      await this.setupMediaStream(pc);
    } catch (error) {
      // A rejected setup (e.g. a requested kind never produced a track) must not
      // leave a live peer connection behind — the caller only ever sees the error.
      this.close();
      throw error;
    }

    return this.createPhygridMediaStream();
  }

  /**
   * Feed a demultiplexed signaling message in from the responder fan-out
   * dispatcher (used with selfManagedSignaling). No-op until connect() has
   * created the underlying peer connection manager (the manager itself buffers
   * messages that arrive before its pc exists).
   */
  async ingestSignalingMessage(message: any): Promise<void> {
    await this.pcManager?.ingestSignalingMessage(message);
  }

  /**
   * Close the media stream and clean up
   */
  close(): void {
    if (this.isClosed) return;

    this.isClosed = true;
    this.isReceiving = false;
    this.connectPromise = null;

    this.stopFrameActivityMonitor();
    this.stopOutboundLivenessMonitor();

    // Stop all tracks
    this.tracks.forEach((track) => {
      try {
        track.stop();
      } catch (err) {
        console.error('[MediaStreamHandler] Error stopping track:', err);
      }
    });
    this.tracks = [];

    if (this.remoteStream) {
      this.remoteStream.getTracks().forEach((track) => track.stop());
      this.remoteStream = null;
    }

    if (this.localStream) {
      this.localStream.getTracks().forEach((track) => track.stop());
      this.localStream = null;
    }

    if (this.pcManager) {
      this.pcManager.close();
      this.pcManager = null;
    }

    this.notifyCloseListeners();
    this.trackListeners.clear();
    this.frameListeners.clear();
    this.closeListeners.clear();
    this.trackLastFrameTime.clear();
  }

  // ===========================================================================
  // Private Methods
  // ===========================================================================

  private async setupMediaStream(_pc: RTCPeerConnection): Promise<void> {
    // Transceivers and ontrack handler are set up in onPeerConnectionCreated
    // This method now just waits for the connection to be established
    // or returns immediately if we're not expecting incoming tracks
    if (this.options.mediaOptions.direction === 'sendonly') {
      return;
    }

    // Explicitly-requested kinds are enforced: each one must produce a track or
    // the connection rejects. Callers that omitted kinds keep the tolerant
    // legacy path below, byte-for-byte.
    const enforcedKinds = this.getEnforcedReceiveKinds();
    if (enforcedKinds) {
      return this.waitForRequestedKinds(enforcedKinds);
    }

    // For recvonly/sendrecv, wait for tracks if not already received
    if (this.remoteStream && this.remoteStream.getTracks().length > 0) {
      return; // Already have tracks
    }

    // Wait a short time for tracks to arrive (they may come after connection)
    return new Promise<void>((resolve) => {
      const timeout = setTimeout(() => {
        console.log('[MediaStreamHandler] Proceeding without waiting for remote tracks');
        resolve();
      }, 1000);

      // If we get a track, resolve immediately
      const checkForTracks = () => {
        if (this.remoteStream && this.remoteStream.getTracks().length > 0) {
          clearTimeout(timeout);
          resolve();
        }
      };

      // Check periodically
      const interval = setInterval(() => {
        checkForTracks();
        if (this.remoteStream && this.remoteStream.getTracks().length > 0) {
          clearInterval(interval);
        }
      }, 100);

      // Clean up interval on timeout
      setTimeout(() => clearInterval(interval), 1000);
    });
  }

  /**
   * The kinds whose arrival is enforced — non-null only when the caller
   * explicitly requested kinds AND they were lowered onto receiving
   * transceivers (initiator with no local tracks, the same condition as the
   * addTransceiver loop in onPeerConnectionCreated). An initiator sending a
   * local stream never had its kinds negotiated, so nothing is enforced there.
   */
  private getEnforcedReceiveKinds(): MediaTrackKind[] | null {
    const requestedKinds = this.options.mediaOptions.kinds;
    if (!requestedKinds || requestedKinds.length === 0) {
      return null;
    }
    if (!this.isInitiator) {
      return null;
    }
    if (this.localStream && this.localStream.getTracks().length > 0) {
      return null;
    }
    return requestedKinds;
  }

  /**
   * Resolve once every requested kind has delivered a remote track; reject with
   * MissingMediaTrackError naming the missing kind(s) after connectionTimeout.
   * Without this, asking a publisher for a kind it does not offer resolves
   * half-connected and the consumer waits forever for a track that is never
   * coming (the responder answers the unfulfillable m-line with nothing, so
   * ontrack never fires for it).
   */
  private waitForRequestedKinds(requestedKinds: MediaTrackKind[]): Promise<void> {
    const timeoutMs = this.options.connectionTimeout;

    const findMissingKinds = (): MediaTrackKind[] => {
      const receivedKinds = new Set((this.remoteStream?.getTracks() ?? []).map((track) => track.kind));
      return requestedKinds.filter((kind) => !receivedKinds.has(kind));
    };

    if (findMissingKinds().length === 0) {
      return Promise.resolve();
    }

    return new Promise<void>((resolve, reject) => {
      let pollInterval: NodeJS.Timeout | null = null;
      let timeout: NodeJS.Timeout | null = null;

      const finish = (error?: Error): void => {
        if (pollInterval) {
          clearInterval(pollInterval);
          pollInterval = null;
        }
        if (timeout) {
          clearTimeout(timeout);
          timeout = null;
        }
        if (error) {
          reject(error);
        } else {
          resolve();
        }
      };

      pollInterval = setInterval(() => {
        if (this.isClosed) {
          finish(new Error('MediaStreamHandler has been closed'));
          return;
        }
        if (findMissingKinds().length === 0) {
          finish();
        }
      }, 100);

      timeout = setTimeout(() => {
        finish(new MissingMediaTrackError(this.targetTwinId, findMissingKinds(), timeoutMs));
      }, timeoutMs);
    });
  }

  private handleRemoteStream(stream: MediaStream): void {
    this.startFrameActivityMonitor();

    stream.getTracks().forEach((track) => {
      this.addTrackToCollection(track, stream);
    });

    this.onConnectedCallback?.();
  }

  private addTrackToCollection(track: MediaStreamTrack, stream: MediaStream): void {
    // Check for duplicate
    const existingIndex = this.tracks.findIndex((existingTrack) => existingTrack.id === track.id);
    if (existingIndex !== -1) {
      this.tracks.splice(existingIndex, 1);
    }

    this.tracks.push(track);
    this.trackLastFrameTime.set(track.id, Date.now());

    // Set up frame monitoring for the track
    this.setupTrackFrameMonitoring(track, stream);

    // Notify listeners
    this.notifyTrackListeners(track);
  }

  private setupTrackFrameMonitoring(track: MediaStreamTrack, stream: MediaStream): void {
    const extendedTrack = track as ExtendedMediaStreamTrack;

    // Try to use onFrame if available (Node.js @roamhq/wrtc)
    if (typeof extendedTrack.onFrame === 'function') {
      const originalOnFrame = extendedTrack.onFrame;
      extendedTrack.onFrame = (frame: any) => {
        this.trackLastFrameTime.set(track.id, Date.now());
        this.isReceiving = true;
        this.notifyFrameListeners(frame);
        originalOnFrame.call(extendedTrack, frame);
      };
    }

    // Handle track ended
    track.onended = () => {
      this.trackLastFrameTime.delete(track.id);
      const index = this.tracks.findIndex((existingTrack) => existingTrack.id === track.id);
      if (index !== -1) {
        this.tracks.splice(index, 1);
      }

      // Check if all tracks ended
      const allEnded = stream.getTracks().every((streamTrack) => streamTrack.readyState === 'ended');
      if (allEnded && !this.isClosed) {
        this.handlePeerDisconnected();
      }
    };
  }

  private startFrameActivityMonitor(): void {
    if (this.frameActivityInterval) return;

    this.frameActivityInterval = setInterval(() => {
      this.checkFrameActivity();
    }, 1000);
  }

  private stopFrameActivityMonitor(): void {
    if (this.frameActivityInterval) {
      clearInterval(this.frameActivityInterval);
      this.frameActivityInterval = null;
    }
  }

  private checkFrameActivity(): void {
    if (this.trackLastFrameTime.size === 0) return;

    const now = Date.now();
    let hasActiveTrack = false;

    this.trackLastFrameTime.forEach((lastTime) => {
      if (now - lastTime < FRAME_INACTIVITY_TIMEOUT) {
        hasActiveTrack = true;
      }
    });

    if (!hasActiveTrack && this.isReceiving) {
      console.log('[MediaStreamHandler] Frame inactivity detected, connection may be stale');
      this.isReceiving = false;

      // Trigger reconnect
      if (!this.isClosed && this.pcManager) {
        this.pcManager.reconnect();
      }
    }
  }

  private handlePeerConnected(): void {
    this.isConnecting = false;
    // Peer connection established - media setup will follow.
    // Arm the sendonly liveness backstop (no-op for non-sendonly directions).
    this.startOutboundLivenessMonitor();
  }

  /**
   * Start the sendonly liveness backstop. A sendonly responder peer receives no
   * media (frame monitor never runs) and wrtc may never flip pc.connectionState
   * when the viewer disappears — so without this its slot leaks and eventually
   * exhausts a maxPeers fan-out. We watch inbound transport bytes/packets via
   * getStats; once we've seen real inbound progress, a freeze past the timeout
   * means the remote is gone. No-op unless direction is 'sendonly'.
   */
  private startOutboundLivenessMonitor(): void {
    if (this.outboundLivenessInterval || this.isClosed) return;
    if (this.options.mediaOptions.direction !== 'sendonly') return;
    this.lastInboundTotal = 0;
    this.lastInboundProgressAt = 0;
    this.everReceivedInbound = false;
    this.outboundLivenessInterval = setInterval(() => {
      void this.checkOutboundLiveness();
    }, OUTBOUND_LIVENESS_CHECK_INTERVAL_MS);
  }

  private stopOutboundLivenessMonitor(): void {
    if (this.outboundLivenessInterval) {
      clearInterval(this.outboundLivenessInterval);
      this.outboundLivenessInterval = null;
    }
  }

  private async checkOutboundLiveness(): Promise<void> {
    if (this.isClosed) {
      this.stopOutboundLivenessMonitor();
      return;
    }
    const pc = this.pcManager?.getPeerConnection();
    if (!pc) return;

    let inbound = 0;
    try {
      const stats = await pc.getStats();
      stats.forEach((report: any) => {
        if (report.type === 'candidate-pair') {
          inbound += (report.bytesReceived ?? 0) + (report.packetsReceived ?? 0) + (report.responsesReceived ?? 0);
        } else if (report.type === 'remote-inbound-rtp' || report.type === 'inbound-rtp') {
          inbound += report.packetsReceived ?? 0;
        }
      });
    } catch {
      return; // getStats unavailable — never act (no false positives)
    }

    if (this.isClosed) return; // may have closed during the await

    const now = Date.now();
    if (inbound > this.lastInboundTotal) {
      this.lastInboundTotal = inbound;
      this.lastInboundProgressAt = now;
      this.everReceivedInbound = true;
      return;
    }

    // Only act after the connection has PROVEN inbound activity, so a stats
    // backend that reports nothing can never tear down a healthy peer.
    if (!this.everReceivedInbound) return;

    if (now - this.lastInboundProgressAt >= OUTBOUND_STALE_TIMEOUT_MS) {
      this.stopOutboundLivenessMonitor();
      if (this.selfManagedSignaling) {
        // Fan-out responder: can't re-offer. Signal disconnect → the dispatcher
        // drops this peer and frees its slot; the initiator re-offers a fresh one.
        console.log(
          '[MediaStreamHandler] Outbound liveness backstop: no inbound from viewer, tearing down (fan-out peer)',
        );
        this.handlePeerDisconnected();
      } else {
        console.log('[MediaStreamHandler] Outbound liveness backstop: no inbound from peer, forcing reconnect');
        this.pcManager?.reconnect();
      }
    }
  }

  private handlePeerDisconnected(): void {
    this.isReceiving = false;
    this.onDisconnectedCallback?.();
  }

  private handleReconnected(attempt: number): void {
    // Tracks are re-added via onPeerConnectionCreated when new peer connection is created
    // Just notify callback that reconnection succeeded
    console.log(`[MediaStreamHandler] Reconnected after ${attempt} attempts`);
    this.onReconnectedCallback?.(attempt);
  }

  private handleError(error: Error): void {
    console.error('[MediaStreamHandler] MediaStream error:', error);
    this.onErrorCallback?.(error);
  }

  private notifyTrackListeners(track: MediaStreamTrack): void {
    this.trackListeners.forEach((listener) => {
      try {
        listener(track);
      } catch (err) {
        console.error('[MediaStreamHandler] Error in track listener:', err);
      }
    });
  }

  private notifyFrameListeners(frameData: any): void {
    this.frameListeners.forEach((listener) => {
      try {
        listener(frameData);
      } catch (err) {
        console.error('[MediaStreamHandler] Error in frame listener:', err);
      }
    });
  }

  private notifyCloseListeners(): void {
    this.closeListeners.forEach((listener) => {
      try {
        listener();
      } catch (err) {
        console.error('[MediaStreamHandler] Error in close listener:', err);
      }
    });
  }

  private createPhygridMediaStream(): PhygridMediaStream {
    return {
      getTracks: () => [...this.tracks],

      getStream: () => this.remoteStream,

      addTrack: (track: MediaStreamTrack) => {
        if (this.isClosed) {
          console.warn('[MediaStreamHandler] Cannot add track to closed stream');
          return;
        }

        // Add to local stream
        if (this.localStream) {
          const existing = this.localStream.getTrackById(track.id);
          if (existing) {
            this.localStream.removeTrack(existing);
          }
          this.localStream.addTrack(track);
        }

        // Add to tracks collection
        this.tracks.push(track);

        // Add to peer connection if connected
        const pc = this.pcManager?.getPeerConnection();
        if (pc && pc.connectionState === 'connected' && this.localStream) {
          const senders = pc.getSenders();
          const existingSender = senders.find((sender) => sender.track?.id === track.id);
          if (existingSender) {
            existingSender.replaceTrack(track);
          } else {
            pc.addTrack(track, this.localStream);
          }
        }

        this.notifyTrackListeners(track);
      },

      onTrack: (callback: (track: MediaStreamTrack) => void) => {
        this.trackListeners.add(callback);

        // Notify for existing tracks
        this.tracks.forEach((track) => {
          try {
            callback(track);
          } catch (err) {
            console.error('[MediaStreamHandler] Error in track listener:', err);
          }
        });
      },

      offTrack: (callback: (track: MediaStreamTrack) => void) => {
        this.trackListeners.delete(callback);
      },

      onFrame: (callback: (frameData: any) => void) => {
        this.frameListeners.add(callback);
      },

      offFrame: (callback: (frameData: any) => void) => {
        this.frameListeners.delete(callback);
      },

      onClose: (callback: () => void) => {
        this.closeListeners.add(callback);
      },

      offClose: (callback: () => void) => {
        this.closeListeners.delete(callback);
      },

      close: () => {
        this.close();
      },

      isReceivingFrames: () => {
        if (this.trackLastFrameTime.size === 0) return false;

        const now = Date.now();
        for (const lastTime of this.trackLastFrameTime.values()) {
          if (now - lastTime < FRAME_INACTIVITY_TIMEOUT) {
            return true;
          }
        }
        return false;
      },

      getTargetTwinId: () => {
        return this.targetTwinId;
      },

      getChannelName: () => {
        return this.channelName;
      },

      getPeerId: () => {
        return this.pcManager?.getPeerId() ?? this.peerId ?? null;
      },

      isConnecting: () => {
        return this.isConnecting;
      },
    };
  }
}