<?php
class Various   //Class names are listed 
{
    //DefaultRuntime
    public function run()
    {
        if (!$response) { 
            $response = $this->server->handleRequest($request);
        }
 
        // Prepare and return the response
        return $response->prepare($request);
    }
 
    //DefaultServer
    public function handleRequest(SymfonyRequest $request)
    {
        return $stack->process($request);
    }
 
    //MiddlewareStack
    public function process(Request $request)
    {
        $stack = $this->getStack();
        return $stack->next($request);
    }
 
    //MiddlewareDelegate
    public function next(Request $request)
    {
        $response = $this->middleware->process($request, $this->nextDelegate);
 
        // Negotiate PSR7 responses
        if ($response instanceof ResponseInterface) {
            return $this->foundationFactory->createResponse($response);
        }
 
        return $response;
    }
 
    //$this->middleware->process calls self::next() 3 timesand the 4th time $this->middleware->process() is called... 
 
    //ThumbnailMiddleware
    public function process(Request $request, DelegateInterface $frame)
    {
        $response = $frame->next($request);
    }
 
    //DispatcherDelegate
    public function next(Request $request)
    {
        return $this->dispatcher->dispatch($request);
    }
 
    //DefaultDispatcher
    public function dispatch(SymfonyRequest $request)
    {
        $response = null;
        if ($this->app->isInstalled()) {
            $response = $this->getEarlyDispatchResponse();    //Pass the security checks and returns null
        }
        if ($response === null) {
            $response = $this->handleDispatch($request);
        }
 
        return $response;
    }
 
    //DefaultDispatcher
    private function handleDispatch($request)
    {
        $callDispatcher = false;
        try {
            $route = $this->router->matchRoute($request)->getRoute();
            $dispatcher = new RouteDispatcher($this->router, $route, []);
            $stack = new MiddlewareStack(
                new DispatcherDelegate($dispatcher)
            );
            $stack->setApplication($this->app);
 
            // Does not get any middleware
            foreach($route->getMiddlewares() as $middleware) {
                if (is_string($middleware->getMiddleware())) {
                    $inflatedMiddleware =  $this->app->make($middleware->getMiddleware());
                } else {
                    $inflatedMiddleware = $middleware->getMiddleware();
                }
                $stack = $stack->withMiddleware(
                    $inflatedMiddleware,
                    $middleware->getPriority()
                );
            }
            return $stack->process($request);
        } catch (ResourceNotFoundException $e) {
            $callDispatcher = true;
        } catch (MethodNotAllowedException $e) {
            $callDispatcher = true;
        }
        if ($callDispatcher) {
            $c = \Page::getFromRequest($request);
            $response = $this->app->make(ResponseFactoryInterface::class)->collection($c);
        }
 
        return $response;
    }
 
    //MiddlewareStack
    public function process(Request $request)
    {
        $stack = $this->getStack();
        return $stack->next($request);
    }
 
    //DispatcherDelegate
    public function next(Request $request)
    {
        return $this->dispatcher->dispatch($request);
    }
 
    //RouteDispatcher
    public function dispatch(SymfonyRequest $request)
    {
        $action = $this->router->resolveAction($this->route);
        $response = $action->execute($request, $this->route, $this->parameters);
        return $response;
    }
 
    //ControllerRouteAction
    public function execute(Request $request, Route $route, $parameters)
    {
        if (method_exists($controller, 'runAction')) {
            $response = $controller->runAction($method, $arguments);
        }
    }
 
    //AbstractController
    public function runAction($action, $parameters = [])
    {
        $this->action = $action;
        $this->parameters = $parameters;
        if (is_callable([$this, $action])) {
            if ($this->shouldRunControllerTask()) {
                return call_user_func_array([$this, $action], $parameters);
            }
        }
    }
 
    //Edit
    public function submit()
    {
        if ($this->validateAction() && $this->canAccess()) {            
            $pr->outputJSON();
        }
    }
 
    //EditResponse
    public function outputJSON()
    {
        if ($this->hasError()) {
            Core::make('helper/ajax')->sendError($this->error);
        } else {
            Core::make('helper/ajax')->sendResult($this->getJSONObject());
        }
    }
 
    //EditResponse
 
    public function getJSONObject()
    {
        $o = parent::getBaseJSONObject();
        return $o;
    }
 
    //Ajax
    public function sendResult($result)
    {
        echo json_encode($result);
        die();
    }
 
    //Whoops
    public function handleShutdown()
    {
        // If we reached this step, we are in shutdown handler.
        // An exception thrown in a shutdown handler will not be propagated
        // to the exception handler. Pass that information along.
        $this->canThrowExceptions = false;
 
        //"You are using a fallback implementation of the intl extension. Installing the native one is highly recommended instead."
 
        $error = $this->system->getLastError();
        if ($error && Misc::isLevelFatal($error['type'])) {}    //returns false.  $level is 16384 and $errors is 245
    }
}