Named Routes Demo

<?php
namespace App\Backend\Core;

class Router
{
    private array $routes = [];
    private array $namedRoutes = [];
    private array $currentRoute = [];
    private string $basePath = '';

    /**
     * Add GET route
     */
    public function get(string $pattern, $handler, string $name = null): self
    {
        return $this->addRoute('GET', $pattern, $handler, $name);
    }

    /**
     * Add POST route
     */
    public function post(string $pattern, $handler, string $name = null): self
    {
        return $this->addRoute('POST', $pattern, $handler, $name);
    }

    /**
     * Add PUT route
     */
    public function put(string $pattern, $handler, string $name = null): self
    {
        return $this->addRoute('PUT', $pattern, $handler, $name);
    }

    /**
     * Add DELETE route
     */
    public function delete(string $pattern, $handler, string $name = null): self
    {
        return $this->addRoute('DELETE', $pattern, $handler, $name);
    }

    /**
     * Add route for any HTTP method
     */
    public function any(string $pattern, $handler, string $name = null): self
    {
        $methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'];
        foreach ($methods as $method) {
            $this->addRoute($method, $pattern, $handler, $name);
        }
        return $this;
    }

    /**
     * Add route group with prefix
     */
    public function group(string $prefix, callable $callback): self
    {
        $originalBasePath = $this->basePath;
        $this->basePath .= '/' . trim($prefix, '/');
        
        $callback($this);
        
        $this->basePath = $originalBasePath;
        return $this;
    }

    /**
     * Add RESTful resource routes
     */
    public function resource(string $name, string $controller): self
    {
        $singular = rtrim($name, 's');
        
        // GET /resource - index
        $this->get("/{$name}", "{$controller}@index", "{$name}.index");
        
        // GET /resource/create - create form
        $this->get("/{$name}/create", "{$controller}@create", "{$name}.create");
        
        // POST /resource - store
        $this->post("/{$name}", "{$controller}@store", "{$name}.store");
        
        // GET /resource/{id} - show
        $this->get("/{$name}/{id}", "{$controller}@show", "{$name}.show");
        
        // GET /resource/{id}/edit - edit form
        $this->get("/{$name}/{id}/edit", "{$controller}@edit", "{$name}.edit");
        
        // PUT /resource/{id} - update
        $this->put("/{$name}/{id}", "{$controller}@update", "{$name}.update");
        
        // DELETE /resource/{id} - destroy
        $this->delete("/{$name}/{id}", "{$controller}@destroy", "{$name}.destroy");
        
        return $this;
    }

    /**
     * Add route to routes array
     */
    private function addRoute(string $method, string $pattern, $handler, ?string $name): self
    {
        $pattern = $this->basePath . '/' . ltrim($pattern, '/');
        $pattern = '/' . trim($pattern, '/');
        
        $route = [
            'method' => $method,
            'pattern' => $pattern,
            'handler' => $handler,
            'name' => $name,
            'regex' => $this->patternToRegex($pattern),
            'parameters' => $this->extractParameters($pattern)
        ];

        $this->routes[] = $route;

        // Store named routes for URL generation
        if ($name) {
            $this->namedRoutes[$name] = $route;
        }

        return $this;
    }

    /**
     * Convert route pattern to regex
     */
    private function patternToRegex(string $pattern): string
    {
        // Replace {param} with named capture groups
        $regex = preg_replace('/\{([^}]+)\}/', '(?P<$1>[^/]+)', $pattern);
        
        // Escape forward slashes
        $regex = str_replace('/', '\/', $regex);
        
        return '/^' . $regex . '$/';
    }

    /**
     * Extract parameter names from pattern
     */
    private function extractParameters(string $pattern): array
    {
        preg_match_all('/\{([^}]+)\}/', $pattern, $matches);
        return $matches[1] ?? [];
    }

    /**
     * Dispatch request to appropriate handler
     */
    public function dispatch(string $method, string $uri): mixed
    {
        $uri = '/' . trim(parse_url($uri, PHP_URL_PATH), '/');
        
        foreach ($this->routes as $route) {
            if ($route['method'] === $method && preg_match($route['regex'], $uri, $matches)) {
                $this->currentRoute = $route;
                
                // Extract route parameters
                $parameters = [];
                foreach ($route['parameters'] as $param) {
                    if (isset($matches[$param])) {
                        $parameters[$param] = $matches[$param];
                    }
                }

                return $this->callHandler($route['handler'], $parameters);
            }
        }

        throw new NotFoundException("Route not found: {$method} {$uri}");
    }

