types

var (
	ErrImageNotFound = errors.New("image not found")
)

var ExprFunctions = []expr.Option{

	expr.Function(
		"_call",
		func(params ...any) (any, error) {
			t0 := time.Now()
			defer func() {
				logger.Tracef("[expr] _call(%q) took %s", params[0], time.Since(t0))
			}()

			res, err := ExprCall(params[0].(string), params[1].(ExprEnv))
			return res, wrapErr("_call", err)
		},
		new(func(exprName string) (any, error)),
		new(func(exprName string, env ExprEnv) (any, error)),
	),

	expr.Function(
		"_exist",
		func(params ...any) (any, error) {
			t0 := time.Now()
			defer func() {
				logger.Tracef("[expr] _exist(%q) took %s", params[0], time.Since(t0))
			}()

			file, err := fileFromSelector(params[0], params[1])
			if err != nil {
				return false, wrapErr("_exist", err)
			}

			res, err := ExprExist(file.CacheKey)
			return res, wrapErr("_exist", err)
		},
		new(func(fileSelector string) (bool, error)),
		new(func(fileSelector string, env ExprEnv) (bool, error)),
	),

	expr.Function(
		"_jq",
		func(params ...any) (any, error) {
			t0 := time.Now()
			defer func() {
				logger.Tracef("[expr] _jq(%q, ...) took %s", params[1], time.Since(t0))
			}()

			file, err := fileFromSelector(params[1], params[3])
			if err != nil {
				return nil, wrapErr("_jq", err)
			}

			res, err := ExprJQ(params[0].(context.Context), file.CacheKey, params[2].(string))
			return res, wrapErr("_jq", err)
		},
		new(func(ctx context.Context, fileSelector string, filter string) (any, error)),
		new(func(ctx context.Context, fileSelector string, filter string, env ExprEnv) (any, error)),
	),

	expr.Function(
		"_loadJSON",
		func(params ...any) (any, error) {
			t0 := time.Now()
			defer func() {
				logger.Tracef("[expr] _loadJSON(%q) took %s", params[0], time.Since(t0))
			}()

			file, err := fileFromSelector(params[0], params[1])
			if err != nil {
				return nil, wrapErr("_loadJSON", err)
			}

			res, err := ExprLoadJSON(file.CacheKey)
			return res, wrapErr("_loadJSON", err)
		},
		new(func(fileSelector string) (any, error)),
		new(func(fileSelector string, env ExprEnv) (any, error)),
	),

	expr.Function(
		"_merge",
		func(params ...any) (any, error) {
			t0 := time.Now()
			defer func() {
				logger.Tracef("[expr] _merge(...) took %s", time.Since(t0))
			}()

			return ExprMerge(params[0].(map[string]any), params[1].(map[string]any)), nil
		},
		new(func(o1, o2 map[string]any) (map[string]any, error)),
	),

	expr.Function(
		"_replaceRegex",
		func(params ...any) (any, error) {
			t0 := time.Now()
			defer func() {
				logger.Tracef("[expr] _replaceRegex(%q, %q, %q) took %s", params[0], params[1], params[2], time.Since(t0))
			}()

			res, err := ExprReplaceRegex(params[0].(string), params[1].(string), params[2].(string))
			return res, wrapErr("_replaceRegex", err)
		},
		new(func(str string, regex string, replacement string) (string, error)),
	),

	expr.Function(
		"_s3Key",
		func(params ...any) (any, error) {
			t0 := time.Now()
			defer func() {
				logger.Tracef("[expr] _merge(...) took %s", time.Since(t0))
			}()

			file, err := fileFromSelector(params[0], params[1])
			if err != nil {
				return "", wrapErr("_s3Key", err)
			}

			return file.S3Path, nil
		},
		new(func(fileSelector string) (string, error)),
		new(func(fileSelector string, env ExprEnv) (string, error)),
	),

	expr.Function(
		"_title",
		func(params ...any) (any, error) {
			t0 := time.Now()
			defer func() {
				logger.Tracef("[expr] _title(%q) took %s", params[0], time.Since(t0))
			}()

			return ExprTitle(params[0].(string)), nil
		},
		new(func(str string) (string, error)),
	),

	expr.Function(
		"_xpath",
		func(params ...any) (any, error) {
			t0 := time.Now()
			defer func() {
				logger.Tracef("[expr] _xpath(%q, ...) took %s", params[0], time.Since(t0))
			}()

			file, err := fileFromSelector(params[0], params[2])
			if err != nil {
				return nil, wrapErr("_xpath", err)
			}

			res, err := ExprXPath(file.CacheKey, params[1].(string))
			return res, wrapErr("_xpath", err)
		},
		new(func(fileSelector string, xpath string) (any, error)),
		new(func(fileSelector string, xpath string, env ExprEnv) (any, error)),
	),
}

var ExprTestingFunctions = []expr.Option{
	expr.Function(
		"__testCounter__",
		func(params ...any) (any, error) {
			ctx := params[0].(context.Context)

			counter, ok := ctx.Value(ExprTestCounterKey{}).(*atomic.Int64)
			if !ok {
				return nil, errors.New("__testCounter__: context value not found")
			}

			counter.Add(1)

			return nil, nil
		},
		new(func(ctx context.Context) (any, error)),
	),
}