plow

type BodyWriter interface {
	// WriteBody function allows you to send a content body to a specific node.
	WriteBody(io.Writer) error

	// ContentLength specifies size of the body
	// which can be passed in the 'Content-Length' header.
	ContentLength() int64
}

type Client struct {
	// Transport specifies the mechanism by which individual HTTP requests are made.
	// If nil, [DefaultTransport] is used.
	Transport RoundTripper

	// MaxRedirectCount maximum number of redirects
	// before getting an error.
	// if not specified is used [DefaultMaxRedirectCount]
	MaxRedirectCount int

	// Header specifies independent request header and cookies
	//
	// The Header is used to insert headers and cookies
	// into every outbound Request independent of url.
	// The Header is consulted for every redirect that the [Client] follows.
	//
	// If Header is nil, headers and cookies are only sent
	// if they are explicitly set on the [Request].
	Header *specs.Header

	// Jar specifies the cookie jar with dependent to url
	//
	// The Jar is used to insert relevant requested url cookies
	// into every outbound Request and is updated
	// with the cookie values of every inbound Response.
	// The Jar is consulted for every redirect that the [Client] follows.
	//
	// If Jar is nil, cookies are only sent
	// if they are explicitly set on the [Request].
	Jar *specs.CookieJar
	// contains filtered or unexported fields
}

type ClientRequest interface {
	// Method specifies the HTTP method (GET, POST, PUT, etc.)
	// to be sent by the client in HTTP request.
	Method() specs.HttpMethod

	// Url specifies the URL for client requests.
	Url() *specs.Url

	// Header contains the request header fields and cookies
	// to be sent by the client in HTTP request.
	Header() *specs.Header
}

type ClientResponse interface {
	// StatusCode specifies [specs.StatusCode] which
	// is received by the client.
	StatusCode() specs.StatusCode

	// Header contains the request header fields and cookies
	// which is received by the client.
	Header() *specs.Header

	// Body specifies [io.ReadCloser] response body
	// which is received by the client.
	//
	// if response body not provided return nil.
	Body() io.ReadCloser
}

type Dialer interface {
	// Dial connects to the address on the named network.
	Dial(ctx context.Context, network, address string) (net.Conn, error)
}

type DialerFunc func(ctx context.Context, network, address string) (net.Conn, error)

type ErrorHandler interface {
	HandleError(ctx context.Context, conn net.Conn, err any)
}

type ErrorHandlerFunc func(ctx context.Context, conn net.Conn, err any)

type Handler interface {
	Handle(ctx context.Context, request Request) Response
}

type HandlerFunc func(ctx context.Context, request Request) Response

type HijackHandler = server_ops.HijackHandler

type MarshallResponse interface {
	Response
	BodyWriter
	Instance() any
}

type NextProtoHandler func(conn *tls.Conn)

type Request interface {
	// ProtoVersion specifies protocol version of incoming server request.
	ProtoVersion() (major, minor uint16)

	// RemoteAddr specifies client [net.Addr] of incoming server request.
	RemoteAddr() net.Addr

	// Hijack lets the handler take over the connection.
	// After a call to Hijack the HTTP server library
	// will not do anything else with the connection when HTTP transaction ends.
	Hijack(handler HijackHandler)

	// Method specifies the HTTP method (GET, POST, PUT, etc.)
	// of incoming server request.
	Method() specs.HttpMethod

	// Url specifies the URL of incoming server request.
	Url() *specs.Url

	// Header contains the header fields and cookies
	// of incoming server request.
	Header() *specs.Header

	// Body specifies [io.Reader] of incoming server request.
	//
	// if request body not provided return nil.
	Body() io.Reader
}

type Response interface {
	// StatusCode specifies [specs.StatusCode] to be sent by the server in HTTP request.
	StatusCode() specs.StatusCode

	// Header contains the response header fields and cookies
	// to be sent by the server in HTTP response.
	Header() *specs.Header
}

type RoundTripper interface {
	// RoundTrip executes a single HTTP transaction,
	// returning a [ClientResponse] for the provided request parts.
	RoundTrip(ctx context.Context, method specs.HttpMethod, url *specs.Url, header *specs.Header, writer BodyWriter) (ClientResponse, error)
}

type RoundTripperFunc func(ctx context.Context, method specs.HttpMethod, url *specs.Url, header *specs.Header, writer BodyWriter) (ClientResponse, error)