    /**
     * Call route handler
     */
    private function callHandler($handler, array $parameters): mixed
    {
        if (is_string($handler) && strpos($handler, '@') !== false) {
            // Controller@method format
            [$controllerClass, $method] = explode('@', $handler);
            
            // Resolve full controller class name
            if (!class_exists($controllerClass)) {
                $controllerClass = "App\\Frontend\\Controllers\\{$controllerClass}";
            }
            
            if (!class_exists($controllerClass)) {
                throw new Exception("Controller not found: {$controllerClass}");
            }

            $controller = new $controllerClass();
            
            if (!method_exists($controller, $method)) {
                throw new Exception("Method {$method} not found in {$controllerClass}");
            }

            return call_user_func_array([$controller, $method], array_values($parameters));
        }

        if (is_callable($handler)) {
            return call_user_func_array($handler, array_values($parameters));
        }

        throw new Exception("Invalid route handler");
    }

    /**
     * Generate URL for named route
     */
    public function route(string $name, array $parameters = []): string
    {
        if (!isset($this->namedRoutes[$name])) {
            throw new Exception("Named route '{$name}' not found");
        }

        $route = $this->namedRoutes[$name];
        $url = $route['pattern'];

        // Replace parameters in URL
        foreach ($parameters as $key => $value) {
            $url = str_replace('{' . $key . '}', $value, $url);
        }

        // Check for unresolved parameters
        if (preg_match('/\{[^}]+\}/', $url)) {
            throw new Exception("Missing required parameters for route '{$name}'");
        }

        return $url;
    }

    /**
     * Get current route information
     */
    public function getCurrentRoute(): array
    {
        return $this->currentRoute;
    }

    /**
     * Get all registered routes
     */
    public function getRoutes(): array
    {
        return $this->routes;
    }

    /**
     * Get all named routes
     */
    public function getNamedRoutes(): array
    {
        return $this->namedRoutes;
    }

    /**
     * Get named route by name
     */
    public function getNamedRoute(string $name): ?array
    {
        return $this->namedRoutes[$name] ?? null;
    }

    /**
     * Check if named route exists
     */
    public function hasNamedRoute(string $name): bool
    {
        return isset($this->namedRoutes[$name]);
    }
}

<?php
/**
 * Add route group with prefix
 */
public function group(string $prefix, callable $callback): self
{
    $originalBasePath = $this->basePath;
    $this->basePath .= '/' . trim($prefix, '/');
    
    $callback($this);
    
    $this->basePath = $originalBasePath;
    return $this;
}

// Usage Examples:

// Demo routes group
$router->group('/demo', function(Router $router) {
    $router->get('/', 'DemoController@index', 'demo.index');
    $router->get('/templates', 'DemoController@templates', 'demo.templates');
    $router->get('/components', 'DemoController@components', 'demo.components');
    $router->get('/forms', 'DemoController@forms', 'demo.forms');
    $router->get('/api', 'DemoController@api', 'demo.api');
});

// API routes group
$router->group('/api', function(Router $router) {
    $router->get('/collections', 'ApiController@collections', 'api.collections');
    $router->get('/items/{collection}', 'ApiController@getItems', 'api.items.index');
    $router->post('/items/{collection}', 'ApiController@createItem', 'api.items.store');
});

// Admin routes group
$router->group('/admin', function(Router $router) {
    $router->get('/', 'AdminController@dashboard', 'admin.dashboard');
    $router->get('/collections', 'AdminController@collections', 'admin.collections');
    $router->post('/cache/clear', 'AdminController@clearCache', 'admin.cache.clear');
});

<?php
/**
 * Add RESTful resource routes
 */
