api

type BasicAuth struct {
	User   string
	Passwd string
}

type BatchElem struct {
	Method string
	Args   interface{}
	// The result is unmarshalled into this field. Result must be set to a
	// non-nil pointer value of the desired type, otherwise the response will be
	// discarded.
	Result interface{}
	// Error is set if the server returns an error for this request, or if
	// unmarshalling into Result fails. It is not set for I/O errors.
	Error error
}

type Client interface {
	GetType() ClientType
	CallJsonRpc(result interface{}, method string, args interface{}) error
	BatchCallJsonRpc(b []BatchElem) error
	RawCallHttp(method string, path string, body interface{}) (*HttpResponse, error)
	Close() error

	// The WriteByWs ending with "WS" are only intended for WebSocket clients
	WriteByWs(WSMessage) error
	ErrFromWS() chan error

	// The UnderlyingHandle is only intended for grpc clients now
	UnderlyingHandle() interface{}
}

type ClientAdapter struct{}

type ClientOption struct {
	JsonRpcOpt *JsonRpcOption

	// http auth
	Heads http.Header

	// websocket
	RevChan interface{}
}

type ClientType int

type Context interface {
	CtxID() interface{}
	ClientIP() string
	WithValue(key string, value any)
	Value(key string) (any, bool)
}

type HttpResponse struct {
	StatusCode int
	Body       []byte
}

type JsonRpcError struct {
	Code    int         `json:"code"`
	Message string      `json:"message"`
	Data    interface{} `json:"data,omitempty"`
}

type JsonRpcNotifier interface {
	Notify(sub *SubscriptionNotice) error
	ID() string
	Err() chan error
}

type JsonRpcOption struct {
	Codec codec.CodecType
}

type JsonRpcRequest struct {
	Version string `json:"jsonrpc"`
	Method  string `json:"method"`
	// Params should be json.RawMessage. However, in fact, since the params parameter in the request body is already
	// an interface after the data is deserialized into a map, if it is set to json.rawMessage,
	// essentially a conversion process is required. In other words, the type of the value in map after deserialization
	// is interface{}, and the interface{} cannot be forced to be converted to json.RawMessage
	Params interface{} `json:"params,omitempty"`
	Id     interface{} `json:"id"`
}

type JsonRpcResponse struct {
	Version string          `json:"jsonrpc"`
	Id      interface{}     `json:"id"`
	Result  json.RawMessage `json:"result,omitempty"`
	Error   *JsonRpcError   `json:"error,omitempty"`
}

type RawHttpContext interface {
	Context
	Param(key string) string
	Query(key string) string
	WriteData(code int, contType string, data []byte) error
}

type RawHttpHandle func(RawHttpContext, []byte)

type RawWSNotifier interface {
	Write(WSMessage) error
	ID() string
	Err() chan error
}

type RawWsHandle func(Context, WSMessage) error

type ServerOption struct {
	Addr        string
	ClusterName string

	Logger log.Logger

	JsonRpcOpt *JsonRpcOption

	BeforeRun          func() error
	EnableInnerService bool
}

type SubscriptionNotice struct {
	Version string             `json:"jsonrpc"`
	Method  string             `json:"method"`
	Params  SubscriptionResult `json:"params,omitempty"`
}

type SubscriptionResult struct {
	ID     interface{}     `json:"subscription"`
	Result json.RawMessage `json:"result,omitempty"`
}

type WSMessage struct {
	Type WSMessageType
	Data []byte
}

type WSMessageType int

type WithHttpHeader func(http.Header)