streaming

type Args struct {
	ServerStream ServerStream
	ClientStream ClientStream
	// for gRPC compatible
	Stream Stream
}

type BidiStreamingClient[Req, Res any] interface {
	Send(ctx context.Context, req *Req) error
	Recv(ctx context.Context) (*Res, error)
	ClientStream
}

type BidiStreamingServer[Req, Res any] interface {
	Recv(ctx context.Context) (*Req, error)
	Send(ctx context.Context, res *Res) error
	ServerStream
}

type ClientStream interface {
	// SendMsg send message to peer
	// will block until an error or enough buffer to send
	// not concurrent-safety
	SendMsg(ctx context.Context, m any) error
	// RecvMsg recvive message from peer
	// will block until an error or a message received
	// not concurrent-safety
	RecvMsg(ctx context.Context, m any) error
	// Header returns the header info received from the server if there
	// is any. It blocks if the header info is not ready to read.  If the header info
	// is nil and the error is also nil, then the stream was terminated without
	// headers, and the error can be discovered by calling RecvMsg.
	Header() (Header, error)
	// Trailer returns the trailer info from the server, if there is any.
	// It must only be called after stream.CloseAndRecv has returned, or
	// stream.Recv has returned a non-nil error (including io.EOF).
	Trailer() (Trailer, error)
	// CloseSend closes the send direction of the stream. It closes the stream
	// when non-nil error is met. It is also not safe to call CloseSend
	// concurrently with SendMsg.
	CloseSend(ctx context.Context) error
	// Context the stream context.Context
	Context() context.Context
}

type ClientStreamingClient[Req, Res any] interface {
	Send(ctx context.Context, req *Req) error
	CloseAndRecv(ctx context.Context) (*Res, error)
	ClientStream
}

type ClientStreamingServer[Req, Res any] interface {
	Recv(ctx context.Context) (*Req, error)
	SendAndClose(ctx context.Context, res *Res) error
	ServerStream
}

type CloseCallbackRegister interface {
	RegisterCloseCallback(cb func(error))
}

type EventHandler func(ctx context.Context, evt stats.Event, err error)

type GRPCStreamGetter interface {
	GetGRPCStream() Stream
}

type Header map[string]string

type Result struct {
	ServerStream ServerStream
	ClientStream ClientStream
	// for gRPC compatible
	Stream Stream
}

type ServerStream interface {
	// SendMsg send message to peer
	// will block until an error or enough buffer to send
	// not concurrent-safety
	SendMsg(ctx context.Context, m any) error
	// RecvMsg recvive message from peer
	// will block until an error or a message received
	// not concurrent-safety
	RecvMsg(ctx context.Context, m any) error
	// SetHeader sets the header info. It may be called multiple times.
	// When call multiple times, all the provided header info will be merged.
	// All the header info will be sent out when one of the following happens:
	//  - ServerStream.SendHeader() is called;
	//  - The first response is sent out;
	//  - The server handler returns (error or nil).
	SetHeader(hd Header) error
	// SendHeader sends the header info.
	// The provided hd and headers set by SetHeader() will be sent.
	// It fails if called multiple times or called after the first response is sent out.
	SendHeader(hd Header) error
	// SetTrailer sets the trailer info which will be sent with the RPC status.
	// When called more than once, all the provided trailer info will be merged.
	SetTrailer(hd Trailer) error
}

type ServerStreamingClient[Res any] interface {
	Recv(ctx context.Context) (*Res, error)
	ClientStream
}

type ServerStreamingServer[Res any] interface {
	Send(ctx context.Context, res *Res) error
	ServerStream
}

type Stream interface {
	// SetHeader sets the header metadata. It may be called multiple times.
	// When call multiple times, all the provided metadata will be merged.
	// All the metadata will be sent out when one of the following happens:
	//  - ServerStream.SendHeader() is called;
	//  - The first response is sent out;
	//  - An RPC status is sent out (error or success).
	SetHeader(metadata.MD) error
	// SendHeader sends the header metadata.
	// The provided md and headers set by SetHeader() will be sent.
	// It fails if called multiple times.
	SendHeader(metadata.MD) error
	// SetTrailer sets the trailer metadata which will be sent with the RPC status.
	// When called more than once, all the provided metadata will be merged.
	SetTrailer(metadata.MD)
	// Header is used for client side stream to receive header from server.
	Header() (metadata.MD, error)
	// Trailer is used for client side stream to receive trailer from server.
	Trailer() metadata.MD
	// Context the stream context.Context
	Context() context.Context
	// RecvMsg recvive message from peer
	// will block until an error or a message received
	// not concurrent-safety
	RecvMsg(m interface{}) error
	// SendMsg send message to peer
	// will block until an error or enough buffer to send
	// not concurrent-safety
	SendMsg(m interface{}) error
	// not concurrent-safety with SendMsg
	io.Closer
}

type Trailer map[string]string

type WithDoFinish interface {
	DoFinish(error)
}