utils.go

package httpx

import (
	"encoding"
	"encoding/json"
	"errors"
	"fmt"
	"log/slog"
	"net/http"
	"net/url"
	"reflect"
	"strconv"
	"strings"
	"time"
)

// wrappedWriter captures status codes for logging
type wrappedWriter struct {
	http.ResponseWriter
	statusCode int
}

func (w *wrappedWriter) WriteHeader(statusCode int) {
	w.ResponseWriter.WriteHeader(statusCode)
	w.statusCode = statusCode
}

func defaultLogger(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		start := time.Now()

		responseWriter := &wrappedWriter{
			ResponseWriter: w,
			statusCode:     http.StatusOK,
		}

		next.ServeHTTP(responseWriter, r)

		logFields := []slog.Attr{
			slog.String("method", r.Method),
			slog.Int("statusCode", responseWriter.statusCode),
			slog.Duration("latency", time.Since(start)),
			slog.Time("time", start),
		}

		if responseWriter.statusCode >= 200 && responseWriter.statusCode < 400 {
			slog.LogAttrs(r.Context(), slog.LevelInfo, r.URL.Path, logFields...)
		} else {
			slog.LogAttrs(r.Context(), slog.LevelError, r.URL.Path, logFields...)
		}
	})
}

func defaultErrorHandler(fn HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		err := fn(w, r)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
	}
}

// JSON writes a JSON response with the given status code and body.
// It sets the Content-Type header to "application/json" and encodes the body using json.Encoder.
// Returns an error if the JSON encoding fails.
//
// Example:
//
//	func GetUser(w http.ResponseWriter, r *http.Request) error {
//	    user := User{ID: 1, Name: "John"}
//	    return httpx.JSON(w, http.StatusOK, user)
//	}
func JSON(w http.ResponseWriter, status int, body any) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	if err := json.NewEncoder(w).Encode(body); err != nil {
		return fmt.Errorf("httpx JSON err: %w", err)
	}

	return nil
}

var (
	ErrNotStruct       = errors.New("out is not a struct")
	ErrNotPointer      = errors.New("out must be a pointer")
	ErrUnsupportedType = errors.New("unsupported type")
)

func tryTextUnmarshal(v reflect.Value, raw string) (bool, error) {
	// Pointer receiver
	if v.CanAddr() {
		if u, ok := v.Addr().Interface().(encoding.TextUnmarshaler); ok {
			return true, u.UnmarshalText([]byte(raw))
		}
	}

	// Value receiver
	if v.CanInterface() {
		if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
			return true, u.UnmarshalText([]byte(raw))
		}
	}

	return false, nil
}

func parseAndSet(value reflect.Value, raw string) error {
	ok, err := tryTextUnmarshal(value, raw)
	if err != nil {
		return err
	} else if ok {
		return nil
	}

	switch value.Kind() {
	case reflect.String:
		value.SetString(raw)

	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		i, err := strconv.ParseInt(raw, 10, 64)
		if err != nil || value.OverflowInt(i) {
			return err
		}
		value.SetInt(i)

	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		u, err := strconv.ParseUint(raw, 10, 64)
		if err != nil || value.OverflowUint(u) {
			return err
		}
		value.SetUint(u)

	case reflect.Bool:
		b, err := strconv.ParseBool(raw)
		if err != nil {
			return err
		}
		value.SetBool(b)

	case reflect.Float32, reflect.Float64:
		f, err := strconv.ParseFloat(raw, 64)
		if err != nil || value.OverflowFloat(f) {
			return err
		}
		value.SetFloat(f)

	default:
		return fmt.Errorf("%s: %w", value.Kind(), ErrUnsupportedType)
	}

	return nil
}

