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

  else:
      nil

  

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

ConnEventKind {.pure.} = enum
  Connected, Disconnected

ConnManager = ref object of RootObj
  maxConnsPerPeer: int
  inSema*: AsyncSemaphore
  outSema*: AsyncSemaphore
  conns: Table[PeerId, HashSet[Connection]]
  muxed: Table[Connection, MuxerHolder]
  connEvents: array[ConnEventKind, OrderedSet[ConnEventHandler]]
  peerEvents: array[PeerEventKind, OrderedSet[PeerEventHandler]]
  peerStore*: PeerStore

ConnProvider = proc (): Future[Connection] {....gcsafe, closure, ...raises: [Defect].}

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

  else:
      nil

  

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

PeerEventKind {.pure.} = enum
  Left, Identified, Joined

TooManyConnectionsError = object of LPError

MaxConnections = 50

MaxConnectionsPerPeer = 1

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

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

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

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

proc contains(c: ConnManager; conn: Connection): bool {....raises: [Defect],
    tags: [].}

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

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

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

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

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

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

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

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

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

proc selectConn(c: ConnManager; peerId: PeerId): Connection {....raises: [Defect],
    tags: [].}

proc selectConn(c: ConnManager; peerId: PeerId; dir: Direction): Connection {.
    ...raises: [Defect], tags: [].}

proc selectMuxer(c: ConnManager; conn: Connection): Muxer {....raises: [Defect],
    tags: [WriteIOEffect, TimeEffect].}

proc storeConn(c: ConnManager; conn: Connection) {....raises: [Defect, LPError],
    raises: [Defect], tags: [WriteIOEffect, TimeEffect, RootEffect].}

proc storeMuxer(c: ConnManager; muxer: Muxer; handle: Future[void] = nil) {.
    ...raises: [Defect, CatchableError], raises: [Defect], tags: [RootEffect].}

proc trackIncomingConn(c: ConnManager; provider: ConnProvider): Future[
    Connection] {.stackTrace: false, ...gcsafe, raises: [Defect], raises: [Defect],
                  tags: [RootEffect].}

proc trackOutgoingConn(c: ConnManager; provider: ConnProvider; forceDial = false): Future[
    Connection] {.stackTrace: false, ...gcsafe, raises: [Defect], raises: [Defect],
                  tags: [RootEffect].}

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

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