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, ...raises: [],
    gcsafe, 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,
    ...raises: [], gcsafe, raises: [], raises: [], tags: [RootEffect].}

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

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

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

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

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

proc getStream(c: ConnManager; peerId: PeerId; dir: Direction): InternalRaisesFuture[
    Connection, ] {.stackTrace: false, ...raises: [], gcsafe, 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 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] {.stackTrace: false, ...raises: [], gcsafe, raises: [], raises: [],
            tags: [RootEffect].}