// Code generated by ogen, DO NOT EDIT.

package gen

import (
	"net/http"
	"strings"

	ht "github.com/ogen-go/ogen/http"
	"github.com/ogen-go/ogen/middleware"
	"github.com/ogen-go/ogen/ogenerrors"
	"github.com/ogen-go/ogen/ogenregex"
	"github.com/ogen-go/ogen/otelogen"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/metric"
	"go.opentelemetry.io/otel/trace"
)

var regexMap = map[string]ogenregex.Regexp{
	"(.)([0-9а-яА-Яa-zA-Z]+)(.)": ogenregex.MustCompile("(.)([0-9а-яА-Яa-zA-Z]+)(.)"),
	"(?s).{1,210}":               ogenregex.MustCompile("(?s).{1,210}"),
	"([\\d]{20})|(0)":            ogenregex.MustCompile("([\\d]{20})|(0)"),
	"([\\d]{8})|(0)":             ogenregex.MustCompile("([\\d]{8})|(0)"),
	"(^00[1-9]{1}$)|(^0[1-6]{1}[0-9]{1}$)|(^07[0-3]{1}$)": ogenregex.MustCompile("(^00[1-9]{1}$)|(^0[1-6]{1}[0-9]{1}$)|(^07[0-3]{1}$)"),
	"[0-9]{1,150}":             ogenregex.MustCompile("[0-9]{1,150}"),
	"[0-9]{10}":                ogenregex.MustCompile("[0-9]{10}"),
	"[0-9]{11,33}":             ogenregex.MustCompile("[0-9]{11,33}"),
	"[0-9]{14,19}":             ogenregex.MustCompile("[0-9]{14,19}"),
	"[0-9]{16,19}":             ogenregex.MustCompile("[0-9]{16,19}"),
	"[0-9]{24}":                ogenregex.MustCompile("[0-9]{24}"),
	"[0-9]{2}":                 ogenregex.MustCompile("[0-9]{2}"),
	"[0-9]{4,15}":              ogenregex.MustCompile("[0-9]{4,15}"),
	"[0-9]{4}":                 ogenregex.MustCompile("[0-9]{4}"),
	"[0-9]{6}":                 ogenregex.MustCompile("[0-9]{6}"),
	"[0-9]{9}":                 ogenregex.MustCompile("[0-9]{9}"),
	"[0-9a-zA-Z+-_.]{1,64}":    ogenregex.MustCompile("[0-9a-zA-Z+-_.]{1,64}"),
	"[A-Z]{3}":                 ogenregex.MustCompile("[A-Z]{3}"),
	"[a-zA-Z '-]{0,26}":        ogenregex.MustCompile("[a-zA-Z '-]{0,26}"),
	"[a-zA-Z0-9]{12}":          ogenregex.MustCompile("[a-zA-Z0-9]{12}"),
	"\\d{1,20}":                ogenregex.MustCompile("\\d{1,20}"),
	"\\d{10}|\\d{12}":          ogenregex.MustCompile("\\d{10}|\\d{12}"),
	"\\d{20}":                  ogenregex.MustCompile("\\d{20}"),
	"\\d{9}":                   ogenregex.MustCompile("\\d{9}"),
	"^[0]{1}$":                 ogenregex.MustCompile("^[0]{1}$"),
	"^[\\-a-zA-Zа-яёА-ЯЁ ]]*$": ogenregex.MustCompile("^[\\-a-zA-Zа-яёА-ЯЁ ]]*$"),
}
var (
	// Allocate option closure once.
	clientSpanKind = trace.WithSpanKind(trace.SpanKindClient)
	// Allocate option closure once.
	serverSpanKind = trace.WithSpanKind(trace.SpanKindServer)
)

type (
	optionFunc[C any] func(*C)
	otelOptionFunc    func(*otelConfig)
)

type otelConfig struct {
	TracerProvider trace.TracerProvider
	Tracer         trace.Tracer
	MeterProvider  metric.MeterProvider
	Meter          metric.Meter
	Attributes     []attribute.KeyValue
}

