parse.go

package query

import (
	"fmt"
	"net/url"
	"strconv"
	"strings"
)

const (
	keyFields = "_fields"
	keySort   = "_sort"
	keyLimit  = "_limit"
	keyOffset = "_offset"

	keyFieldsNoPrefix = "fields"
	keySortNoPrefix   = "sort"
	keyLimitNoPrefix  = "limit"
	keyOffsetNoPrefix = "offset"
)

func ParseWithValidator(query string, validator *Validator, opts ...OptionQuery) (*Query, error) {
	q, err := Parse(query, opts...)
	if err != nil {
		return nil, err
	}

	if validator == nil {
		return q, nil
	}

	if err := q.Validate(validator); err != nil {
		return nil, err
	}

	return q, nil
}

// Parse parses a query string into a Query struct.
func Parse(query string, opts ...OptionQuery) (*Query, error) {
	o := &optionQuery{
		SkipUnderscore: true,
	}
	for _, opt := range opts {
		opt(o)
	}

	// Determine the effective key names based on the underscore prefix option.
	kFields, kSort, kLimit, kOffset := keyFields, keySort, keyLimit, keyOffset
	if o.UnderscorePrefix != nil && !*o.UnderscorePrefix {
		kFields = keyFieldsNoPrefix
		kSort = keySortNoPrefix
		kLimit = keyLimitNoPrefix
		kOffset = keyOffsetNoPrefix
	}

	result := New()

	// Fast path: skip unescape when the query contains no percent-encoded or plus-encoded chars.
	if strings.ContainsAny(query, "%+") {
		var err error
		query, err = url.QueryUnescape(query)
		if err != nil {
			return nil, err
		}
	}

	// Split the query by & to get key-value pairs
	for _, pair := range split(query, '&') {
		// Handle each parameter
		if pair == "" {
			continue
		}

		if isParenthesesAny(pair) {
			// Handle standalone parentheses expression
			exprs, err := parseFilter(pair, o.KeyType, o.KeyOperator, o.KeyValueTransform, o.CommaSplit)
			if err != nil {
				return nil, err
			}

			var expr Expression
			switch length := len(exprs); {
			case length > 1:
				expr = &ExpressionLogic{
					Operator: OperatorAnd,
					List:     exprs,
				}
			case length == 1:
				expr = exprs[0]
			default:
				continue
			}

			processed := resultAddExpr(result, expr, o)
			if processed != nil {
				result.Where = append(result.Where, processed)
			}

			continue
		}

		key, value, _ := strings.Cut(pair, "=")

		switch key {
		case kFields:
			// Handle field selection
			if value == "" {
				continue
			}

			for field := range strings.SplitSeq(value, ",") {
				if field != "" {
					result.Select = append(result.Select, field)
				}
			}
		case kSort:
			// Handle sorting
			if value == "" {
				continue
			}
			result.Sort = parseSort(value)
		case kLimit:
			// Handle limit
			if value == "" {
				continue
			}
			limit, err := strconv.ParseUint(value, 10, 64)
			if err != nil {
				return nil, fmt.Errorf("invalid limit value: %s", value)
			}
			result.Limit = &limit
		case kOffset:
			// Handle offset
			if value == "" {
				continue
			}
			offset, err := strconv.ParseUint(value, 10, 64)
			if err != nil {
				return nil, fmt.Errorf("invalid offset value: %s", value)
			}
			result.Offset = &offset
		default:
			// Handle filtering
			expr, err := parseFilterExpr(key, value, o.KeyType, o.KeyOperator, o.KeyValueTransform, o.CommaSplit)
			if err != nil {
				return nil, err
			}

			processed := resultAddExpr(result, expr, o)
			if processed != nil {
				result.Where = append(result.Where, processed)
			}
		}
	}

	if result.Offset == nil && o.DefaultOffset != nil {
		result.Offset = o.DefaultOffset
	}
	if result.Limit == nil && o.DefaultLimit != nil {
		result.Limit = o.DefaultLimit
	}

	for key, value := range o.Value {
		if result.Values == nil {
			result.Values = make(map[string][]*ExpressionCmp)
		}

		result.Values[key] = append(result.Values[key], value)
		result.Where = append(result.Where, value)
	}

	return result, nil
}

func resultAddExpr(result *Query, expr Expression, o *optionQuery) Expression {
	if expr == nil {
		return nil
	}

	if cmp, ok := expr.(*ExpressionCmp); ok {
		if result.Values == nil {
			result.Values = make(map[string][]*ExpressionCmp)
		}

		result.Values[cmp.Field] = append(result.Values[cmp.Field], cmp)

		if o.SkipUnderscore && strings.HasPrefix(cmp.Field, "_") {
			return nil
		}

		if _, ok := o.Skip[cmp.Field]; ok {
			return nil
		}

		return cmp
	}

	if exprLogic, ok := expr.(*ExpressionLogic); ok {
		// Filter in-place: reuse the existing slice to avoid allocating a new one.
		n := 0
		for _, e := range exprLogic.List {
			processed := resultAddExpr(result, e, o)
			if processed != nil {
				exprLogic.List[n] = processed
				n++
			}
		}

		// Clear trailing references to allow GC of removed expressions.
		for i := n; i < len(exprLogic.List); i++ {
			exprLogic.List[i] = nil
		}
		exprLogic.List = exprLogic.List[:n]

		if n == 0 {
			return nil
		}

		return exprLogic
	}

	// Other expression types
	return expr
}

