sockety

type BufferedReader interface {
	Len() offset
	MayHave(size offset) bool
	ReadByte() (byte, error)
	Read(target []byte) (offset, error)
	Preload() error
}

type ChannelID uint16

type ChannelManager interface {
	Current() ChannelID           // not thread-safe
	Is(id ChannelID) bool         // not thread-safe
	SetCurrent(channel ChannelID) // not thread-safe
	GetFree() ChannelID           // not thread-safe
	Reserve() ChannelID
	Release(channel ChannelID)
}

type Conn interface {
	LocalAddr() net.Addr
	RemoteAddr() net.Addr

	Request(p ProducerWithRequest) Request
	Pass(p Producer) error

	Close() error

	ReadDone() <-chan struct{}
	ConnectionClosed() <-chan struct{}
	Done() <-chan struct{}

	Messages() <-chan Message
	Responses() <-chan Response
	FastReplies() <-chan FastReply
}

type ConnOptions struct {
	Channels         uint16        // default: max
	WriteChannels    uint16        // default: max
	BufferedMessages uint16        // default: 0
	ReadBufferSize   uint32        // default: 4096
	Timeout          time.Duration // default: 0 = none
}

type FastReply struct {
	Code Uint12
	Id   uuid.UUID
}

type GoAway interface {
}

type Message interface {
	Id() uuid.UUID
	Action() string
	DataSize() uint64
	TotalFilesSize() uint64
	FilesCount() uint32
	ExpectsResponse() bool
	Stream() MessageStream
	Data() MessageData
}

type MessageData interface {
	io.Reader
	Received() uint64
	Size() uint64
	Done() bool
}

type MessageDraft struct {
	HasStream bool
	Action    string
	Data      []byte
}

type MessageStream interface {
	io.Reader
	Received() uint64
	Done() bool
}

type Parser interface {
	Read() (ParserResult, error)
}

type ParserChannelOptions struct {
}

type ParserChannelResult interface {
	message | Response
}

type ParserOptions struct {
	Channels   uint16
	BufferSize uint32
}

type ParserResult interface {
	message | Response | FastReply | GoAway
}

type Producer interface {
	// contains filtered or unexported methods
}

type ProducerWithRequest interface {
	// contains filtered or unexported methods
}

type Request interface {
	Id() uuid.UUID
	Stream() io.WriteCloser
	Send() error
	Initiated() <-chan struct{}
	Done() <-chan struct{}
}

type Response interface {
}

type Server interface {
	Listen(network string, address string) error
	ListenContext(context context.Context, network string, address string) error
	Close() error

	Accept() (Conn, error)
	Next() <-chan Conn
	Done() <-chan struct{}
}

type ServerOptions struct {
	HandleError      func(e error) // default: ignore errors TODO?
	Timeout          time.Duration // default: none TODO?
	Channels         uint16        // default: max
	WriteChannels    uint16        // default: max
	ReadBufferSize   uint32        // per connection, default: 4096
	BufferedMessages uint16        // per connection, default: 0

}

type Uint12 uint16

type Uint24 uint32

type Uint48 uint64

type Writer interface {
	ObtainChannel() ChannelID
	ReleaseChannel(channel ChannelID)

	WriteRaw(data []byte) error

	WriteStandalone(p packet) error
	Write(p packet) error
	WriteAndObtainChannel(p packet) (ChannelID, error)
	WriteRawAtChannel(channel ChannelID, data []byte) error
	WriteAtChannel(channel ChannelID, p packet) error
	WriteAndReleaseChannel(channel ChannelID, p packet) error
	WriteExternalWithSignatureAtChannel(channel ChannelID, signature uint8, data []byte) error
}

type WriterOptions struct {
	Channels uint16
}