Http.php

<?php

namespace Utopia\Http;

use Utopia\Validator;
use Utopia\Telemetry\Adapter as Telemetry;
use Utopia\Telemetry\Adapter\None as NoTelemetry;
use Utopia\Telemetry\Histogram;
use Utopia\Telemetry\UpDownCounter;
use Utopia\Validator\ArrayList;
use Utopia\Validator\Boolean;
use Utopia\Validator\FloatValidator;
use Utopia\Validator\Integer;
use Utopia\Validator\Text;

class Http
{
    public const COMPRESSION_MIN_SIZE_DEFAULT = 1024;

    /**
     * Request method constants
     */
    public const REQUEST_METHOD_GET = 'GET';

    public const REQUEST_METHOD_POST = 'POST';

    public const REQUEST_METHOD_PUT = 'PUT';

    public const REQUEST_METHOD_PATCH = 'PATCH';

    public const REQUEST_METHOD_DELETE = 'DELETE';

    public const REQUEST_METHOD_OPTIONS = 'OPTIONS';

    public const REQUEST_METHOD_HEAD = 'HEAD';

    /**
     * Mode Type
     */
    public const MODE_TYPE_DEVELOPMENT = 'development';

    public const MODE_TYPE_STAGE = 'stage';

    public const MODE_TYPE_PRODUCTION = 'production';

    /**
     * @var array
     */
    protected array $resources = [
        'error' => null,
    ];

    /**
     * @var Files
     */
    protected Files $files;

    /**
     * @var array
     */
    protected static array $resourcesCallbacks = [];

    /**
     * Current running mode
     *
     * @var string
     */
    protected static string $mode = '';

    /**
     * Errors
     *
     * Errors callbacks
     *
     * @var Hook[]
     */
    protected static array $errors = [];

    /**
     * Init
     *
     * A callback function that is initialized on application start
     *
     * @var Hook[]
     */
    protected static array $init = [];

    /**
     * Shutdown
     *
     * A callback function that is initialized on application end
     *
     * @var Hook[]
     */
    protected static array $shutdown = [];

    /**
     * Options
     *
     * A callback function for options method requests
     *
     * @var Hook[]
     */
    protected static array $options = [];

    /**
     * Route
     *
     * Memory cached result for chosen route
     *
     * @var Route|null
     */
    protected ?Route $route = null;

    /**
     * Matched Route
     *
     * During runtime $this->route might be overwritten with the wildcard route to keep custom functions working with
     * paths not declared in the Router. Keep a copy of the original matched app route.
     */
    protected ?Route $matchedRoute = null;

    /**
     * Wildcard route
     * If set, this get's executed if no other route is matched
     *
     * @var Route|null
     */
    protected static ?Route $wildcardRoute = null;

    /**
     * Compression
     */
    protected bool $compression = false;
    protected int $compressionMinSize = Http::COMPRESSION_MIN_SIZE_DEFAULT;
    protected mixed $compressionSupported = [];

    private Histogram $requestDuration;
    private UpDownCounter $activeRequests;
    private Histogram $requestBodySize;
    private Histogram $responseBodySize;

    /**
     * Http
     *
     * @param  string  $timezone
     */
    public function __construct(string $timezone)
    {
        \date_default_timezone_set($timezone);
        $this->files = new Files();
        $this->setTelemetry(new NoTelemetry());
    }

    /**
     * Set Compression
     */
    public function setCompression(bool $compression)
    {
        $this->compression = $compression;
    }

    /**
     * Set minimum compression size
     */
    public function setCompressionMinSize(int $compressionMinSize)
    {
        $this->compressionMinSize = $compressionMinSize;
    }

    /**
     * Set supported compression algorithms
     */
    public function setCompressionSupported(mixed $compressionSupported)
    {
        $this->compressionSupported = $compressionSupported;
    }

