transformations

var (
	ErrSummarizeByFieldNotFound   = errors.New("summarize by field not found. Not applying summarize")
	ErrNotUniqueFieldNames        = errors.New("field names are not unique. Not applying filter")
	ErrEvaluatingFilterExpression = errors.New("error evaluating filter expression")
	ErrInvalidFilterExpression    = errors.New("invalid filter expression")

	ErrMergeTransformationNoFrameSupplied     = errors.New("no frames supplied for merge frame transformation")
	ErrMergeTransformationDifferentFields     = errors.New("unable to merge fields due to different fields")
	ErrMergeTransformationDifferentFieldNames = errors.New("unable to merge field due to different field names")
	ErrMergeTransformationDifferentFieldTypes = errors.New("unable to merge fields due to different field types")

	ErrEvaluatingFilterExpressionWithEmptyFrame = errors.Join(ErrEvaluatingFilterExpression, errors.New("unable to apply filter on nil frame"))
)

var ExpressionFunctions = map[string]govaluate.ExpressionFunction{
	"trim": func(arguments ...any) (any, error) {
		if len(arguments) < 1 {
			return nil, errors.New("invalid arguments to trim method")
		}
		if arg, ok := arguments[0].(*string); ok {
			return strings.TrimSpace(*arg), nil
		}
		if arg, ok := arguments[0].(string); ok {
			return strings.TrimSpace(arg), nil
		}
		return "", nil
	},
	"tolower": func(arguments ...any) (any, error) {
		if len(arguments) < 1 {
			return nil, errors.New("invalid arguments to tolower method")
		}
		if arg, ok := arguments[0].(*string); ok {
			return strings.ToLower(*arg), nil
		}
		if arg, ok := arguments[0].(string); ok {
			return strings.ToLower(arg), nil
		}
		return "", nil
	},
	"toupper": func(arguments ...any) (any, error) {
		if len(arguments) < 1 {
			return nil, errors.New("invalid arguments to toupper method")
		}
		if arg, ok := arguments[0].(*string); ok {
			return strings.ToUpper(*arg), nil
		}
		if arg, ok := arguments[0].(string); ok {
			return strings.ToUpper(arg), nil
		}
		return "", nil
	},
	"startswith": func(arguments ...any) (any, error) {
		if len(arguments) < 2 {
			return nil, errors.New("invalid arguments to startswith method")
		}
		var first *string
		var second *string
		if arg, ok := arguments[0].(*string); ok {
			first = arg
		}
		if arg, ok := arguments[0].(string); ok {
			first = &arg
		}
		if arg, ok := arguments[1].(*string); ok {
			second = arg
		}
		if arg, ok := arguments[1].(string); ok {
			second = &arg
		}
		if first != nil && second != nil {
			return strings.HasPrefix(*first, *second), nil
		}
		return false, nil
	},
	"endswith": func(arguments ...any) (any, error) {
		if len(arguments) < 2 {
			return nil, errors.New("invalid arguments to endswith method")
		}
		var first *string
		var second *string
		if arg, ok := arguments[0].(*string); ok {
			first = arg
		}
		if arg, ok := arguments[0].(string); ok {
			first = &arg
		}
		if arg, ok := arguments[1].(*string); ok {
			second = arg
		}
		if arg, ok := arguments[1].(string); ok {
			second = &arg
		}
		if first != nil && second != nil {
			return strings.HasSuffix(*first, *second), nil
		}
		return false, nil
	},
	"contains": func(arguments ...any) (any, error) {
		if len(arguments) < 2 {
			return nil, errors.New("invalid arguments to endswith method")
		}
		var first *string
		var second *string
		if arg, ok := arguments[0].(*string); ok {
			first = arg
		}
		if arg, ok := arguments[0].(string); ok {
			first = &arg
		}
		if arg, ok := arguments[1].(*string); ok {
			second = arg
		}
		if arg, ok := arguments[1].(string); ok {
			second = &arg
		}
		if first != nil && second != nil {
			return strings.Contains(*first, *second), nil
		}
		return false, nil
	},
	"replace": func(arguments ...any) (any, error) {
		if len(arguments) < 3 {
			return nil, errors.New("invalid arguments to endswith method")
		}
		var first *string
		var second *string
		var third *string
		if arg, ok := arguments[0].(*string); ok {
			first = arg
		}
		if arg, ok := arguments[0].(string); ok {
			first = &arg
		}
		if arg, ok := arguments[1].(*string); ok {
			second = arg
		}
		if arg, ok := arguments[1].(string); ok {
			second = &arg
		}
		if arg, ok := arguments[2].(*string); ok {
			third = arg
		}
		if arg, ok := arguments[2].(string); ok {
			third = &arg
		}

		if first != nil && second != nil && third != nil {
			return strings.ReplaceAll(*first, *second, *third), nil
		}
		return "", nil
	},
	"replace_all": func(arguments ...any) (any, error) {
		if len(arguments) < 3 {
			return nil, errors.New("invalid arguments to endswith method")
		}
		var first *string
		var second *string
		var third *string
		if arg, ok := arguments[0].(*string); ok {
			first = arg
		}
		if arg, ok := arguments[0].(string); ok {
			first = &arg
		}
		if arg, ok := arguments[1].(*string); ok {
			second = arg
		}
		if arg, ok := arguments[1].(string); ok {
			second = &arg
		}
		if arg, ok := arguments[2].(*string); ok {
			third = arg
		}
		if arg, ok := arguments[2].(string); ok {
			third = &arg
		}
		if first != nil && second != nil && third != nil {
			return strings.ReplaceAll(*first, *second, *third), nil
		}
		return "", nil
	},
	"guid": func(arguments ...any) (any, error) {
		id := uuid.New()
		return id.String(), nil
	},
	"uuid": func(arguments ...any) (any, error) {
		id := uuid.New()
		return id.String(), nil
	},
	"totime": func(arguments ...any) (any, error) {
		if len(arguments) < 1 {
			return nil, errors.New("invalid arguments to todatetime function")
		}
		if arguments[0] == nil {
			return nil, errors.New("invalid argument to totime function")
		}
		var first *string
		if arg, ok := arguments[0].(*string); ok {
			first = arg
		}
		if arg, ok := arguments[0].(string); ok {
			first = &arg
		}
		if first != nil {
			return dateparse.ParseAny(*first)
		}
		return nil, nil
	},
	"tomillis": func(arguments ...any) (any, error) {
		if len(arguments) < 1 {
			return nil, errors.New("invalid arguments to tomillis function")
		}
		if arguments[0] == nil {
			return nil, errors.New("invalid argument to tomillis function")
		}
		var first *time.Time
		if arg, ok := arguments[0].(*time.Time); ok {
			first = arg
		}
		if arg, ok := arguments[0].(time.Time); ok {
			first = &arg
		}
		if first != nil {
			return first.UnixMilli(), nil
		}
		return nil, nil
	},
}