{.used.}

import
  chronos,
  confutils/toml/std/net,
  libp2p/multiaddress,
  testutils/unittests

import
  ./testlib/wakunode,
  ../../waku/waku_enr/capabilities

include
  ../../waku/node/config

proc defaultTestWakuFlags(): CapabilitiesBitfield =
  CapabilitiesBitfield.init(
      lightpush = false,
      filter = false,
      store = false,
      relay = true
  )
    
suite "Waku NetConfig":
  
  asyncTest "Create NetConfig with default values":

    let conf = defaultTestWakuNodeConf()
    
    let wakuFlags = defaultTestWakuFlags()
    
    let netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort,
      extIp = none(IpAddress),
      extPort = none(Port),
      extMultiAddrs = @[],
      wsBindPort = conf.websocketPort,
      wsEnabled = conf.websocketSupport,
      wssEnabled = conf.websocketSecureSupport,
      dns4DomainName = none(string),
      discv5UdpPort = none(Port),
      wakuFlags = some(wakuFlags)
    )

    check:
      netConfigRes.isOk()

  asyncTest "AnnouncedAddresses contains only bind address when no external addresses are provided":

    let conf = defaultTestWakuNodeConf()
        
    let netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort
    )
     
    assert netConfigRes.isOk(), $netConfigRes.error

    let netConfig = netConfigRes.get()

    check:
      netConfig.announcedAddresses.len == 1  # Only bind address should be present
      netConfig.announcedAddresses[0] == formatListenAddress(ip4TcpEndPoint(conf.listenAddress, conf.tcpPort))


  asyncTest "AnnouncedAddresses contains external address if extIp/Port are provided":

    let 
      conf = defaultTestWakuNodeConf()
      extIp = parseIpAddress("1.2.3.4")
      extPort = Port(1234)
        
    let netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort,
      extIp = some(extIp),
      extPort = some(extPort)
    )
     
    assert netConfigRes.isOk(), $netConfigRes.error

    let netConfig = netConfigRes.get()

    check:
      netConfig.announcedAddresses.len == 1  # Only external address should be present
      netConfig.announcedAddresses[0] == ip4TcpEndPoint(extIp, extPort)

  asyncTest "AnnouncedAddresses contains dns4DomainName if provided":

    let 
      conf = defaultTestWakuNodeConf()
      dns4DomainName = "example.com"
      extPort = Port(1234)

    let netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort,
      dns4DomainName = some(dns4DomainName),
      extPort = some(extPort)
    )
      
    assert netConfigRes.isOk(), $netConfigRes.error

    let netConfig = netConfigRes.get()

    check:
      netConfig.announcedAddresses.len == 1  # Only DNS address should be present
      netConfig.announcedAddresses[0] == dns4TcpEndPoint(dns4DomainName, extPort)

  asyncTest "AnnouncedAddresses includes extMultiAddrs when provided":

    let 
      conf = defaultTestWakuNodeConf()
      extIp = parseIpAddress("1.2.3.4")
      extPort = Port(1234)
      extMultiAddrs = @[ip4TcpEndPoint(extIp, extPort)]
        
    let netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort,
      extMultiAddrs = extMultiAddrs
    )
     
    assert netConfigRes.isOk(), $netConfigRes.error

    let netConfig = netConfigRes.get()

    check:
      netConfig.announcedAddresses.len == 2  # Bind address + extAddress
      netConfig.announcedAddresses[1] == extMultiAddrs[0]


  asyncTest "AnnouncedAddresses uses dns4DomainName over extIp when both are provided":

    let 
      conf = defaultTestWakuNodeConf()
      dns4DomainName = "example.com"
      extIp = parseIpAddress("1.2.3.4")
      extPort = Port(1234)
        
    let netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort,
      dns4DomainName = some(dns4DomainName),
      extIp = some(extIp),
      extPort = some(extPort)
    )
     
    assert netConfigRes.isOk(), $netConfigRes.error

    let netConfig = netConfigRes.get()

    check:
      netConfig.announcedAddresses.len == 1  # DNS address
      netConfig.announcedAddresses[0] == dns4TcpEndPoint(dns4DomainName, extPort) 

  asyncTest "AnnouncedAddresses includes WebSocket addresses when enabled":

    var 
      conf = defaultTestWakuNodeConf()
      wssEnabled = false
        
    var netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort,
      wsEnabled = true,
      wssEnabled = wssEnabled
    )
     
    assert netConfigRes.isOk(), $netConfigRes.error

    var netConfig = netConfigRes.get()

    check:
      netConfig.announcedAddresses.len == 2  # Bind address + wsHostAddress
      netConfig.announcedAddresses[1] == (ip4TcpEndPoint(conf.listenAddress, 
        conf.websocketPort) & wsFlag(wssEnabled))
    
    ## Now try the same for the case of wssEnabled = true
        
    wssEnabled = true
    
    netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort,
      wsEnabled = true,
      wssEnabled = wssEnabled
    )

    assert netConfigRes.isOk(), $netConfigRes.error

    netConfig = netConfigRes.get()

    check:
      netConfig.announcedAddresses.len == 2  # Bind address + wsHostAddress
      netConfig.announcedAddresses[1] == (ip4TcpEndPoint(conf.listenAddress, 
        conf.websocketPort) & wsFlag(wssEnabled))
    
  asyncTest "Announced WebSocket address contains external IP if provided":

    let 
      conf = defaultTestWakuNodeConf()
      extIp = parseIpAddress("1.2.3.4")
      extPort = Port(1234)
      wssEnabled = false
        
    let netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort,
      extIp = some(extIp),
      extPort = some(extPort),
      wsEnabled = true,
      wssEnabled = wssEnabled
    )
     
    assert netConfigRes.isOk(), $netConfigRes.error

    let netConfig = netConfigRes.get()

    check:
      netConfig.announcedAddresses.len == 2  # External address + wsHostAddress
      netConfig.announcedAddresses[1] == (ip4TcpEndPoint(extIp, 
        conf.websocketPort) & wsFlag(wssEnabled))

  asyncTest "Announced WebSocket address contains dns4DomainName if provided":

    let 
      conf = defaultTestWakuNodeConf()
      dns4DomainName = "example.com"
      extPort = Port(1234)
      wssEnabled = false
        
    let netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort,
      dns4DomainName = some(dns4DomainName),
      extPort = some(extPort),
      wsEnabled = true,
      wssEnabled = wssEnabled
    )
     
    assert netConfigRes.isOk(), $netConfigRes.error

    let netConfig = netConfigRes.get()

    check:
      netConfig.announcedAddresses.len == 2  # Bind address + wsHostAddress
      netConfig.announcedAddresses[1] == (dns4TcpEndPoint(dns4DomainName, conf.websocketPort) & 
        wsFlag(wssEnabled))

  asyncTest "Announced WebSocket address contains dns4DomainName if provided alongside extIp":

    let 
      conf = defaultTestWakuNodeConf()
      dns4DomainName = "example.com"
      extIp = parseIpAddress("1.2.3.4")
      extPort = Port(1234)
      wssEnabled = false
        
    let netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort,
      dns4DomainName = some(dns4DomainName),
      extIp = some(extIp),
      extPort = some(extPort),
      wsEnabled = true,
      wssEnabled = wssEnabled
    )
     
    assert netConfigRes.isOk(), $netConfigRes.error

    let netConfig = netConfigRes.get()

    check:
      netConfig.announcedAddresses.len == 2  # DNS address + wsHostAddress
      netConfig.announcedAddresses[0] == dns4TcpEndPoint(dns4DomainName, extPort)
      netConfig.announcedAddresses[1] == (dns4TcpEndPoint(dns4DomainName, conf.websocketPort) & 
        wsFlag(wssEnabled))      

  asyncTest "ENR is set with bindIp/Port if no extIp/Port are provided":

    let conf = defaultTestWakuNodeConf()
        
    let netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort
    )
     
    assert netConfigRes.isOk(), $netConfigRes.error

    let netConfig = netConfigRes.get()

    check:
      netConfig.enrIp.get() == conf.listenAddress
      netConfig.enrPort.get() == conf.tcpPort

  asyncTest "ENR is set with extIp/Port if provided":

    let 
      conf = defaultTestWakuNodeConf()
      extIp = parseIpAddress("1.2.3.4")
      extPort = Port(1234)
        
    let netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort,
      extIp = some(extIp),
      extPort = some(extPort)
    )
     
    assert netConfigRes.isOk(), $netConfigRes.error

    let netConfig = netConfigRes.get()

    check:
      netConfig.extIp.get() == extIp
      netConfig.enrPort.get() == extPort

  asyncTest "ENR is set with dns4DomainName if provided":

    let 
      conf = defaultTestWakuNodeConf()
      dns4DomainName = "example.com"
      extPort = Port(1234)

    let netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort,
      dns4DomainName = some(dns4DomainName),
      extPort = some(extPort)
    )

    assert netConfigRes.isOk(), $netConfigRes.error

    let netConfig = netConfigRes.get()

    check:
      netConfig.enrMultiaddrs.contains(dns4TcpEndPoint(dns4DomainName, extPort))

  asyncTest "wsHostAddress is not announced if a WS/WSS address is provided in extMultiAddrs":
  
    var 
      conf = defaultTestWakuNodeConf()
      extAddIp = parseIpAddress("1.2.3.4")
      extAddPort = Port(1234)
      wsEnabled = true
      wssEnabled = false
      extMultiAddrs = @[(ip4TcpEndPoint(extAddIp, extAddPort) & wsFlag(wssEnabled))]
        
    var netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort,
      extMultiAddrs = extMultiAddrs,
      wsEnabled = wsEnabled
    )
     
    assert netConfigRes.isOk(), $netConfigRes.error

    var netConfig = netConfigRes.get()

    check:
      netConfig.announcedAddresses.len == 2  # Bind address + extAddress
      netConfig.announcedAddresses[1] == extMultiAddrs[0]

    # Now same test for WSS external address
    wssEnabled = true
    extMultiAddrs = @[(ip4TcpEndPoint(extAddIp, extAddPort) & wsFlag(wssEnabled))]
    
    netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort,
      extMultiAddrs = extMultiAddrs,
      wssEnabled = wssEnabled
    )

    assert netConfigRes.isOk(), $netConfigRes.error

    netConfig = netConfigRes.get()

    check:
      netConfig.announcedAddresses.len == 2  # Bind address + extAddress
      netConfig.announcedAddresses[1] == extMultiAddrs[0]

  asyncTest "Only extMultiAddrs are published when enabling extMultiAddrsOnly flag":
  
    let 
      conf = defaultTestWakuNodeConf()
      extAddIp = parseIpAddress("1.2.3.4")
      extAddPort = Port(1234)
      extMultiAddrs = @[ip4TcpEndPoint(extAddIp, extAddPort)]
        
    let netConfigRes = NetConfig.init(
      bindIp = conf.listenAddress,
      bindPort = conf.tcpPort,
      extMultiAddrs = extMultiAddrs,
      extMultiAddrsOnly = true
    )
     
    assert netConfigRes.isOk(), $netConfigRes.error

    let netConfig = netConfigRes.get()

    check:
      netConfig.announcedAddresses.len == 1  # ExtAddress
      netConfig.announcedAddresses[0] == extMultiAddrs[0]