AlreadyExpectingConnectionError = object of LPError

ConnectionSlot = object
  connManager: ConnManager
  direction: Direction

ConnEvent = object
  case kind*: ConnEventKind
  of ConnEventKind.Connected:
      incoming*: bool

  else:
      nil

  

ConnEventHandler = proc (peerId: PeerId; event: ConnEvent): Future[void] {.
    ...gcsafe, raises: [].}

ConnEventKind {.pure.} = enum
  Connected, Disconnected

ConnManager = ref object of RootObj
  maxConnsPerPeer: int
  inSema*: AsyncSemaphore
  outSema*: AsyncSemaphore
  muxed: Table[PeerId, seq[Muxer]]
  connEvents: array[ConnEventKind, OrderedSet[ConnEventHandler]]
  peerEvents: array[PeerEventKind, OrderedSet[PeerEventHandler]]
  expectedConnectionsOverLimit*: Table[Future[Muxer]]
  peerStore*: PeerStore

PeerEvent = object
  case kind*: PeerEventKind
  of PeerEventKind.Joined:
      initiator*: bool

  else:
      nil

  

PeerEventHandler = proc (peerId: PeerId; event: PeerEvent): Future[void] {.
    ...gcsafe, raises: [].}

PeerEventKind {.pure.} = enum
  Left, Joined

TooManyConnectionsError = object of LPError

MaxConnections = 50

MaxConnectionsPerPeer = 1

proc addConnEventHandler(c: ConnManager; handler: ConnEventHandler;
                         kind: ConnEventKind) {....raises: [], tags: [].}

proc addPeerEventHandler(c: ConnManager; handler: PeerEventHandler;
                         kind: PeerEventKind) {....raises: [], tags: [].}

proc close(c: ConnManager): Future[void] {.stackTrace: false, ...gcsafe,
    raises: [], raises: [], raises: [], tags: [RootEffect].}

proc connCount(c: ConnManager; peerId: PeerId): int {....raises: [], tags: [].}

proc contains(c: ConnManager; muxer: Muxer): bool {....raises: [], tags: [].}

proc contains(c: ConnManager; peerId: PeerId): bool {....raises: [], tags: [].}

proc dropPeer(c: ConnManager; peerId: PeerId): Future[void] {.stackTrace: false,
    ...gcsafe, raises: [], raises: [], raises: [], tags: [RootEffect].}

proc expectConnection(c: ConnManager; p: PeerId; dir: Direction): Future[Muxer] {.
    stackTrace: false, ...gcsafe, raises: [], raises: [], raises: [],
    tags: [RootEffect].}

proc getConnections(c: ConnManager): Table[PeerId, seq[Muxer]] {....raises: [],
    tags: [].}

proc getOutgoingSlot(c: ConnManager; forceDial = false): ConnectionSlot {.
    ...raises: [TooManyConnectionsError], raises: [], tags: [].}

proc getStream(c: ConnManager; peerId: PeerId): Future[Connection] {....gcsafe,
    stackTrace: false, ...gcsafe, raises: [], raises: [], raises: [],
    tags: [RootEffect].}

proc getStream(c: ConnManager; peerId: PeerId; dir: Direction): Future[
    Connection] {....gcsafe, stackTrace: false, ...gcsafe, raises: [], raises: [],
                  raises: [], tags: [RootEffect].}

proc new(C: type ConnManager; maxConnsPerPeer = MaxConnectionsPerPeer;
         maxConnections = MaxConnections; maxIn = -1; maxOut = -1): ConnManager {.
    ...raises: [].}

proc release(cs: ConnectionSlot) {....raises: [], tags: [].}

proc removeConnEventHandler(c: ConnManager; handler: ConnEventHandler;
                            kind: ConnEventKind) {....raises: [], tags: [].}

proc removePeerEventHandler(c: ConnManager; handler: PeerEventHandler;
                            kind: PeerEventKind) {....raises: [], tags: [].}

proc selectMuxer(c: ConnManager; peerId: PeerId): Muxer {....raises: [], tags: [].}

proc storeMuxer(c: ConnManager; muxer: Muxer) {....raises: [CatchableError],
    raises: [], tags: [RootEffect, WriteIOEffect, TimeEffect].}

proc trackConnection(cs: ConnectionSlot; conn: Connection) {....raises: [],
    tags: [RootEffect].}

proc trackMuxer(cs: ConnectionSlot; mux: Muxer) {....raises: [], tags: [RootEffect].}

proc triggerPeerEvents(c: ConnManager; peerId: PeerId; event: PeerEvent): Future[
    void] {....gcsafe, stackTrace: false, ...gcsafe, raises: [], raises: [],
            raises: [], tags: [RootEffect].}