package middleware

import (
	"context"
	"net/http"
	"sync"

	"git.frostfs.info/TrueCloudLab/frostfs-observability/tracing"
	"go.opentelemetry.io/otel/attribute"
	semconv "go.opentelemetry.io/otel/semconv/v1.18.0"
	"go.opentelemetry.io/otel/trace"
)

// Tracing adds tracing support for requests.
// Must be placed after prepareRequest middleware.
func Tracing() Func {
	return func(h http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			appCtx, span := StartHTTPServerSpan(r, "REQUEST S3")
			lw := &traceResponseWriter{ResponseWriter: w, ctx: appCtx, span: span}
			h.ServeHTTP(lw, r.WithContext(appCtx))
		})
	}
}

type traceResponseWriter struct {
	sync.Once
	http.ResponseWriter

	ctx  context.Context
	span trace.Span
}

func (lrw *traceResponseWriter) WriteHeader(code int) {
	lrw.Do(func() {
		lrw.span.SetAttributes(
			semconv.HTTPStatusCode(code),
		)

		carrier := &httpResponseCarrier{resp: lrw.ResponseWriter}
		tracing.Propagator.Inject(lrw.ctx, carrier)

		lrw.ResponseWriter.WriteHeader(code)
		lrw.span.End()
	})
}

func (lrw *traceResponseWriter) Flush() {
	if f, ok := lrw.ResponseWriter.(http.Flusher); ok {
		f.Flush()
	}
}

type httpResponseCarrier struct {
	resp http.ResponseWriter
}

func (h httpResponseCarrier) Get(key string) string {
	return h.resp.Header().Get(key)
}

func (h httpResponseCarrier) Set(key string, value string) {
	h.resp.Header().Set(key, value)
}

func (h httpResponseCarrier) Keys() []string {
	result := make([]string, 0, len(h.resp.Header()))
	for key := range h.resp.Header() {
		result = append(result, key)
	}

	return result
}

type httpRequestCarrier struct {
	req *http.Request
}

func (c *httpRequestCarrier) Get(key string) string {
	bytes := c.req.Header.Get(key)
	if len(bytes) == 0 {
		return ""
	}
	return bytes
}

func (c *httpRequestCarrier) Set(key string, value string) {
	c.req.Response.Header.Set(key, value)
}

func (c *httpRequestCarrier) Keys() []string {
	result := make([]string, 0, len(c.req.Header))
	for key := range c.req.Header {
		result = append(result, key)
	}

	return result
}

func extractHTTPTraceInfo(ctx context.Context, req *http.Request) context.Context {
	if req == nil {
		return ctx
	}
	carrier := &httpRequestCarrier{req: req}
	return tracing.Propagator.Extract(ctx, carrier)
}

// StartHTTPServerSpan starts root HTTP server span.
func StartHTTPServerSpan(r *http.Request, operationName string, opts ...trace.SpanStartOption) (context.Context, trace.Span) {
	ctx := extractHTTPTraceInfo(r.Context(), r)
	opts = append(opts, trace.WithAttributes(
		attribute.String("s3.client_address", r.RemoteAddr),
		attribute.String("s3.path", r.Host),
		attribute.String("s3.request_id", GetRequestID(r.Context())),
		semconv.HTTPMethod(r.Method),
		semconv.RPCService("frostfs-s3-gw"),
		attribute.String("s3.query", r.RequestURI),
	), trace.WithSpanKind(trace.SpanKindServer))
	return tracing.StartSpanFromContext(ctx, operationName, opts...)
}