class IO::Endpoint::Wrapper

def accept(*arguments, backlog: SOMAXCONN, **options, &block)
	bind(*arguments, **options) do |server|
		server.listen(backlog) if backlog
		
		async do
			while true
				server.accept(&block)
			end
		end
	end
end

def async
	raise NotImplementedError
end

def bind(local_address, protocol: 0, **options, &block)
	socket = build(local_address.afamily, local_address.socktype, protocol, **options) do |socket|
		socket.bind(local_address.to_sockaddr)
	end
	
	return socket unless block_given?
	
	async do
		begin
			yield socket
		ensure
			socket.close
		end
	end
end

def build(*arguments, timeout: nil, reuse_address: true, reuse_port: nil, linger: nil, buffered: false)
	socket = ::Socket.new(*arguments)
	
	# Set the timeout:
	if timeout
		set_timeout(socket, timeout)
	end
	
	if reuse_address
		socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
	end
	
	if reuse_port
		socket.setsockopt(SOL_SOCKET, SO_REUSEPORT, 1)
	end
	
	if linger
		socket.setsockopt(SOL_SOCKET, SO_LINGER, 1)
	end
	
	if buffered == false
		set_buffered(socket, buffered)
	end
	
	yield socket if block_given?
	
	return socket
rescue
	socket&.close
	raise
end

def connect(remote_address, local_address: nil, **options)
	socket = build(remote_address.afamily, remote_address.socktype, remote_address.protocol, **options) do |socket|
		if local_address
			if defined?(IP_BIND_ADDRESS_NO_PORT)
				# Inform the kernel (Linux 4.2+) to not reserve an ephemeral port when using bind(2) with a port number of 0. The port will later be automatically chosen at connect(2) time, in a way that allows sharing a source port as long as the 4-tuple is unique.
				socket.setsockopt(SOL_IP, IP_BIND_ADDRESS_NO_PORT, 1)
			end
			
			socket.bind(local_address.to_sockaddr)
		end
	end
	
	begin
		socket.connect(remote_address.to_sockaddr)
	rescue Exception
		socket.close
		raise
	end
	
	return socket unless block_given?
	
	begin
		yield socket
	ensure
		socket.close
	end
end

def set_buffered(socket, buffered)
	case buffered
	when true
		socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 0)
	when false
		socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
	end
rescue Errno::EINVAL
	# On Darwin, sometimes occurs when the connection is not yet fully formed. Empirically, TCP_NODELAY is enabled despite this result.
rescue Errno::EOPNOTSUPP
	# Some platforms may simply not support the operation.
	# Console.logger.warn(self) {"Unable to set sync=#{value}!"}
rescue Errno::ENOPROTOOPT
	# It may not be supported by the protocol (e.g. UDP). ¯\_(ツ)_/¯
end

def set_timeout(io, timeout)
	io.timeout = timeout
end

def set_timeout(io, timeout)
	warn "IO#timeout= not supported on this platform."
end