http

func (*StdHTTP) Handle(m, p string, h Handler)
{
	final := h.(http.Handler)
	for i := len(s.mwChain) - 1; i >= 0; i-- {
		final = s.mwChain[i](final).(http.Handler)
	}

	switch m {
	case http.MethodGet:
		s.mux.Handle(p, final)
	default:
		s.mux.HandleFunc(p, func(w http.ResponseWriter, r *http.Request) {
			if r.Method != m {
				http.NotFound(w, r)
				return
			}
			final.ServeHTTP(w, r)
		})
	}
}

func (*Transport) Register(prototype core.Handler)
{
	t.handlers = append(t.handlers, prototype)
	val := reflect.ValueOf(prototype)
	if val.Kind() != reflect.Ptr || val.Elem().Kind() != reflect.Struct {
		panic("Transport.Register: prototype must be a pointer to a struct")
	}

	elemType := val.Elem().Type()

	var method, path string
	for i := 0; i < elemType.NumField(); i++ {
		field := elemType.Field(i)
		if field.Type == reflect.TypeOf(core.Pattern{}) {
			method = field.Tag.Get("method")
			path = field.Tag.Get("path")
			break
		}
	}

	if method == "" || path == "" {
		panic(fmt.Sprintf("Transport.Register: struct %s missing Pattern with method/path tags", elemType.Name()))
	}

	fullPath := t.prefix + path
	pattern := fmt.Sprintf("%s %s", method, fullPath)

	t.Logger.Info("Registering route", "route", pattern, "handler", elemType.Name())

	var finalHandler http.Handler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		// Create new instance
		newVal := reflect.New(elemType).Elem()
		newVal.Set(val.Elem())

		instance := newVal.Addr().Interface()

		// Inject dependencies
		t.container.Inject(instance)

		// Bind request data
		binder := core.NewBinder()
		binder.AddSource("path", func(key string) string { return req.PathValue(key) })
		binder.AddSource("query", func(key string) string { return req.URL.Query().Get(key) })
		binder.AddSource("header", func(key string) string { return req.Header.Get(key) })

		if err := binder.Bind(instance); err != nil {
			http.Error(w, fmt.Sprintf("Bad Request: %v", err), http.StatusBadRequest)
			return
		}

		// Bind JSON body if present
		contentType := req.Header.Get("Content-Type")
		if req.Body != nil && strings.HasPrefix(contentType, "application/json") {
			body, _ := io.ReadAll(req.Body)
			if len(body) > 0 {
				binder.BindJSON(instance, body)
			}
		}

		// Execute
		handler := instance.(core.Handler)

		// Inject HTTP context
		ctx := req.Context()
		ctx = context.WithValue(ctx, "http_request", req)
		ctx = context.WithValue(ctx, "http_response_writer", w)

		resp, err := handler.Handle(ctx)
		if err != nil {
			t.Logger.Error("Handler failed", "error", err)

			code := http.StatusInternalServerError
			var resp any = map[string]string{"error": err.Error()}

			// Check for optional interfaces
			type StatusCoder interface {
				StatusCode() int
			}
			type Payloader interface {
				Payload() any
			}

			if sc, ok := err.(StatusCoder); ok {
				code = sc.StatusCode()
			}
			if pl, ok := err.(Payloader); ok {
				resp = pl.Payload()
			}

			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(code)
			json.NewEncoder(w).Encode(resp)
			return
		}

		// Write response
		if resp != nil {
			w.Header().Set("Content-Type", "application/json")
			json.NewEncoder(w).Encode(resp)
		} else {
			w.WriteHeader(http.StatusNoContent)
		}
	})

	// Apply middleware
	for i := len(t.middleware) - 1; i >= 0; i-- {
		finalHandler = t.middleware[i](finalHandler)
	}

	t.mux.Handle(pattern, finalHandler)
}