    /**
     * Set telemetry adapter.
     *
     * @param Telemetry $telemetry
     * @return void
     */
    public function setTelemetry(Telemetry $telemetry): void
    {
        // https://opentelemetry.io/docs/specs/semconv/http/http-metrics/#metric-httpserverrequestduration
        $this->requestDuration = $telemetry->createHistogram(
            'http.server.request.duration',
            's',
            null,
            ['ExplicitBucketBoundaries' =>  [0.005, 0.01, 0.025, 0.05, 0.075, 0.1, 0.25, 0.5, 0.75, 1, 2.5, 5, 7.5, 10]]
        );

        // https://opentelemetry.io/docs/specs/semconv/http/http-metrics/#metric-httpserveractive_requests
        $this->activeRequests = $telemetry->createUpDownCounter('http.server.active_requests', '{request}');
        // https://opentelemetry.io/docs/specs/semconv/http/http-metrics/#metric-httpserverrequestbodysize
        $this->requestBodySize = $telemetry->createHistogram('http.server.request.body.size', 'By');
        // https://opentelemetry.io/docs/specs/semconv/http/http-metrics/#metric-httpserverresponsebodysize
        $this->responseBodySize = $telemetry->createHistogram('http.server.response.body.size', 'By');
    }

    /**
     * GET
     *
     * Add GET request route
     *
     * @param  string  $url
     * @return Route
     */
    public static function get(string $url): Route
    {
        return self::addRoute(self::REQUEST_METHOD_GET, $url);
    }

    /**
     * POST
     *
     * Add POST request route
     *
     * @param  string  $url
     * @return Route
     */
    public static function post(string $url): Route
    {
        return self::addRoute(self::REQUEST_METHOD_POST, $url);
    }

    /**
     * PUT
     *
     * Add PUT request route
     *
     * @param  string  $url
     * @return Route
     */
    public static function put(string $url): Route
    {
        return self::addRoute(self::REQUEST_METHOD_PUT, $url);
    }

    /**
     * PATCH
     *
     * Add PATCH request route
     *
     * @param  string  $url
     * @return Route
     */
    public static function patch(string $url): Route
    {
        return self::addRoute(self::REQUEST_METHOD_PATCH, $url);
    }

    /**
     * DELETE
     *
     * Add DELETE request route
     *
     * @param  string  $url
     * @return Route
     */
    public static function delete(string $url): Route
    {
        return self::addRoute(self::REQUEST_METHOD_DELETE, $url);
    }

    /**
     * Wildcard
     *
     * Add Wildcard route
     *
     * @return Route
     */
    public static function wildcard(): Route
    {
        self::$wildcardRoute = new Route('', '');

        return self::$wildcardRoute;
    }

    /**
     * Init
     *
     * Set a callback function that will be initialized on application start
     *
     * @return Hook
     */
    public static function init(): Hook
    {
        $hook = new Hook();
        $hook->groups(['*']);

        self::$init[] = $hook;

        return $hook;
    }

    /**
     * Shutdown
     *
     * Set a callback function that will be initialized on application end
     *
     * @return Hook
     */
    public static function shutdown(): Hook
    {
        $hook = new Hook();
        $hook->groups(['*']);

        self::$shutdown[] = $hook;

        return $hook;
    }

    /**
     * Options
     *
     * Set a callback function for all request with options method
     *
     * @return Hook
     */
    public static function options(): Hook
    {
        $hook = new Hook();
        $hook->groups(['*']);

        self::$options[] = $hook;

        return $hook;
    }

    /**
     * Error
     *
     * An error callback for failed or no matched requests
     *
     * @return Hook
     */
    public static function error(): Hook
    {
        $hook = new Hook();
        $hook->groups(['*']);

        self::$errors[] = $hook;

        return $hook;
    }

    /**
     * Get env var
     *
     * Method for querying env varialbles. If $key is not found $default value will be returned.
     *
     * @param  string  $key
     * @param  string|null  $default
     * @return string|null
     */
    public static function getEnv(string $key, ?string $default = null): ?string
    {
        return $_SERVER[$key] ?? $default;
    }

    /**
     * Get Mode
     *
     * Get current mode
     *
     * @return string
     */
    public static function getMode(): string
    {
        return self::$mode;
    }

    /**
     * Set Mode
     *
     * Set current mode
     *
     * @param  string  $value
     * @return void
     */
    public static function setMode(string $value): void
    {
        self::$mode = $value;
    }