func decodeQueryParamsWithPrefix(v reflect.Value, queries url.Values, prefix string) error {
	t := v.Type()

	for i := 0; i < t.NumField(); i++ {
		fieldType := t.Field(i)
		fieldValue := v.Field(i)

		if !fieldType.IsExported() || !fieldValue.CanSet() {
			continue
		}

		tag := fieldType.Tag.Get("query")
		if tag == "-" {
			continue
		} else if tag == "" {
			tag = fieldType.Name
		}

		// Build the full query key with prefix
		queryKey := tag
		if prefix != "" {
			queryKey = prefix + "." + tag
		}

		// Check if we have values for this key
		values, hasDirectValue := queries[queryKey]

		// Handle pointer fields
		if fieldValue.Kind() == reflect.Pointer {
			elemType := fieldValue.Type().Elem()

			// Initialize pointer if needed and we have data for it
			if fieldValue.IsNil() && (hasDirectValue || hasNestedValues(queries, queryKey)) {
				fieldValue.Set(reflect.New(elemType))
			}

			if !fieldValue.IsNil() {
				fieldValue = fieldValue.Elem()
			} else {
				continue
			}
		}

		if hasDirectValue {
			if fieldValue.Kind() == reflect.Slice {
				// Try TextUnmarshaler first
				ok, err := tryTextUnmarshal(fieldValue, values[0])
				if err != nil {
					return err
				} else if ok {
					continue
				}

				elemType := fieldValue.Type().Elem()
				slice := reflect.MakeSlice(fieldValue.Type(), 0, len(values))

				for _, raw := range values {
					elem := reflect.New(elemType).Elem()
					if err := parseAndSet(elem, raw); err != nil {
						return fmt.Errorf("field %s: %w", fieldType.Name, err)
					}
					slice = reflect.Append(slice, elem)
				}

				fieldValue.Set(slice)
			} else if fieldValue.Kind() == reflect.Struct {
				// Try TextUnmarshaler first
				ok, err := tryTextUnmarshal(fieldValue, values[0])
				if err != nil {
					return err
				} else if ok {
					continue
				}

				// If struct doesn't implement TextUnmarshaler but has a direct value,
				// this is an error - we can't parse a simple string into a struct
				return fmt.Errorf("field %s: struct must implement encoding.TextUnmarshaler to be parsed from a single value", fieldType.Name)
			} else {
				// Simple value
				if err := parseAndSet(fieldValue, values[0]); err != nil {
					return fmt.Errorf("field %s: %w", fieldType.Name, err)
				}
			}
		} else if fieldValue.Kind() == reflect.Struct {
			// Try TextUnmarshaler first
			ok, err := tryTextUnmarshal(fieldValue, "")
			if err != nil {
				return err
			} else if ok {
				continue
			}

			if hasNestedValues(queries, queryKey) {
				if err := decodeQueryParamsWithPrefix(fieldValue, queries, queryKey); err != nil {
					return err
				}
			}
		}
	}

	return nil
}

// hasNestedValues checks if there are any query parameters with the given prefix
// This function allows to know if a nested struct needs to be allocated or filled in.
func hasNestedValues(queries url.Values, prefix string) bool {
	prefixDot := prefix + "."
	for key := range queries {
		if strings.HasPrefix(key, prefixDot) {
			return true
		}
	}
	return false
}

// DecodeQueryParams parses URL query parameters into a struct based on field tags.
//
// The function uses struct field tags with the key "query" to map query parameters
// to struct fields. It supports:
//   - Basic types: string, int, uint, bool, float
//   - Slices of basic types (e.g., ?ids=1&ids=2&ids=3)
//   - Nested structs using dot notation (e.g., ?address.city=Paris)
//   - Custom types implementing encoding.TextUnmarshaler
//
// Tag usage:
//   - `query:"param_name"` - maps to the specified query parameter
//   - `query:"-"` - ignores the field
//   - no tag or empty tag - uses the field name as the parameter name
//
// The out parameter must be a pointer to a struct
func DecodeQueryParams(uri url.URL, out any) error {
	v := reflect.ValueOf(out)
	if v.Kind() != reflect.Pointer || v.IsNil() {
		return ErrNotPointer
	}
	v = v.Elem()
	if v.Kind() != reflect.Struct {
		return ErrNotStruct
	}

	queries := uri.Query()
	if len(queries) <= 0 {
		return nil
	}

	return decodeQueryParamsWithPrefix(v, queries, "")
}