public function resource(string $name, string $controller): self
{
    $singular = rtrim($name, 's');
    
    // GET /resource - index
    $this->get("/{$name}", "{$controller}@index", "{$name}.index");
    
    // GET /resource/create - create form
    $this->get("/{$name}/create", "{$controller}@create", "{$name}.create");
    
    // POST /resource - store
    $this->post("/{$name}", "{$controller}@store", "{$name}.store");
    
    // GET /resource/{id} - show
    $this->get("/{$name}/{id}", "{$controller}@show", "{$name}.show");
    
    // GET /resource/{id}/edit - edit form
    $this->get("/{$name}/{id}/edit", "{$controller}@edit", "{$name}.edit");
    
    // PUT /resource/{id} - update
    $this->put("/{$name}/{id}", "{$controller}@update", "{$name}.update");
    
    // DELETE /resource/{id} - destroy
    $this->delete("/{$name}/{id}", "{$controller}@destroy", "{$name}.destroy");
    
    return $this;
}

// Usage:
$router->resource('products', 'ProductController');
$router->resource('categories', 'CategoryController');
$router->resource('users', 'UserController');

// This creates these routes:
// GET    /products           products.index      ProductController@index
// GET    /products/create    products.create     ProductController@create  
// POST   /products           products.store      ProductController@store
// GET    /products/{id}      products.show       ProductController@show
// GET    /products/{id}/edit products.edit       ProductController@edit
// PUT    /products/{id}      products.update     ProductController@update
// DELETE /products/{id}      products.destroy    ProductController@destroy

<?php
/**
 * Convert route pattern to regex
 */
private function patternToRegex(string $pattern): string
{
    // Replace {param} with named capture groups
    $regex = preg_replace('/\{([^}]+)\}/', '(?P<$1>[^/]+)', $pattern);
    
    // Escape forward slashes
    $regex = str_replace('/', '\/', $regex);
    
    return '/^' . $regex . '$/';
}

/**
 * Dispatch request to appropriate handler
 */
public function dispatch(string $method, string $uri): mixed
{
    $uri = '/' . trim(parse_url($uri, PHP_URL_PATH), '/');
    
    foreach ($this->routes as $route) {
        if ($route['method'] === $method && preg_match($route['regex'], $uri, $matches)) {
            $this->currentRoute = $route;
            
            // Extract route parameters
            $parameters = [];
            foreach ($route['parameters'] as $param) {
                if (isset($matches[$param])) {
                    $parameters[$param] = $matches[$param];
                }
            }

            return $this->callHandler($route['handler'], $parameters);
        }
    }

    throw new NotFoundException("Route not found: {$method} {$uri}");
}

/**
 * Call route handler
 */
private function callHandler($handler, array $parameters): mixed
{
    if (is_string($handler) && strpos($handler, '@') !== false) {
        // Controller@method format
        [$controllerClass, $method] = explode('@', $handler);
        
        // Resolve full controller class name
        if (!class_exists($controllerClass)) {
            $controllerClass = "App\\Frontend\\Controllers\\{$controllerClass}";
        }

        $controller = new $controllerClass();
        return call_user_func_array([$controller, $method], array_values($parameters));
    }

    if (is_callable($handler)) {
        return call_user_func_array($handler, array_values($parameters));
    }

    throw new Exception("Invalid route handler");
}

<?php
// routes/web.php - Application Routes
use App\Backend\Core\Router;

$router = new Router();

// Home page
$router->get('/', 'HomeController@index', 'home');

// Demo routes group
$router->group('/demo', function(Router $router) {
    $router->get('/', 'DemoController@index', 'demo.index');
    $router->get('/templates', 'DemoController@templates', 'demo.templates');
    $router->get('/components', 'DemoController@components', 'demo.components');
    $router->get('/forms', 'DemoController@forms', 'demo.forms');
    $router->get('/api', 'DemoController@api', 'demo.api');
    $router->get('/named-routes', 'DemoController@namedRoutes', 'demo.named-routes');
    $router->get('/blade-products', 'DemoController@bladeProducts', 'demo.blade-products');
    
    // Form processing routes
    $router->post('/forms/contact', 'DemoController@processContact', 'demo.forms.contact');
    
    // Template test routes
    $router->get('/template-test', 'DemoController@templateTest', 'demo.template-test');
    $router->get('/simple-template', 'DemoController@simpleTemplate', 'demo.simple-template');
});