    /**
     * Get allow override
     *
     *
     * @return bool
     */
    public static function getAllowOverride(): bool
    {
        return Router::getAllowOverride();
    }

    /**
     * Set Allow override
     *
     *
     * @param  bool  $value
     * @return void
     */
    public static function setAllowOverride(bool $value): void
    {
        Router::setAllowOverride($value);
    }

    /**
     * If a resource has been created return it, otherwise create it and then return it
     *
     * @param  string  $name
     * @param  bool  $fresh
     * @return mixed
     *
     * @throws Exception
     */
    public function getResource(string $name, bool $fresh = false): mixed
    {
        if ($name === 'utopia') {
            return $this;
        }

        if (!\array_key_exists($name, $this->resources) || $fresh || self::$resourcesCallbacks[$name]['reset']) {
            if (!\array_key_exists($name, self::$resourcesCallbacks)) {
                throw new Exception('Failed to find resource: "' . $name . '"');
            }

            $this->resources[$name] = \call_user_func_array(
                self::$resourcesCallbacks[$name]['callback'],
                $this->getResources(self::$resourcesCallbacks[$name]['injections'])
            );
        }

        self::$resourcesCallbacks[$name]['reset'] = false;

        return $this->resources[$name];
    }

    /**
     * Get Resources By List
     *
     * @param  array  $list
     * @return array
     */
    public function getResources(array $list): array
    {
        $resources = [];

        foreach ($list as $name) {
            $resources[$name] = $this->getResource($name);
        }

        return $resources;
    }

    /**
     * Set a new resource callback
     *
     * @param  string  $name
     * @param  callable  $callback
     * @param  array  $injections
     * @return void
     *
     * @throws Exception
     */
    public static function setResource(string $name, callable $callback, array $injections = []): void
    {
        if ($name === 'utopia') {
            throw new Exception("'utopia' is a reserved keyword.", 500);
        }
        self::$resourcesCallbacks[$name] = ['callback' => $callback, 'injections' => $injections, 'reset' => true];
    }

    /**
     * Is app in production mode?
     *
     * @return bool
     */
    public static function isProduction(): bool
    {
        return self::MODE_TYPE_PRODUCTION === self::$mode;
    }

    /**
     * Is app in development mode?
     *
     * @return bool
     */
    public static function isDevelopment(): bool
    {
        return self::MODE_TYPE_DEVELOPMENT === self::$mode;
    }

    /**
     * Is app in stage mode?
     *
     * @return bool
     */
    public static function isStage(): bool
    {
        return self::MODE_TYPE_STAGE === self::$mode;
    }

    /**
     * Get Routes
     *
     * Get all application routes
     *
     * @return array
     */
    public static function getRoutes(): array
    {
        return Router::getRoutes();
    }

    /**
     * Get the current route
     *
     * @return null|Route
     */
    public function getRoute(): ?Route
    {
        return $this->route ?? null;
    }

    /**
     * Set the current route
     *
     * @param  Route  $route
     */
    public function setRoute(Route $route): self
    {
        $this->route = $route;

        return $this;
    }

    /**
     * Add Route
     *
     * Add routing route method, path and callback
     *
     * @param  string  $method
     * @param  string  $url
     * @return Route
     */
    public static function addRoute(string $method, string $url): Route
    {
        $route = new Route($method, $url);

        Router::addRoute($route);

        return $route;
    }

    /**
     * Load directory.
     *
     * @param  string  $directory
     * @param  string|null  $root
     * @return void
     *
     * @throws \Exception
    */
    public function loadFiles(string $directory, ?string $root = null): void
    {
        $this->files->load($directory, $root);
    }

    /**
     * Is file loaded.
     *
     * @param  string  $uri
     * @return bool
     */
    protected function isFileLoaded(string $uri): bool
    {
        return $this->files->isFileLoaded($uri);
    }

    /**
     * Get file contents.
     *
     * @param  string  $uri
     * @return string
     *
     * @throws \Exception
     */
    protected function getFileContents(string $uri): mixed
    {
        return $this->files->getFileContents($uri);
    }

