fn pub static datagram(ipv6: Bool) -> Result[Socket, Error] {
  Socket.new(ipv6, libc.SOCK_DGRAM, protocol: 0)
}

fn pub static raw(ipv6: Bool, protocol: Int) -> Result[Socket, Error] {
  Socket.new(ipv6, libc.SOCK_RAW, protocol)
}

fn pub static stream(ipv6: Bool) -> Result[Socket, Error] {
  Socket.new(ipv6, libc.SOCK_STREAM, protocol: 0)
}

fn pub accept -> Result[Socket, Error] {
  let peer = net.raw_socket

  try sys.accept(@socket, mut peer, @deadline)
  Result.Ok(Socket(socket: peer, deadline: net.NO_DEADLINE))
}

fn pub mut bind(ip: IpAddress, port: Int) -> Result[Nil, Error] {
  sys.bind_ip(@socket.inner, ip, port)
}

fn pub mut broadcast=(value: Bool) -> Result[Nil, Error] {
  set_option(libc.SOL_SOCKET, libc.SO_BROADCAST, value.to_int)
}

fn pub mut connect(ip: IpAddress, port: Int) -> Result[Nil, Error] {
  sys.connect_ip(@socket, ip, port, @deadline)
}

fn pub mut flush -> Result[Nil, Error] {
  Result.Ok(nil)
}

fn pub mut keepalive=(value: Bool) -> Result[Nil, Error] {
  set_option(libc.SOL_SOCKET, libc.SO_KEEPALIVE, value.to_int)
}

fn pub mut keepalive_interval=(value: Duration) -> Result[Nil, Error] {
  set_option(libc.IPPROTO_TCP, libc.TCP_KEEPINTVL, value.to_secs.to_int)
}

fn pub mut keepalive_time=(value: Duration) -> Result[Nil, Error] {
  set_option(libc.IPPROTO_TCP, libc.TCP_KEEPIDLE, value.to_secs.to_int)
}

fn pub linger -> Option[Duration] {
  let linger = libc.Linger(l_onoff: 0 as Int32, l_linger: 0 as Int32)
  let size = 8 as Int32
  let res = libc.getsockopt(
    @socket.inner,
    libc.SOL_SOCKET as Int32,
    libc.SO_LINGER as Int32,
    (mut linger) as Pointer[UInt8],
    mut size,
  )
    as Int

  # Similar to get_option(), this method shouldn't ever reach this point, but
  # we panic just in case we do.
  if res != 0 { sys.getsockopt_error }

  if linger.l_onoff as Int != 0 {
    Option.Some(Duration.from_secs(linger.l_linger as Int))
  } else {
    Option.None
  }
}

fn pub mut linger=(value: Option[Duration]) -> Result[Nil, Error] {
  let linger = libc.Linger(l_onoff: 0 as Int32, l_linger: 0 as Int32)

  match value {
    case Some(d) -> {
      linger.l_onoff = 1 as Int32
      linger.l_linger = d.to_secs.to_int as Int32
    }
    case _ -> {}
  }

  let res = libc.setsockopt(
    @socket.inner,
    libc.SOL_SOCKET as Int32,
    libc.SO_LINGER as Int32,
    (mut linger) as Pointer[UInt8],
    8 as Int32,
  )
    as Int

  if res == 0 { Result.Ok(nil) } else { Result.Error(Error.last_os_error) }
}

fn pub mut listen -> Result[Nil, Error] {
  sys.listen(@socket.inner, MAXIMUM_LISTEN_BACKLOG)
}

fn pub local_address -> Result[SocketAddress, Error] {
  match sys.ip_local_address(@socket) {
    case Ok((ip, port)) -> Result.Ok(SocketAddress(ip, port))
    case Error(e) -> Result.Error(e)
  }
}

fn pub mut no_delay=(value: Bool) -> Result[Nil, Error] {
  set_option(libc.IPPROTO_TCP, libc.TCP_NODELAY, value.to_int)
}

fn pub no_delay? -> Bool {
  get_option(libc.IPPROTO_TCP, libc.TCP_NODELAY) != 0
}

fn pub mut only_ipv6=(value: Bool) -> Result[Nil, Error] {
  set_option(libc.IPPROTO_IPV6, libc.IPV6_V6ONLY, value.to_int)
}