// API routes group
$router->group('/api', function(Router $router) {
    $router->get('/collections', 'ApiController@collections', 'api.collections');
    $router->get('/items/{collection}', 'ApiController@getItems', 'api.items.index');
    $router->get('/items/{collection}/{id}', 'ApiController@getItem', 'api.items.show');
    $router->post('/items/{collection}', 'ApiController@createItem', 'api.items.store');
    $router->put('/items/{collection}/{id}', 'ApiController@updateItem', 'api.items.update');
    $router->delete('/items/{collection}/{id}', 'ApiController@deleteItem', 'api.items.destroy');
    $router->get('/system/info', 'ApiController@systemInfo', 'api.system.info');
    $router->get('/health', 'ApiController@health', 'api.health');
});

// RESTful resource routes
$router->resource('products', 'ProductController');
$router->resource('categories', 'CategoryController');
$router->resource('users', 'UserController');

// Admin routes
$router->group('/admin', function(Router $router) {
    $router->get('/', 'AdminController@dashboard', 'admin.dashboard');
    $router->get('/collections', 'AdminController@collections', 'admin.collections');
    $router->get('/media', 'AdminController@media', 'admin.media');
    $router->get('/api-sandbox', 'AdminController@apiSandbox', 'admin.api-sandbox');
    $router->get('/graphql', 'AdminController@graphql', 'admin.graphql');
    $router->post('/cache/clear', 'AdminController@clearCache', 'admin.cache.clear');
});

// Authentication routes
$router->get('/login', 'AuthController@showLogin', 'auth.login');
$router->post('/login', 'AuthController@processLogin', 'auth.login.process');
$router->post('/logout', 'AuthController@logout', 'auth.logout');

// Catch-all for 404 errors
$router->any('/{any:.*}', function() {
    throw new NotFoundException('Page not found');
}, '404');

return $router;

<?php
// Basic named route usage
echo route('home'); // Output: /
echo route('demo.index'); // Output: /demo
echo route('demo.templates'); // Output: /demo/templates

// Routes with parameters
echo route('api.items.show', ['collection' => 'products', 'id' => 123]);
// Output: /api/items/products/123

echo route('products.show', ['id' => 456]);
// Output: /products/456

// Using in templates
?>
<nav class="navbar">
    <a href="<?= route('home') ?>" class="nav-link">Home</a>
    <a href="<?= route('demo.index') ?>" class="nav-link">Demo</a>
    <a href="<?= route('products.index') ?>" class="nav-link">Products</a>
</nav>

<!-- Form action URLs -->
<form action="<?= route('demo.forms.contact') ?>" method="POST">
    <!-- form fields -->
</form>

<!-- Dynamic product links -->
<?php foreach ($products as $product): ?>
    <div class="product-card">
        <h3><?= $product['name'] ?></h3>
        <a href="<?= route('products.show', ['id' => $product['id']]) ?>" class="btn">
            View Product
        </a>
        <a href="<?= route('products.edit', ['id' => $product['id']]) ?>" class="btn">
            Edit Product
        </a>
    </div>
<?php endforeach; ?>

<?php
// Route parameter examples

// Single parameter
$router->get('/user/{id}', 'UserController@show', 'user.show');
// Matches: /user/123
// Parameters: $id = 123

// Multiple parameters
$router->get('/user/{id}/posts/{slug}', 'PostController@show', 'user.posts.show');
// Matches: /user/123/posts/my-blog-post
// Parameters: $id = 123, $slug = 'my-blog-post'

// API resource with parameters
$router->get('/api/items/{collection}/{id}', 'ApiController@getItem', 'api.items.show');
// Matches: /api/items/products/456
// Parameters: $collection = 'products', $id = 456

// Controller method receiving parameters
class UserController
{
    public function show(Request $request, Response $response, string $id): void
    {
        $user = $this->userRepository->findById($id);
        
        if (!$user) {
            throw new NotFoundException('User not found');
        }
        
        $response->render('users/show', ['user' => $user]);
    }
    
    public function posts(Request $request, Response $response, string $id, string $slug): void
    {
        $user = $this->userRepository->findById($id);
        $post = $this->postRepository->findBySlug($slug);
        
        $response->render('posts/show', [
            'user' => $user,
            'post' => $post
        ]);
    }
}

// Generating URLs with parameters
echo route('user.show', ['id' => 123]); // /user/123
echo route('user.posts.show', ['id' => 123, 'slug' => 'my-post']); // /user/123/posts/my-post
echo route('api.items.show', ['collection' => 'products', 'id' => 456]); // /api/items/products/456