    /**
     * Get file MIME type.
     *
     * @param  string  $uri
     * @return string
     *
     * @throws \Exception
     */
    protected function getFileMimeType(string $uri): mixed
    {
        return $this->files->getFileMimeType($uri);
    }

    /**
     * Match
     *
     * Find matching route given current user request
     *
     * @param  Request  $request
     * @param  bool  $fresh If true, will not match any cached route
     * @return null|Route
     */
    public function match(Request $request, bool $fresh = false): ?Route
    {
        if (null !== $this->route && !$fresh) {
            return $this->route;
        }

        $url = \parse_url($request->getURI(), PHP_URL_PATH);

        if ($url === null || $url === false) {
            $url = '/'; // Default to root path for malformed URLs
        }

        $method = $request->getMethod();
        $method = (self::REQUEST_METHOD_HEAD == $method) ? self::REQUEST_METHOD_GET : $method;

        $this->route = Router::match($method, $url);

        return $this->route;
    }

    /**
     * Capture the current route context so nested dispatches can restore it.
     *
     * @return array<string, mixed>
     */
    private function captureRouteContext(): array
    {
        return [
            'route' => $this->route,
            'hasRouteResource' => \array_key_exists('route', $this->resources),
            'routeResource' => $this->resources['route'] ?? null,
            'hasRouteResourceCallback' => \array_key_exists('route', self::$resourcesCallbacks),
            'routeResourceCallback' => self::$resourcesCallbacks['route'] ?? null,
        ];
    }

    private function applyRouteContext(?Route $route, Request $request): void
    {
        $this->route = $route;

        self::setResource('route', function () use ($route, $request) {
            return $route ?? new Route($request->getMethod(), $request->getURI());
        });
    }

    /**
     * Restore the previous route context after nested dispatch completes.
     *
     * @param  array<string, mixed>  $context
     */
    private function restoreRouteContext(array $context): void
    {
        $this->route = $context['route'];

        if ($context['hasRouteResource']) {
            $this->resources['route'] = $context['routeResource'];
        } else {
            unset($this->resources['route']);
        }

        if ($context['hasRouteResourceCallback']) {
            self::$resourcesCallbacks['route'] = $context['routeResourceCallback'];
        } else {
            unset(self::$resourcesCallbacks['route']);
        }
    }

    /**
     * Execute a given route with middlewares and error handling
     *
     * @param  Route  $route
     * @param  Request  $request
     */
    public function execute(Route $route, Request $request, Response $response): static
    {
        $arguments = [];
        $groups = $route->getGroups();

        $preparedPath = Router::preparePath($route->getMatchedPath());
        $pathValues = $route->getPathValues($request, $preparedPath[0]);

        try {
            if ($route->getHook()) {
                foreach (self::$init as $hook) { // Global init hooks
                    if (in_array('*', $hook->getGroups())) {
                        $arguments = $this->getArguments($hook, $pathValues, $request->getParams());
                        \call_user_func_array($hook->getAction(), $arguments);
                    }
                }
            }

            foreach ($groups as $group) {
                foreach (self::$init as $hook) { // Group init hooks
                    if (in_array($group, $hook->getGroups())) {
                        $arguments = $this->getArguments($hook, $pathValues, $request->getParams());
                        \call_user_func_array($hook->getAction(), $arguments);
                    }
                }
            }

            if (!($response->isSent())) {
                $arguments = $this->getArguments($route, $pathValues, $request->getParams());

                // Call the action callback with the matched positions as params
                \call_user_func_array($route->getAction(), $arguments);
            }


            foreach ($groups as $group) {
                foreach (self::$shutdown as $hook) { // Group shutdown hooks
                    if (in_array($group, $hook->getGroups())) {
                        $arguments = $this->getArguments($hook, $pathValues, $request->getParams());
                        \call_user_func_array($hook->getAction(), $arguments);
                    }
                }
            }

            if ($route->getHook()) {
                foreach (self::$shutdown as $hook) { // Group shutdown hooks
                    if (in_array('*', $hook->getGroups())) {
                        $arguments = $this->getArguments($hook, $pathValues, $request->getParams());
                        \call_user_func_array($hook->getAction(), $arguments);
                    }
                }
            }
        } catch (\Throwable $e) {
            self::setResource('error', fn () => $e);

            foreach ($groups as $group) {
                foreach (self::$errors as $error) { // Group error hooks
                    if (in_array($group, $error->getGroups())) {
                        try {
                            $arguments = $this->getArguments($error, $pathValues, $request->getParams());
                            \call_user_func_array($error->getAction(), $arguments);
                        } catch (\Throwable $e) {
                            throw new Exception('Error handler had an error: ' . $e->getMessage() . "\nStack trace: " . $e->getTraceAsString(), 500, $e);
                        }
                    }
                }
            }

            foreach (self::$errors as $error) { // Global error hooks
                if (in_array('*', $error->getGroups())) {
                    try {
                        $arguments = $this->getArguments($error, $pathValues, $request->getParams());
                        \call_user_func_array($error->getAction(), $arguments);
                    } catch (\Throwable $e) {
                        throw new Exception('Error handler had an error: ' . $e->getMessage() . "\nStack trace: " . $e->getTraceAsString(), 500, $e);
                    }
                }
            }
        }

        return $this;
    }