fn pub peer_address -> Result[SocketAddress, Error] {
  match sys.ip_peer_address(@socket) {
    case Ok((ip, port)) -> Result.Ok(SocketAddress(ip, port))
    case Error(e) -> Result.Error(e)
  }
}

fn pub mut print[B: Bytes](bytes: ref B) -> Result[Nil, E] {
  try write(bytes)
  write('\n')
}

fn pub mut read(into: mut ByteArray, size: Int) -> Result[Int, Error] {
  sys.read(@socket, into, size, @deadline)
}

fn pub mut read_all(bytes: mut ByteArray) -> Result[Int, E] {
  let mut total = 0
  let mut read_size = INITIAL_READ_ALL_SIZE

  loop {
    match read(into: bytes, size: read_size) {
      case Ok(0) -> return Result.Ok(total)
      case Ok(n) -> {
        total += n

        # To reduce the number of calls to `Reader.read` when there's lots of
        # input to consume, we increase the read size if deemed beneficial.
        if read_size < MAX_READ_ALL_SIZE and n == read_size { read_size *= 2 }
      }
      case Error(e) -> throw e
    }
  }
}

fn pub mut read_exact(
  into: mut ByteArray,
  size: Int,
) -> Result[Nil, ReadExactError[E]] {
  let mut pending = size

  while pending > 0 {
    match read(into, pending) {
      case Ok(0) if pending > 0 -> throw ReadExactError.EndOfInput
      case Ok(n) -> pending -= n
      case Error(e) -> throw ReadExactError.Read(e)
    }
  }

  Result.Ok(nil)
}

fn pub mut receive_buffer_size=(value: Int) -> Result[Nil, Error] {
  set_option(libc.SOL_SOCKET, libc.SO_RCVBUF, value.to_int)
}

fn pub mut receive_from(
  bytes: mut ByteArray,
  size: Int,
) -> Result[(Int, SocketAddress), Error] {
  match sys.receive_from_ip(@socket, bytes, size, @deadline) {
    case Ok((read, ip, port)) -> Result.Ok((read, SocketAddress(ip, port)))
    case Error(e) -> Result.Error(e)
  }
}

fn pub mut reset_deadline {
  @deadline = net.NO_DEADLINE
}

fn pub mut reuse_address=(value: Bool) -> Result[Nil, Error] {
  set_option(libc.SOL_SOCKET, libc.SO_REUSEADDR, value.to_int)
}

fn pub mut reuse_port=(value: Bool) -> Result[Nil, Error] {
  set_option(libc.SOL_SOCKET, libc.SO_REUSEPORT, value.to_int)
}

fn pub mut send_buffer_size=(value: Int) -> Result[Nil, Error] {
  set_option(libc.SOL_SOCKET, libc.SO_SNDBUF, value.to_int)
}

fn pub mut send_file(file: mut ReadOnlyFile) -> Result[Int, Error] {
  sys.send_file_stream(file, self)
}

fn pub mut send_to[B: Bytes](
  bytes: ref B,
  ip: IpAddress,
  port: Int,
) -> Result[Int, Error] {
  sys.send_to_ip(@socket, bytes.pointer, bytes.size, ip, port, @deadline)
}

fn pub mut shutdown -> Result[Nil, Error] {
  sys.shutdown(@socket, read: true, write: true)
}

fn pub mut shutdown_read -> Result[Nil, Error] {
  sys.shutdown(@socket, read: true, write: false)
}

fn pub mut shutdown_write -> Result[Nil, Error] {
  sys.shutdown(@socket, read: false, write: true)
}

fn pub mut timeout_after=[T: ToInstant](deadline: ref T) {
  @deadline = deadline.to_instant.to_int
}

fn pub try_clone -> Result[Socket, Error] {
  let sock = net.raw_socket

  try sys.try_clone(@socket, mut sock)
  Result.Ok(Socket(socket: sock, deadline: net.NO_DEADLINE))
}

fn pub mut ttl=(value: Int) -> Result[Nil, Error] {
  set_option(libc.IPPROTO_IP, libc.IP_TTL, value)
}

fn pub mut write[B: Bytes](bytes: ref B) -> Result[Nil, Error] {
  write_all_internal(bytes.pointer, bytes.size)
}