# Nim-LibP2P
# Copyright (c) 2023 Status Research & Development GmbH
# Licensed under either of
#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.

{.push gcsafe.}
when (NimMajor, NimMinor) < (1, 4):
  {.push raises: [Defect].}
else:
  {.push raises: [].}

import std/[options, sequtils, strutils]
import pkg/[chronos, chronicles, metrics]

import ../stream/connection,
       ../protocols/secure/secure,
       ../protocols/identify,
       ../muxers/muxer,
       ../multistream,
       ../peerstore,
       ../connmanager,
       ../errors,
       ../utility

export connmanager, connection, identify, secure, multistream

declarePublicCounter(libp2p_failed_upgrade, "peers failed upgrade")

logScope:
  topics = "libp2p upgrade"

type
  UpgradeFailedError* = object of LPError

  Upgrade* = ref object of RootObj
    ms*: MultistreamSelect
    connManager*: ConnManager
    secureManagers*: seq[Secure]

method upgradeIncoming*(
  self: Upgrade,
  conn: Connection): Future[Muxer] {.base.} =
  doAssert(false, "Not implemented!")

method upgradeOutgoing*(
  self: Upgrade,
  conn: Connection,
  peerId: Opt[PeerId]): Future[Muxer] {.base.} =
  doAssert(false, "Not implemented!")

proc secure*(
  self: Upgrade,
  conn: Connection,
  direction: Direction,
  peerId: Opt[PeerId]): Future[Connection] {.async, gcsafe.} =
  if self.secureManagers.len <= 0:
    raise newException(UpgradeFailedError, "No secure managers registered!")

  let codec =
    if direction == Out: await self.ms.select(conn, self.secureManagers.mapIt(it.codec))
    else: await MultistreamSelect.handle(conn, self.secureManagers.mapIt(it.codec))
  if codec.len == 0:
    raise newException(UpgradeFailedError, "Unable to negotiate a secure channel!")

  trace "Securing connection", conn, codec
  let secureProtocol = self.secureManagers.filterIt(it.codec == codec)

  # ms.select should deal with the correctness of this
  # let's avoid duplicating checks but detect if it fails to do it properly
  doAssert(secureProtocol.len > 0)

  return await secureProtocol[0].secure(conn, direction == Out, peerId)