    /**
     * Get Arguments
     *
     * @param  Hook  $hook
     * @param  array  $values
     * @param  array  $requestParams
     * @return array
     *
     * @throws Exception
     */
    protected function getArguments(Hook $hook, array $values, array $requestParams): array
    {
        $arguments = [];
        foreach ($hook->getParams() as $key => $param) { // Get value from route or request object
            $existsInRequest = \array_key_exists($key, $requestParams);
            $existsInValues = \array_key_exists($key, $values);
            $paramExists = $existsInRequest || $existsInValues;

            if ($existsInRequest) {
                $arg = $requestParams[$key];
            } else {
                if (!is_string($param['default']) && \is_callable($param['default'])) {
                    $arg = \call_user_func_array($param['default'], $this->getResources($param['injections']));
                } else {
                    $arg = $param['default'];
                }
            }

            $value = $existsInValues ? $values[$key] : $arg;

            if (!$param['skipValidation'] && !$paramExists && !$param['optional']) {
                throw new Exception('Param "' . $key . '" is not optional.', 400);
            }

            if ($param['model'] && $paramExists) {
                $model = $param['model'];

                if (!\is_string($model) || !\class_exists($model)) {
                    throw new Exception('Model class does not exist: ' . $model, 500);
                }
                if (!\is_a($model, Model::class, true)) {
                    throw new Exception('Model class is not an instance of Utopia\\Http\\Model', 500);
                }
                if (\is_string($value) && $value !== '') {
                    try {
                        $value = \json_decode($value, true, flags: JSON_THROW_ON_ERROR);
                    } catch (\Throwable $e) {
                        throw new Exception('Failed to parse JSON for model param "' . $key . '": ' . $e->getMessage(), 400);
                    }
                }
                if (!\is_array($value) && $value !== null && $value !== '') {
                    throw new Exception('Model param "' . $key . '" must be a JSON string, or an array', 400);
                }
                if (\is_array($value)) {
                    $validator = $param['validator'];
                    $isArrayList = $validator instanceof ArrayList;

                    if ($isArrayList) {
                        try {
                            $value = \array_map(
                                fn ($item) => \is_array($item) ? $model::fromArray($item) : $item,
                                $value
                            );
                        } catch (\Throwable $e) {
                            throw new Exception('Failed to create model instance for param "' . $key . '": ' . $e->getMessage(), 400);
                        }
                    } else {
                        try {
                            $value = $model::fromArray($value);
                        } catch (\Throwable $e) {
                            throw new Exception('Failed to create model instance for param "' . $key . '": ' . $e->getMessage(), 400);
                        }
                    }
                }
                if ($param['optional'] && $value === '') {
                    $value = null;
                }
            }

            if (
                !$param['skipValidation'] &&
                !($param['optional'] && $value === null) &&
                $paramExists
            ) {
                $validator = $this->validate($key, $param, $value);

                if ($existsInRequest && $value !== null) {
                    if ($validator instanceof Boolean) {
                        $value = filter_var($value, FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE);
                        if ($value === null) {
                            throw new Exception('Invalid boolean value for param "' . $key . '"', 400);
                        }
                    } elseif ($validator instanceof Integer && \is_string($value)) {
                        if (\is_numeric($value)) {
                            $value = (int)$value;
                        }
                    } elseif ($validator instanceof FloatValidator && \is_string($value)) {
                        if (\is_numeric($value)) {
                            $value = (float)$value;
                        }
                    } elseif ($validator instanceof Text && !\is_string($value)) {
                        $value = (string)$value;
                    }
                }
            }

            $hook->setParamValue($key, $value);
            $arguments[$param['order']] = $value;
        }

        foreach ($hook->getInjections() as $injection) {
            $arguments[$injection['order']] = $this->getResource($injection['name']);
        }

        return $arguments;
    }

