type Action int

type AsyncCallback func(c Conn, err error) error

type BuiltinEventEngine struct{}

type Client struct {
	// contains filtered or unexported fields
}

type Conn interface {
	Reader
	Writer
	Socket

	Context() (ctx any)
	SafeContext() (ctx any)
	EventLoop() EventLoop
	SetContext(ctx any)
	SetSafeContext(ctx any)
	LocalAddr() net.Addr
	RemoteAddr() net.Addr
	Wake(callback AsyncCallback) error
	CloseWithCallback(callback AsyncCallback) error
	Close() error
	SetDeadline(time.Time) error
	SetReadDeadline(time.Time) error
	SetWriteDeadline(time.Time) error
}

type Engine struct {
	// contains filtered or unexported fields
}

type EventHandler interface {
	OnBoot(eng Engine) (action Action)
	OnShutdown(eng Engine)
	OnOpen(c Conn) (out []byte, action Action)
	OnClose(c Conn, err error) (action Action)
	OnTraffic(c Conn) (action Action)
	OnTick() (delay time.Duration, action Action)
}

type EventLoop interface {
	Register(ctx context.Context, addr net.Addr) (<-chan RegisteredResult, error)
	Enroll(ctx context.Context, c net.Conn) (<-chan RegisteredResult, error)
	Execute(ctx context.Context, runnable Runnable) error
	Schedule(ctx context.Context, runnable Runnable, delay time.Duration) error
	Close(Conn) error
}

type LoadBalancing int

type Option func(opts *Options)

type Options struct {
	// LB represents the load-balancing algorithm used when assigning new connections
	// to event loops. This option is server-only, and it is not applicable to the client.
	LB LoadBalancing

	// ReuseAddr indicates whether to set the SO_REUSEADDR socket option.
	// This option is server-only.
	ReuseAddr bool

	// ReusePort indicates whether to set the SO_REUSEPORT socket option.
	// This option is server-only.
	ReusePort bool

	// MulticastInterfaceIndex is the index of the interface name where the multicast UDP addresses will be bound to.
	// This option is server-only.
	MulticastInterfaceIndex int

	// BindToDevice is the name of the interface to which the listening socket will be bound.
	// It is only available on Linux at the moment, an error will therefore be returned when
	// setting this option on non-linux platforms.
	// This option is server-only.
	BindToDevice string

	// Multicore indicates whether the engine will be effectively created with multi-cores, if so,
	// then you must take care with synchronizing memory between all event callbacks; otherwise,
	// it will run the engine with single thread. The number of threads in the engine will be
	// automatically assigned to the number of usable logical CPUs that can be leveraged by the
	// current process.
	Multicore bool

	// NumEventLoop is set up to start the given number of event-loop goroutines.
	// Note that a non-negative NumEventLoop will override Multicore.
	NumEventLoop int

	// ReadBufferCap is the maximum number of bytes that can be read from the remote when the readable event comes.
	// The default value is 64KB, it can either be reduced to avoid starving the subsequent connections or increased
	// to read more data from a socket.
	//
	// Note that ReadBufferCap will always be converted to the least power of two integer value greater than
	// or equal to its real amount.
	ReadBufferCap int

	// WriteBufferCap is the maximum number of bytes that a static outbound buffer can hold,
	// if the data exceeds this value, the overflow bytes will be stored in the elastic linked list buffer.
	// The default value is 64KB.
	//
	// Note that WriteBufferCap will always be converted to the least power of two integer value greater than
	// or equal to its real amount.
	WriteBufferCap int

	// LockOSThread is used to determine whether each I/O event-loop should be associated to an OS thread,
	// it is useful when you need some kind of mechanisms like thread local storage, or invoke certain C
	// libraries (such as graphics lib: GLib) that require thread-level manipulation via cgo, or want all I/O
	// event-loops to actually run in parallel for a potential higher performance.
	LockOSThread bool

	// Ticker indicates whether the ticker has been set up.
	Ticker bool

	// TCPKeepAlive enables the TCP keep-alive mechanism (SO_KEEPALIVE) and set its value
	// on TCP_KEEPIDLE.
	// When TCPKeepInterval is not set, 1/5 of TCPKeepAlive will be set on TCP_KEEPINTVL,
	// and 5 will be set on TCP_KEEPCNT if TCPKeepCount is not assigned to a positive value.
	TCPKeepAlive time.Duration

	// TCPKeepInterval is the value for TCP_KEEPINTVL, it's the interval between
	// TCP keep-alive probes.
	TCPKeepInterval time.Duration

	// TCPKeepCount is the number of keep-alive probes that will be sent before
	// the connection is considered dead and dropped.
	TCPKeepCount int

	// TCPNoDelay controls whether the operating system should delay
	// packet transmission in hopes of sending fewer packets (Nagle's algorithm).
	// When this option is assigned to TCPNoDelay, TCP_NODELAY socket option will
	// be turned on, on the contrary, if it is assigned to TCPDelay, the socket
	// option will be turned off.
	//
	// The default is TCPNoDelay, meaning that TCP_NODELAY is turned on and data
	// will not be buffered but sent as soon as possible after a write operation.
	TCPNoDelay TCPSocketOpt

	// SocketRecvBuffer sets the maximum socket receive buffer of kernel in bytes.
	SocketRecvBuffer int

	// SocketSendBuffer sets the maximum socket send buffer of kernel in bytes.
	SocketSendBuffer int

	// LogPath specifies a local path where logs will be written, this is the easiest
	// way to set up logging, gnet instantiates a default uber-go/zap logger with this
	// given log path, you are also allowed to employ your own logger during the lifetime
	// by implementing the following logging.Logger interface.
	//
	// Note that this option can be overridden by a non-nil option Logger.
	LogPath string

	// LogLevel specifies the logging level, it should be used along with LogPath.
	LogLevel logging.Level

	// Logger is the customized logger for logging info, if it is not set,
	// then gnet will use the default logger powered by go.uber.org/zap.
	Logger logging.Logger

	// EdgeTriggeredIO enables the edge-triggered I/O for the underlying epoll/kqueue event-loop.
	// Don't enable it unless you are 100% sure what you are doing.
	// Note that this option is only available for stream-oriented protocol.
	EdgeTriggeredIO bool

	// EdgeTriggeredIOChunk specifies the number of bytes that `gnet` can
	// read/write up to in one event loop of ET. This option implies
	// EdgeTriggeredIO when it is set to a value greater than 0.
	// If EdgeTriggeredIO is set to true and EdgeTriggeredIOChunk is not set,
	// 1MB is used. The value of EdgeTriggeredIOChunk must be a power of 2,
	// otherwise, it will be rounded up to the nearest power of 2.
	EdgeTriggeredIOChunk int
}