// parseSort parses the sort parameter and returns the ordered expressions.
func parseSort(value string) []ExpressionSort {
	if value == "" {
		return nil
	}

	// Count commas to pre-size the result.
	n := 1 + strings.Count(value, ",")
	orderedExpressions := make([]ExpressionSort, 0, n)

	for field := range strings.SplitSeq(value, ",") {
		switch {
		case field == "":
			// Skip empty fields
		case field[0] == '+':
			orderedExpressions = append(orderedExpressions, ExpressionSort{
				Field: field[1:],
				Desc:  false,
			})
		case field[0] == '-':
			orderedExpressions = append(orderedExpressions, ExpressionSort{
				Field: field[1:],
				Desc:  true,
			})
		case strings.HasSuffix(field, ":asc"):
			orderedExpressions = append(orderedExpressions, ExpressionSort{
				Field: field[:len(field)-4],
				Desc:  false,
			})
		case strings.HasSuffix(field, ":desc"):
			orderedExpressions = append(orderedExpressions, ExpressionSort{
				Field: field[:len(field)-5],
				Desc:  true,
			})
		default:
			orderedExpressions = append(orderedExpressions, ExpressionSort{
				Field: field,
				Desc:  false,
			})
		}
	}

	return orderedExpressions
}

func parseFilter(value string, keyType map[string]ValueType, keyOperator map[string]operatorCmpType, keyValueTransform map[string]func(string) string, commaSplit map[string]struct{}) ([]Expression, error) {
	if isParentheses(value) {
		// Strip surrounding parentheses
		value = value[1 : len(value)-1]
	}

	// Handle & conditions
	parts := split(value, '&')
	exs := make([]Expression, 0, len(parts))

	for _, part := range parts {
		if part == "" {
			continue
		}

		if isParentheses(part) {
			// Nested parentheses
			nestedExpr, err := parseFilter(part, keyType, keyOperator, keyValueTransform, commaSplit)
			if err != nil {
				return nil, err
			}
			exs = append(exs, &ExpressionLogic{
				Operator: OperatorAnd,
				List:     nestedExpr,
			})

			continue
		}

		if parts := split(part, '|'); len(parts) > 1 {
			exsInternal := make([]Expression, 0, len(parts))
			for _, p := range parts {
				nestedExpr, err := parseFilter(p, keyType, keyOperator, keyValueTransform, commaSplit)
				if err != nil {
					return nil, err
				}

				switch length := len(nestedExpr); {
				case length > 1:
					exsInternal = append(exsInternal, &ExpressionLogic{
						Operator: OperatorAnd,
						List:     nestedExpr,
					})
				case length == 1:
					exsInternal = append(exsInternal, nestedExpr[0])
				default:
					continue
				}
			}

			exs = append(exs, &ExpressionLogic{
				Operator: OperatorOr,
				List:     exsInternal,
			})

			continue
		}

		partKey, partVal, _ := strings.Cut(part, "=")

		exp, err := parseFilterExpr(partKey, partVal, keyType, keyOperator, keyValueTransform, commaSplit)
		if err != nil {
			return nil, err
		}

		exs = append(exs, exp)
	}

	return exs, nil
}

// parseFilterExpr parses filter expressions from key-value pairs.
func parseFilterExpr(key, value string, keyType map[string]ValueType, keyOperator map[string]operatorCmpType, keyValueTransform map[string]func(string) string, commaSplit map[string]struct{}) (Expression, error) {
	switch {
	case strings.Contains(value, "|"):
		// Handle OR conditions
		parts := strings.Split(value, "|")
		exs := make([]Expression, 0, len(parts))

		exp, err := parseExpression(key, parts[0], keyType[getKey(key)], keyOperator, keyValueTransform, commaSplit)
		if err != nil {
			return nil, err
		}

		exs = append(exs, exp)

		for _, part := range parts[1:] {
			if pKey, pVal, ok := strings.Cut(part, "="); ok {
				// Different field
				exp, err := parseExpression(pKey, pVal, keyType[getKey(pKey)], keyOperator, keyValueTransform, commaSplit)
				if err != nil {
					return nil, err
				}

				exs = append(exs, exp)
			} else {
				// Same field
				exp, err := parseExpression(key, part, keyType[getKey(key)], keyOperator, keyValueTransform, commaSplit)
				if err != nil {
					return nil, err
				}

				exs = append(exs, exp)
			}
		}

		return &ExpressionLogic{
			Operator: OperatorOr,
			List:     exs,
		}, nil
	default:
		return parseExpression(key, value, keyType[getKey(key)], keyOperator, keyValueTransform, commaSplit)
	}
}

func isParentheses(value string) bool {
	return strings.HasPrefix(value, "(") && strings.HasSuffix(value, ")")
}

func isParenthesesAny(value string) bool {
	return strings.Contains(value, "(") && strings.Contains(value, ")")
}

// split with & or | respecting parentheses depth.
// Uses index-based slicing to avoid allocating a strings.Builder per segment.
func split(value string, delim byte) []string {
	// Count delimiters at depth 0 to pre-size the result slice.
	n := 1
	depth := 0
	for i := 0; i < len(value); i++ {
		switch value[i] {
		case '(':
			depth++
		case ')':
			depth--
		case delim:
			if depth == 0 {
				n++
			}
		}
	}

	result := make([]string, 0, n)
	start := 0
	depth = 0

	for i := 0; i < len(value); i++ {
		switch value[i] {
		case '(':
			depth++
		case ')':
			depth--
		case delim:
			if depth == 0 {
				if i > start {
					result = append(result, value[start:i])
				}
				start = i + 1
			}
		}
	}

	if start < len(value) {
		result = append(result, value[start:])
	}

	return result
}