    /**
     * Run: wrapper function to record telemetry. All domain logic should happen in `runInternal`.
     */
    public function run(Request $request, Response $response): static
    {
        $this->activeRequests->add(1, [
            'http.request.method' => $request->getMethod(),
            'url.scheme' => $request->getProtocol(),
        ]);

        $start = microtime(true);
        $result = $this->runInternal($request, $response);

        $requestDuration = microtime(true) - $start;
        $attributes = [
            'url.scheme' => $request->getProtocol(),
            'http.request.method' => $request->getMethod(),
            'http.route' => $this->matchedRoute?->getPath(),
            'http.response.status_code' => $response->getStatusCode(),
        ];
        $this->requestDuration->record($requestDuration, $attributes);
        $this->requestBodySize->record($request->getSize(), $attributes);
        $this->responseBodySize->record($response->getSize(), $attributes);
        $this->activeRequests->add(-1, [
            'http.request.method' => $request->getMethod(),
            'url.scheme' => $request->getProtocol(),
        ]);

        return $result;
    }

    /**
     * Run internal
     *
     * This is the place to initialize any pre routing logic.
     * This is where you might want to parse the application current URL by any desired logic
     *
     * @param  Request  $request
     * @param  Response  $response
     */
    private function runInternal(Request $request, Response $response): static
    {
        if ($this->compression) {
            $response->setAcceptEncoding($request->getHeader('accept-encoding', ''));
            $response->setCompressionMinSize($this->compressionMinSize);
            $response->setCompressionSupported($this->compressionSupported);
        }

        $this->resources['request'] = $request;
        $this->resources['response'] = $response;

        self::setResource('request', function () use ($request) {
            return $request;
        });

        self::setResource('response', function () use ($response) {
            return $response;
        });

        if ($this->isFileLoaded($request->getURI())) {
            $time = (60 * 60 * 24 * 365 * 2); // 45 days cache

            $response
                ->setContentType($this->getFileMimeType($request->getURI()))
                ->addHeader('Cache-Control', 'public, max-age=' . $time)
                ->addHeader('Expires', \date('D, d M Y H:i:s', \time() + $time) . ' GMT') // 45 days cache
                ->send($this->getFileContents($request->getURI()));

            return $this;
        }

        $routeContext = $this->captureRouteContext();
        $matchedRoute = $this->matchedRoute;

        try {
            $method = $request->getMethod();
            $route = $this->match($request, fresh: true);
            $this->matchedRoute = $route;
            $groups = ($route instanceof Route) ? $route->getGroups() : [];

            if (null === $route && null !== self::$wildcardRoute) {
                $route = self::$wildcardRoute;
                $path = \parse_url($request->getURI(), PHP_URL_PATH);
                $route->path($path);
            }

            $this->applyRouteContext($route, $request);

            if (self::REQUEST_METHOD_HEAD == $method) {
                $method = self::REQUEST_METHOD_GET;
                $response->disablePayload();
            }

            if (self::REQUEST_METHOD_OPTIONS == $method) {
                try {
                    foreach ($groups as $group) {
                        foreach (self::$options as $option) { // Group options hooks
                            /** @var Hook $option */
                            if (in_array($group, $option->getGroups())) {
                                \call_user_func_array($option->getAction(), $this->getArguments($option, [], $request->getParams()));
                            }
                        }
                    }

                    foreach (self::$options as $option) { // Global options hooks
                        /** @var Hook $option */
                        if (in_array('*', $option->getGroups())) {
                            \call_user_func_array($option->getAction(), $this->getArguments($option, [], $request->getParams()));
                        }
                    }
                } catch (\Throwable $e) {
                    foreach (self::$errors as $error) { // Global error hooks
                        /** @var Hook $error */
                        if (in_array('*', $error->getGroups())) {
                            self::setResource('error', function () use ($e) {
                                return $e;
                            });
                            try {
                                $arguments = $this->getArguments($error, [], $request->getParams());
                                \call_user_func_array($error->getAction(), $arguments);
                            } catch (\Throwable $e) {
                                throw new Exception('Error handler had an error: ' . $e->getMessage() . "\nStack trace: " . $e->getTraceAsString(), 500, $e);
                            }
                        }
                    }
                }

                return $this;
            }

            if (null !== $route) {
                return $this->execute($route, $request, $response);
            } elseif (self::REQUEST_METHOD_OPTIONS == $method) {
                try {
                    foreach ($groups as $group) {
                        foreach (self::$options as $option) { // Group options hooks
                            if (in_array($group, $option->getGroups())) {
                                \call_user_func_array($option->getAction(), $this->getArguments($option, [], $request->getParams()));
                            }
                        }
                    }

                    foreach (self::$options as $option) { // Global options hooks
                        if (in_array('*', $option->getGroups())) {
                            \call_user_func_array($option->getAction(), $this->getArguments($option, [], $request->getParams()));
                        }
                    }
                } catch (\Throwable $e) {
                    foreach (self::$errors as $error) { // Global error hooks
                        if (in_array('*', $error->getGroups())) {
                            self::setResource('error', function () use ($e) {
                                return $e;
                            });
                            try {
                                $arguments = $this->getArguments($error, [], $request->getParams());
                                \call_user_func_array($error->getAction(), $arguments);
                            } catch (\Throwable $e) {
                                throw new Exception('Error handler had an error: ' . $e->getMessage() . "\nStack trace: " . $e->getTraceAsString(), 500, $e);
                            }
                        }
                    }
                }
            } else {
                foreach (self::$errors as $error) { // Global error hooks
                    if (in_array('*', $error->getGroups())) {
                        self::setResource('error', function () {
                            return new Exception('Not Found', 404);
                        });
                        try {
                            $arguments = $this->getArguments($error, [], $request->getParams());
                            \call_user_func_array($error->getAction(), $arguments);
                        } catch (\Throwable $e) {
                            throw new Exception('Error handler had an error: ' . $e->getMessage() . "\nStack trace: " . $e->getTraceAsString(), 500, $e);
                        }
                    }
                }
            }

            return $this;
        } finally {
            $this->restoreRouteContext($routeContext);
            $this->matchedRoute = $matchedRoute;
        }
    }

    /**
     * Validate Param
     *
     * Creates an validator instance and validate given value with given rules.
     *
     * @param  string  $key
     * @param  array  $param
     * @param  mixed  $value
     * @return Validator
     *
     * @throws Exception
     */
    protected function validate(string $key, array $param, mixed $value): Validator
    {
        $validator = $param['validator']; // checking whether the class exists

        if (\is_callable($validator)) {
            $validator = \call_user_func_array($validator, $this->getResources($param['injections']));
        }

        if (!$validator instanceof Validator) { // is the validator object an instance of the Validator class
            throw new Exception('Validator object is not an instance of the Validator class', 500);
        }

        if (!$validator->isValid($value)) {
            throw new Exception('Invalid `' . $key . '` param: ' . $validator->getDescription(), 400);
        }

        return $validator;
    }

    /**
     * Reset all the static variables
     *
     * @return void
     */
    public static function reset(): void
    {
        Router::reset();
        self::$resourcesCallbacks = [];
        self::$mode = '';
        self::$errors = [];
        self::$init = [];
        self::$shutdown = [];
        self::$options = [];
    }
}