type Server struct {

	// Handler defines the function to be called for handling each incoming HTTP request.
	// This is the main handler implementing the [Handler] interface, which processes requests and generates responses.
	// Handler must be safe for concurrent use, as the server may invoke it from multiple goroutines simultaneously.
	//
	// If Handler is nil, the server cannot process requests and will panic during initialization.
	// If Handler implements the [ErrorHandler] interface and [Server.ErrorHandler] is nil,
	// it will be used as the ErrorHandler.
	Handler Handler

	// ErrorHandler defines a function for handling errors that occur during HTTP request processing.
	// This can include read/write errors, protocol errors, internal server errors, and other exceptional situations.
	//
	// ErrorHandler is called with error details and request context, allowing custom logic for logging,
	// returning special HTTP responses, or collecting metrics. Must be safe for concurrent use, as the server
	// may invoke it from multiple goroutines simultaneously.
	//
	// If ErrorHandler is not set, the server may use default error handling
	// or try to use the Handler as an ErrorHandler if it implements the [ErrorHandler] interface.
	ErrorHandler ErrorHandler

	// FilterConn handles all new incoming connections to provide filtering by address
	// Returns true - accept, false - close connection
	FilterConn func(addr net.Addr) bool

	// ServerName for sending in response headers.
	ServerName string

	// TLSHandshakeTimeout specifies the maximum amount of time to
	// wait for a TLS handshake. Zero means no timeout.
	TLSHandshakeTimeout time.Duration

	// TLSConfig optionally provides a TLS configuration
	TLSConfig *tls.Config

	// ReadTimeout is the maximum duration for server the entire
	// request, including the body. A zero or negative value means
	// there will be no timeout.
	ReadTimeout time.Duration

	// WriteTimeout is the maximum duration before timing out
	// writes of the response. A zero or negative value means
	// there will be no timeout.
	WriteTimeout time.Duration

	// IdleTimeout is the maximum amount of time to wait for the
	// next request when keep-alive are enabled.
	//
	// If zero, the value of ReadTimeout is used.
	// If negative, or if zero and ReadTimeout
	// is zero or negative, there is no timeout.
	IdleTimeout time.Duration

	// ReadLineMaxLength maximum size in bytes
	// to read lines in the request
	// such as headers and headlines
	//
	// If zero there is no limit
	ReadLineMaxLength int64

	// HeadMaxLength maximum size in bytes
	// to read lines in the request
	// such as headline and headers together
	//
	// If zero there is no limit
	HeadMaxLength int64

	// MaxBodySize maximum size in bytes
	// to read request body size.
	//
	// The server responds ErrTooLarge if this limit is greater than 0
	// and response body is greater than the limit.
	//
	// By default, request body size is unlimited.
	MaxBodySize int64

	// MaxEncodingSize maximum size in bytes
	// of the response body that will be encoded (based on the "Accept-Encoding" header)
	// when transfer by size - "Content-Length", except { "Transfer-Encoding": "chunked" }
	//
	// if not specified, the encoding will be skipped
	MaxEncodingSize int64

	// DisableKeepAlive controls whether HTTP keep-alive are enabled.
	//
	// Only very resource-constrained environments or servers in the process of
	// shutting down should disable them.
	//
	// By default, keep-alive are always enabled.
	DisableKeepAlive bool
	// contains filtered or unexported fields
}

type TlsDialer interface {
	// Handshake connects to the address on the named network.
	Handshake(ctx context.Context, conn net.Conn, host string) (net.Conn, error)
}

type TlsDialerFunc func(ctx context.Context, conn net.Conn, host string) (net.Conn, error)

type Transport struct {

	// Dialer specifies the dialer for creating unencrypted TCP connections.
	// If Dialer is nil then the transport dials using package net
	Dialer Dialer

	// Proxy specifies a function to return a proxy for a given
	// Request. If the function returns a non-nil error, the
	// request is aborted with the provided error.
	//
	// The proxy type is determined by the URL scheme. "http",
	// "https", "socks5", and "socks5h" are supported. If the scheme is empty,
	// "http" is assumed.
	// "socks5" is treated the same as "socks5h".
	//
	// If the proxy specs.Url contains a username & password subcomponents,
	// the proxy request will pass the username and password
	// in a `Proxy-Authorization` header.
	//
	// If Proxy is nil or returns a nil *specs.Url, no proxy is used.
	Proxy func(url *specs.Url) (*specs.Url, error)

	// ProxyDialTimeout specifies the maximum amount of time to
	// wait for a Proxy establish connection.
	//
	// If zero there is no timeout.
	ProxyDialTimeout time.Duration

	// TLSDialer specifies an optional dial function for creating
	// TLS connections and gone handshake for non-proxied HTTPS requests.
	//
	// If TLSDialer is nil will be used [tls.Client].
	//
	// If TLSDialer is set, it is assumed
	// that the returned net.Conn has already gone through the TLS handshake.
	TLSDialer TlsDialer

	// TLSClientConfig specifies the TLS configuration
	// to use with tls.Client.
	//
	// If nil, the default configuration is used.
	// If non-nil, HTTP/2 support may not be enabled by default.
	TLSConfig *tls.Config

	// TLSHandshakeTimeout specifies the maximum amount of time to
	// wait for a TLS handshake. Zero means no timeout.
	TLSHandshakeTimeout time.Duration

	// ReadTimeout is the maximum duration for server the entire
	// response, including the body. A zero or negative value means
	// there will be no timeout.
	ReadTimeout time.Duration

	// WriteTimeout is the maximum duration before timing out
	// writes of the request. A zero or negative value means
	// there will be no timeout.
	WriteTimeout time.Duration

	// ReadLineMaxLength maximum size in bytes
	// to read lines in the response
	// such as headers and headlines
	//
	// The client returns specs.ErrTooLarge if this limit is greater than 0
	// and response lines is greater than the limit.
	//
	// If zero there is no limit
	ReadLineMaxLength int64

	// HeadMaxLength maximum size in bytes
	// to read headline and headers together
	//
	// The client returns specs.ErrTooLarge if this limit is greater than 0
	// and response header size is greater than the limit.
	//
	// If zero there is no limit
	HeadMaxLength int64

	// MaxBodySize maximum size in bytes
	// to read response body size.
	//
	// The client returns specs.ErrTooLarge if this limit is greater than 0
	// and response body is greater than the limit.
	//
	// By default, response body size is unlimited.
	MaxBodySize int64
	// contains filtered or unexported fields
}

type TransportHijacker struct {
	// Conn intercepted connection from Transport
	//
	// Can be nil if connection not stored
	Conn net.Conn
}