func (cfg *otelConfig) initOTEL() {
	if cfg.TracerProvider == nil {
		cfg.TracerProvider = otel.GetTracerProvider()
	}
	if cfg.MeterProvider == nil {
		cfg.MeterProvider = otel.GetMeterProvider()
	}
	cfg.Tracer = cfg.TracerProvider.Tracer(otelogen.Name,
		trace.WithInstrumentationVersion(otelogen.SemVersion()),
	)
	cfg.Meter = cfg.MeterProvider.Meter(otelogen.Name,
		metric.WithInstrumentationVersion(otelogen.SemVersion()),
	)
}

// ErrorHandler is error handler.
type ErrorHandler = ogenerrors.ErrorHandler

type serverConfig struct {
	otelConfig
	NotFound           http.HandlerFunc
	MethodNotAllowed   func(w http.ResponseWriter, r *http.Request, allowed string)
	ErrorHandler       ErrorHandler
	Prefix             string
	Middleware         Middleware
	MaxMultipartMemory int64
}

// ServerOption is server config option.
type ServerOption interface {
	applyServer(*serverConfig)
}

var _ ServerOption = (optionFunc[serverConfig])(nil)

func (o optionFunc[C]) applyServer(c *C) {
	o(c)
}

var _ ServerOption = (otelOptionFunc)(nil)

func (o otelOptionFunc) applyServer(c *serverConfig) {
	o(&c.otelConfig)
}

func newServerConfig(opts ...ServerOption) serverConfig {
	cfg := serverConfig{
		NotFound:           http.NotFound,
		MethodNotAllowed:   nil,
		ErrorHandler:       ogenerrors.DefaultErrorHandler,
		Middleware:         nil,
		MaxMultipartMemory: 32 << 20, // 32 MB
	}
	for _, opt := range opts {
		opt.applyServer(&cfg)
	}
	cfg.initOTEL()
	return cfg
}

type baseServer struct {
	cfg      serverConfig
	requests metric.Int64Counter
	errors   metric.Int64Counter
	duration metric.Float64Histogram
}

func (s baseServer) notFound(w http.ResponseWriter, r *http.Request) {
	s.cfg.NotFound(w, r)
}

type notAllowedParams struct {
	allowedMethods string
	allowedHeaders map[string]string
	acceptPost     string
	acceptPatch    string
}

func (s baseServer) notAllowed(w http.ResponseWriter, r *http.Request, params notAllowedParams) {
	h := w.Header()
	isOptions := r.Method == "OPTIONS"
	if isOptions {
		h.Set("Access-Control-Allow-Methods", params.allowedMethods)
		if params.allowedHeaders != nil {
			m := r.Header.Get("Access-Control-Request-Method")
			if m != "" {
				allowedHeaders, ok := params.allowedHeaders[strings.ToUpper(m)]
				if ok {
					h.Set("Access-Control-Allow-Headers", allowedHeaders)
				}
			}
		}
		if params.acceptPost != "" {
			h.Set("Accept-Post", params.acceptPost)
		}
		if params.acceptPatch != "" {
			h.Set("Accept-Patch", params.acceptPatch)
		}
	}
	if s.cfg.MethodNotAllowed != nil {
		s.cfg.MethodNotAllowed(w, r, params.allowedMethods)
		return
	}
	status := http.StatusNoContent
	if !isOptions {
		h.Set("Allow", params.allowedMethods)
		status = http.StatusMethodNotAllowed
	}
	w.WriteHeader(status)
}

func (cfg serverConfig) baseServer() (s baseServer, err error) {
	s = baseServer{cfg: cfg}
	if s.requests, err = otelogen.ServerRequestCountCounter(s.cfg.Meter); err != nil {
		return s, err
	}
	if s.errors, err = otelogen.ServerErrorsCountCounter(s.cfg.Meter); err != nil {
		return s, err
	}
	if s.duration, err = otelogen.ServerDurationHistogram(s.cfg.Meter); err != nil {
		return s, err
	}
	return s, nil
}

type clientConfig struct {
	otelConfig
	Client ht.Client
}

// ClientOption is client config option.
type ClientOption interface {
	applyClient(*clientConfig)
}

var _ ClientOption = (optionFunc[clientConfig])(nil)

func (o optionFunc[C]) applyClient(c *C) {
	o(c)
}