type Reader interface {
	io.Reader
	io.WriterTo

	// Next returns the next n bytes and advances the inbound buffer.
	// buf must not be used in a new goroutine. Otherwise, use Read instead.
	//
	// If the number of the available bytes is less than requested,
	// a pair of (0, io.ErrShortBuffer) is returned.
	Next(n int) (buf []byte, err error)

	// Peek returns the next n bytes without advancing the inbound buffer,
	// the returned bytes remain valid until a Discard is called.
	// buf must neither be used in a new goroutine nor anywhere after the call
	// to Discard, make a copy of buf manually or use Read otherwise.
	//
	// If the number of the available bytes is less than requested,
	// a pair of (0, io.ErrShortBuffer) is returned.
	Peek(n int) (buf []byte, err error)

	// Discard advances the inbound buffer with next n bytes, returning the number of bytes discarded.
	Discard(n int) (discarded int, err error)

	// InboundBuffered returns the number of bytes that can be read from the current buffer.
	InboundBuffered() int
}

type RegisteredResult struct {
	Conn Conn
	Err  error
}

type Runnable interface {
	Run(ctx context.Context) error
}

type RunnableFunc func(ctx context.Context) error

type Socket interface {
	Fd() int
	Dup() (int, error)
	SetReadBuffer(size int) error
	SetWriteBuffer(size int) error
	SetLinger(secs int) error
	SetKeepAlivePeriod(d time.Duration) error
	SetKeepAlive(enabled bool, idle, intvl time.Duration, cnt int) error
	SetNoDelay(noDelay bool) error
}

type TCPSocketOpt int

type Writer interface {
	io.Writer     // not concurrency-safe
	io.ReaderFrom // not concurrency-safe

	// SendTo transmits a message to the given address, it's not concurrency-safe.
	SendTo(buf []byte, addr net.Addr) (n int, err error)

	// Writev writes multiple byte slices to remote synchronously, it's not concurrency-safe.
	Writev(bs [][]byte) (n int, err error)

	// Flush writes any buffered data to the underlying connection, it's not concurrency-safe.
	Flush() error

	// OutboundBuffered returns the number of bytes that can be read from the current buffer.
	OutboundBuffered() int

	// AsyncWrite writes bytes to remote asynchronously, it's concurrency-safe.
	AsyncWrite(buf []byte, callback AsyncCallback) (err error)

	// AsyncWritev writes multiple byte slices to remote asynchronously.
	AsyncWritev(bs [][]byte, callback AsyncCallback) (err error)
}