var _ ClientOption = (otelOptionFunc)(nil)

func (o otelOptionFunc) applyClient(c *clientConfig) {
	o(&c.otelConfig)
}

func newClientConfig(opts ...ClientOption) clientConfig {
	cfg := clientConfig{
		Client: http.DefaultClient,
	}
	for _, opt := range opts {
		opt.applyClient(&cfg)
	}
	cfg.initOTEL()
	return cfg
}

type baseClient struct {
	cfg      clientConfig
	requests metric.Int64Counter
	errors   metric.Int64Counter
	duration metric.Float64Histogram
}

func (cfg clientConfig) baseClient() (c baseClient, err error) {
	c = baseClient{cfg: cfg}
	if c.requests, err = otelogen.ClientRequestCountCounter(c.cfg.Meter); err != nil {
		return c, err
	}
	if c.errors, err = otelogen.ClientErrorsCountCounter(c.cfg.Meter); err != nil {
		return c, err
	}
	if c.duration, err = otelogen.ClientDurationHistogram(c.cfg.Meter); err != nil {
		return c, err
	}
	return c, nil
}

// Option is config option.
type Option interface {
	ServerOption
	ClientOption
}

// WithTracerProvider specifies a tracer provider to use for creating a tracer.
//
// If none is specified, the global provider is used.
func WithTracerProvider(provider trace.TracerProvider) Option {
	return otelOptionFunc(func(cfg *otelConfig) {
		if provider != nil {
			cfg.TracerProvider = provider
		}
	})
}

// WithMeterProvider specifies a meter provider to use for creating a meter.
//
// If none is specified, the otel.GetMeterProvider() is used.
func WithMeterProvider(provider metric.MeterProvider) Option {
	return otelOptionFunc(func(cfg *otelConfig) {
		if provider != nil {
			cfg.MeterProvider = provider
		}
	})
}

// WithAttributes specifies default otel attributes.
func WithAttributes(attributes ...attribute.KeyValue) Option {
	return otelOptionFunc(func(cfg *otelConfig) {
		cfg.Attributes = attributes
	})
}

// WithClient specifies http client to use.
func WithClient(client ht.Client) ClientOption {
	return optionFunc[clientConfig](func(cfg *clientConfig) {
		if client != nil {
			cfg.Client = client
		}
	})
}

// WithNotFound specifies Not Found handler to use.
func WithNotFound(notFound http.HandlerFunc) ServerOption {
	return optionFunc[serverConfig](func(cfg *serverConfig) {
		if notFound != nil {
			cfg.NotFound = notFound
		}
	})
}

// WithMethodNotAllowed specifies Method Not Allowed handler to use.
func WithMethodNotAllowed(methodNotAllowed func(w http.ResponseWriter, r *http.Request, allowed string)) ServerOption {
	return optionFunc[serverConfig](func(cfg *serverConfig) {
		if methodNotAllowed != nil {
			cfg.MethodNotAllowed = methodNotAllowed
		}
	})
}

// WithErrorHandler specifies error handler to use.
func WithErrorHandler(h ErrorHandler) ServerOption {
	return optionFunc[serverConfig](func(cfg *serverConfig) {
		if h != nil {
			cfg.ErrorHandler = h
		}
	})
}

// WithPathPrefix specifies server path prefix.
func WithPathPrefix(prefix string) ServerOption {
	return optionFunc[serverConfig](func(cfg *serverConfig) {
		cfg.Prefix = prefix
	})
}

// WithMiddleware specifies middlewares to use.
func WithMiddleware(m ...Middleware) ServerOption {
	return optionFunc[serverConfig](func(cfg *serverConfig) {
		switch len(m) {
		case 0:
			cfg.Middleware = nil
		case 1:
			cfg.Middleware = m[0]
		default:
			cfg.Middleware = middleware.ChainMiddlewares(m...)
		}
	})
}

// WithMaxMultipartMemory specifies limit of memory for storing file parts.
// File parts which can't be stored in memory will be stored on disk in temporary files.
func WithMaxMultipartMemory(max int64) ServerOption {
	return optionFunc[serverConfig](func(cfg *serverConfig) {
		if max > 0 {
			cfg.MaxMultipartMemory = max
		}
	})
}