Routeur PHP

/**
 * Middleware d'authentification avec vérification de session
 */
class AuthMiddleware
{
    /**
     * Vérifie si l'utilisateur est authentifié
     * @param Request $request La requête HTTP
     * @param Closure $next La fonction à exécuter ensuite
     * @return mixed
     */
    public function handle($request, Closure $next)
    {
        // Démarre la session si pas déjà fait
        if (session_status() === PHP_SESSION_NONE) {
            session_start();
        }
        
        // Vérifie si l'utilisateur est connecté
        if (!isset($_SESSION['user_id']) || empty($_SESSION['user_id'])) {
            // Stocke l'URL de destination pour redirection après connexion
            $_SESSION['intended_url'] = $_SERVER['REQUEST_URI'];
            
            // Gestion différente selon le type de requête
            if ($request->isAjax()) {
                http_response_code(401);
                header('Content-Type: application/json');
                echo json_encode(['error' => 'Non authentifié', 'redirect' => '/login']);
                exit;
            }
              // Redirection classique
            header('Location: /login');
            exit;
        }
          // Vérification de l'expiration de session
        if (isset($_SESSION['last_activity']) && 
            (time() - $_SESSION['last_activity'] > 3600)) { // 1 heure
            session_destroy();
            header('Location: /login?expired=1');
            exit;
        }
        
        // Met à jour l'activité
        $_SESSION['last_activity'] = time();
        
        // Ajoute l'utilisateur à la requête pour usage ultérieur
        $request->setUser(new User($_SESSION['user_id']));
        
        // Continue l'exécution
        return $next($request);
    }
}

/**
 * Middleware de journalisation avancé
 */
class LogMiddleware
{
    protected $logger;
    
    public function __construct(Logger $logger = null)
    {
        $this->logger = $logger ?? new FileLogger('/var/log/app.log');
    }
    
    public function handle($request, Closure $next)
    {
              // Données de la requête
              $startTime = microtime(true);
              $method = $_SERVER['REQUEST_METHOD'];
              $uri = $_SERVER['REQUEST_URI'];
              $ip = $request->getClientIp();
              $userAgent = $_SERVER['HTTP_USER_AGENT'] ?? 'Unknown';
              
              // Log de début de requête
              $this->logger->info("[{$method}] {$uri} - IP: {$ip}", [
                  'user_agent' => $userAgent,
                  'timestamp' => date('Y-m-d H:i:s')
              ]);
              
              try {
                  // Exécute le reste de la chaîne
                  $response = $next($request);
                  
                  // Log de succès
                  $duration = round((microtime(true) - $startTime) * 1000, 2);
                  $statusCode = http_response_code() ?: 200;
                  
                  $this->logger->info("[{$method}] {$uri} - {$statusCode} - {$duration}ms");
                  
                  return $response;
                  
              } catch (\Exception $e) {
                  // Log d'erreur
                  $duration = round((microtime(true) - $startTime) * 1000, 2);
                  $this->logger->error("[{$method}] {$uri} - ERROR - {$duration}ms", [
                      'exception' => $e->getMessage(),
                      'file' => $e->getFile(),
                      'line' => $e->getLine(),
                      'trace' => $e->getTraceAsString()
                  ]);
                  
                  throw $e; // Re-lance l'exception
              }
          }
      }      /**
       * Middleware de contrôle d'accès basé sur les rôles
       */
      class RoleMiddleware
      {
          protected $requiredRoles;
          
          public function __construct($roles = [])
          {
              $this->requiredRoles = is_array($roles) ? $roles : [$roles];
          }
          
          public function handle($request, Closure $next)
          {
              $user = $request->getUser();
              
              if (!$user) {
                  http_response_code(401);
                  throw new RouterException('Authentification requise', 401);
              }
              
              // Vérification des rôles
              if (!empty($this->requiredRoles)) {
                  $userRoles = $user->getRoles();
                  $hasRequiredRole = false;
                  
                  foreach ($this->requiredRoles as $role) {
                      if (in_array($role, $userRoles)) {
                          $hasRequiredRole = true;
                          break;
                      }
                  }
                  
                  if (!$hasRequiredRole) {
                      http_response_code(403);
                      throw new RouterException('Accès non autorisé', 403);
                  }
              }
              
              return $next($request);
          }
      }      /**
       * Middleware de limitation du taux de requêtes (Rate Limiting)
       */
      class RateLimitMiddleware
      {
          protected $maxRequests;
          protected $timeWindow; // en secondes
          protected $storage; // Redis, fichier, etc.
          
          public function __construct(int $maxRequests = 60, int $timeWindow = 60)
          {
              $this->maxRequests = $maxRequests;
              $this->timeWindow = $timeWindow;
              $this->storage = new FileStorage('/tmp/rate_limit'); // Exemple simple
          }
          
          public function handle($request, Closure $next)
          {
              $identifier = $this->getIdentifier($request);
              $key = 'rate_limit:' . $identifier . ':' . floor(time() / $this->timeWindow);
              
              // Récupère le nombre de requêtes pour cette fenêtre
              $requests = (int) $this->storage->get($key, 0);
              
              if ($requests >= $this->maxRequests) {
                  // Limite dépassée
                  http_response_code(429);
                  header('Retry-After: ' . $this->timeWindow);
                  header('X-RateLimit-Limit: ' . $this->maxRequests);
                  header('X-RateLimit-Remaining: 0');
                  
                  throw new RouterException('Trop de requêtes', 429);
              }
              
              // Incrémente le compteur
              $this->storage->increment($key, $this->timeWindow);
              
              // Ajoute les en-têtes de limite
              header('X-RateLimit-Limit: ' . $this->maxRequests);
              header('X-RateLimit-Remaining: ' . ($this->maxRequests - $requests - 1));
              
              return $next($request);
          }
          
          protected function getIdentifier($request): string
          {
              // Peut être l'IP, l'ID utilisateur, une clé API, etc.
              $user = $request->getUser();
              if ($user) {
                  return 'user_' . $user->getId();
              }
              
              return 'ip_' . $request->getClientIp();
          }
      }

class Router
{
    protected $routes = [];
    protected $globalMiddlewares = [];
    
    // ... autres méthodes ...
    
    /**
     * Ajoute un middleware global
     */
    public function middleware($middleware): self
    {
        $this->globalMiddlewares[] = $middleware;
        return $this;
    }
    
    /**
     * Ajoute un middleware à une route spécifique
     */
    protected function addRouteMiddleware(string $path, $middleware): void
    {
        
        // Trouve la dernière route ajoutée et ajoute le middleware        
        foreach ($this->routes as &$route) {
            if ($route['path'] === $path) {
                if (!isset($route['middleware'])) {
                    $route['middleware'] = [];                }
                $route['middleware'] = array_merge($route['middleware'], (array) $middleware);
                break;
            }
        }
    }
    
    /**
     * Exécute les middlewares dans l'ordre
     */
    protected function runMiddlewares(array $middlewares, $request, Closure $target)
    {
        // Si aucun middleware, exécute directement la cible
        if (empty($middlewares)) {
            return $target($request);
        }
        
        // Crée une chaîne de middlewares (pattern pipeline)
        $pipeline = array_reduce(
            array_reverse($middlewares),
            function ($next, $middleware) {
                return function ($request) use ($middleware, $next) {
                    // Instancie le middleware si c'est un nom de classe
                    if (is_string($middleware)) {
                        $middleware = new $middleware();
                    }
                    return $middleware->handle($request, $next);
                };
            },
            $target
        );
        
        return $pipeline($request);
    }
    
    /**
     * Traitement de la requête
     */
    public function run()
    {
        $method = $_SERVER['REQUEST_METHOD'];
        $uri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
        
        foreach ($this->routes as $route) {
            if ($route['method'] === $method && $this->matchRoute($route['path'], $uri, $params)) {
                $request = new Request($params);
                
                // Combine les middlewares globaux avec ceux de la route
                $middlewares = array_merge(
                    $this->globalMiddlewares,
                    $route['middleware'] ?? []
                );
                
                // Prépare la cible finale
                $target = function ($request) use ($route) {
                    // Exécute le contrôleur ou la closure
                    if (is_array($route['callback']) && count($route['callback']) === 2) {
                        $controller = new $route['callback'][0]();
                        return $controller->{$route['callback'][1]}($request);
                    }
                    return call_user_func($route['callback'], $request);
                };
                
                // Exécute la chaîne de middlewares
                return $this->runMiddlewares($middlewares, $request, $target);
            }
        }
        
        // Aucune route trouvée
        throw new \Exception('Route non trouvée', 404);
    }
    
    /**
     * Gère une exception
     */
    protected function handleException(RouterException $exception)
    {
        $statusCode = $exception->getStatusCode();
        
        http_response_code($statusCode);
        
        // Utilise un gestionnaire d'erreur personnalisé si défini
        if (isset($this->errorHandlers[$statusCode])) {
            return call_user_func($this->errorHandlers[$statusCode], $exception);
        }        // Gestionnaire par défaut
        if ($statusCode === 404) {
            return "404 - Page non trouvée" . $exception->getMessage()  ;
        }
        
        return "Erreur " . $statusCode .  . $exception->getMessage() ;
    }
}

$router = new Router();

// Définir des gestionnaires d'erreurs personnalisés
$router->error(404, function() {
    include 'views/404.php';
    return null;
});

$router->error(500, function(RouterException $e) {
    error_log("Erreur critique: {$e->getMessage()}\n{$e->getTraceAsString()}");
    include 'views/500.php';
    return null;
});

// Ajout de routes avec des contrôleurs potentiellement problématiques
$router->get('produits/:id', function($request) {
    if (!is_numeric($request->params['id'])) {
        throw new \InvalidArgumentException('ID de produit invalide');
    }
      $produit = $productRepository->find($request->params['id']);
    
    if ($produit === null) {
        throw new RouterException('Produit non trouvé', 404);
    }
    
    return new ProductView($produit);
});

class UserController
{
    protected $userRepository;
    protected $logger;
    
    /**
     * Injection des dépendances via le constructeur
     */
    public function __construct(UserRepository $userRepository, Logger $logger)
    {
        $this->userRepository = $userRepository;
        $this->logger = $logger;
    }
    
    public function index()
    {
        $users = $this->userRepository->findAll();
        $this->logger->info('Liste des utilisateurs consultée');
          return new View('users/index', ['users' => $users]);
    }
    
    public function show($request)
    {
        $user = $this->userRepository->find($request->params['id']);
        
        if (!$user) {
            throw new RouterException('Utilisateur non trouvé', 404);
        }
        
        $this->logger->info("Utilisateur {$user->id} consulté");
        
        return new View('users/show', ['user' => $user]);
    }
    
    /**
     * GET /users/:id - Affiche un utilisateur spécifique
     * Idempotente et sûre
     */    public function show($request)
    {
        $user = $this->userRepository->find($request->params['id']);
        
        if (!$user) {
            throw new RouterException('Utilisateur non trouvé', 404);
        }
        
        return new View('users/show', ['user' => $user]);
    }
    
    /**
     * GET /users/:id/edit - Affiche le formulaire d'édition
     * Idempotente et sûre
     */    public function edit($request)
    {
        $user = $this->userRepository->find($request->params['id']);
        
        if (!$user) {
            throw new RouterException('Utilisateur non trouvé', 404);
        }
        
        return new View('users/edit', ['user' => $user]);
    }
    
    /**
     * PUT /users/:id - Met à jour complètement un utilisateur
     * Idempotente - exécuter plusieurs fois avec les mêmes données produit le même résultat
     */    public function update($request)
    {
        $user = $this->userRepository->find($request->params['id']);
        
        if (!$user) {
            throw new RouterException('Utilisateur non trouvé', 404);
        }
        
        // Validation
        $validator = new Validator($request->post());
        $validator->required(['name', 'email'])
                  ->email('email')
                  ->unique('email', 'users', $user->id);
        
        if (!$validator->isValid()) {
            return new RedirectResponse("/users/{$user->id}/edit", ['errors' => $validator->getErrors()]);
        }
        
        // Mise à jour complète de l'utilisateur
        $this->userRepository->update($user->id, $validator->getData());
        
        return new RedirectResponse("/users/{$user->id}", ['success' => 'Utilisateur mis à jour']);
    }
    
    /**
     * PATCH /users/:id - Met à jour partiellement un utilisateur
     * Généralement non idempotente (dépend de l'implémentation)
     */    public function partialUpdate($request)    {
        $user = $this->userRepository->find($request->params['id']);
        
        if (!$user) {
            throw new RouterException('Utilisateur non trouvé', 404);
        }
        
        // Validation uniquement des champs présents
        $data = $request->post();
        $allowedFields = ['name', 'email', 'phone', 'address'];
        $updateData = array_intersect_key($data, array_flip($allowedFields));
        
        if (empty($updateData)) {
            throw new RouterException('Aucune donnée valide fournie', 400);
        }
        
        // Mise à jour partielle
        $this->userRepository->partialUpdate($user->id, $updateData);
        
        return new JsonResponse(['message' => 'Utilisateur mis à jour partiellement']);
    }
    
    /**
     * DELETE /users/:id - Supprime un utilisateur
     * Idempotente - supprimer plusieurs fois le même utilisateur a le même effet
     */    public function destroy($request)
    {
        $user = $this->userRepository->find($request->params['id']);
        
        if (!$user) {            // Pour DELETE, on peut considérer que supprimer un élément inexistant est "réussi"
            // car l'objectif (l'élément n'existe plus) est atteint
            return new RedirectResponse('/users', ['info' => 'Utilisateur déjà supprimé']);
        }
        
        // Vérification des contraintes (ex: ne pas supprimer un admin)
        if ($user->role === 'admin' && $this->userRepository->countAdmins() <= 1) {
            throw new RouterException('Impossible de supprimer le dernier administrateur', 403);
        }
        
        $this->userRepository->delete($user->id);
        
        return new RedirectResponse('/users', ['success' => 'Utilisateur supprimé']);
    }
}

// Définition de routes avec noms

// Routes principales
$router->get('', [HomeController::class, 'index'])->name('home');
$router->get('about', [PageController::class, 'about'])->name('about');
$router->get('contact', [ContactController::class, 'show'])->name('contact');
$router->post('contact', [ContactController::class, 'submit'])->name('contact.submit');

// Routes de blog avec paramètres
$router->get('blog', [BlogController::class, 'index'])->name('blog.index');
$router->get('blog/:slug', [BlogController::class, 'show'])
       ->whereSlug('slug')
       ->name('blog.show');

// Routes d'utilisateurs (CRUD complet)
$router->get('users', [UserController::class, 'index'])->name('users.index');
$router->get('users/create', [UserController::class, 'create'])->name('users.create');
$router->post('users', [UserController::class, 'store'])->name('users.store');
$router->get('users/:id', [UserController::class, 'show'])
       ->whereNumber('id')
       ->name('users.show');
$router->get('users/:id/edit', [UserController::class, 'edit'])
       ->whereNumber('id')
       ->name('users.edit');
$router->put('users/:id', [UserController::class, 'update'])
       ->whereNumber('id')
       ->name('users.update');
$router->delete('users/:id', [UserController::class, 'destroy'])
       ->whereNumber('id')
       ->name('users.destroy');

// Routes avec paramètres multiples
$router->get('categories/:category/products/:id', [ProductController::class, 'show'])
       ->whereSlug('category')
       ->whereNumber('id')
       ->name('products.show');

// Routes avec paramètres optionnels (via plusieurs définitions)
$router->get('search', [SearchController::class, 'index'])->name('search');
$router->get('search/:query', [SearchController::class, 'results'])
       ->where('query', '[^/]+')
       ->name('search.results');

/**
 * Générateur d'URLs basé sur les routes nommées
 */
class UrlGenerator
{
    protected $routes = [];
    protected $baseUrl;
    protected $scheme;
      public function __construct(array $routes = [], string $baseUrl = null)
    {
        $this->routes = $routes;
        $this->baseUrl = $baseUrl ?? $this->detectBaseUrl();
        $this->scheme = isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on' ? 'https' : 'http';
    }
    
    /**
     * Génère une URL à partir d'un nom de route
     * @param string $name - Nom de la route
     * @param array $params - Paramètres à injecter dans l'URL
     * @param array $query - Paramètres de query string (?param=value)
     * @param bool $absolute - Générer une URL absolue ou relative
     * @return string URL générée
     */
    public function route(string $name, array $params = [], array $query = [], bool $absolute = false): string
    {
        if (!isset($this->routes[$name])) {
            throw new \InvalidArgumentException("Route '{$name}' non trouvée");
        }
        
        $route = $this->routes[$name];
        $path = $route->getPath();
        
        // Remplace les paramètres dans le chemin
        $url = $this->replaceParameters($path, $params);
        
        // Ajoute les paramètres de query string
        if (!empty($query)) {
            $url .= '?' . http_build_query($query);
        }        
        // Retourne une URL absolue ou relative
        if ($absolute) {
            return $this->scheme . '://' . $this->baseUrl . '/' . ltrim($url, '/');
        }
        
        return '/' . ltrim($url, '/');
    }
        /**
     * Génère une URL absolue
     */
    public function routeAbsolute(string $name, array $params = [], array $query = []): string
    {
        return $this->route($name, $params, $query, true);
    }
        /**
     * Remplace les paramètres dans le chemin de la route
     */
    protected function replaceParameters(string $path, array $params): string
    {
        // Trouve tous les paramètres :nom dans le chemin
        preg_match_all('/:([\w]+)/', $path, $matches);
        
        $missingParams = [];
        
        foreach ($matches[1] as $paramName) {
            if (!array_key_exists($paramName, $params)) {
                $missingParams[] = $paramName;
                continue;
            }            
            // Remplace :paramName par la valeur
            $path = str_replace(':' . $paramName, $params[$paramName], $path);
        }
        
        if (!empty($missingParams)) {
            throw new \InvalidArgumentException(
                'Paramètres manquants pour générer l\'URL : ' . implode(', ', $missingParams)
            );
        }
        
        return $path;
    }
        /**
     * Détecte l'URL de base automatiquement
     */
    protected function detectBaseUrl(): string
    {
        $host = $_SERVER['HTTP_HOST'] ?? 'localhost';
        $scriptName = dirname($_SERVER['SCRIPT_NAME']);
        $basePath = rtrim(str_replace('\\', '/', $scriptName), '/');
        
        return $host . $basePath;
    }
        /**
     * Ajoute des routes au générateur
     */
    public function addRoute(string $name, Route $route): void
    {
        $this->routes[$name] = $route;
    }
        /**
     * Génère une URL pour un asset (CSS, JS, images)
     */
    public function asset(string $path, bool $absolute = false): string
    {
        $url = '/assets/' . ltrim($path, '/');
        
        if ($absolute) {
            return $this->scheme . '://' . $this->baseUrl . $url;
        }
        
        return $url;
    }
        /**
     * Vérifie si une route existe
     */
    public function hasRoute(string $name): bool
    {
        return isset($this->routes[$name]);
    }
        /**
     * Récupère toutes les routes nommées
     */
    public function getAllRoutes(): array
    {
        return $this->routes;
    }
}

class Router
{
    protected $routes = [];    protected $namedRoutes = [];
    protected $urlGenerator;
    
    // ...existing code...
    
    /**
     * Modifie addRoute pour gérer les routes nommées
     */
    protected function addRoute(string $method, string $path, $callback): Route
    {
        $route = new Route($method, $path, $callback);
        $this->routes[] = $route;
          return $route;
    }
    
    /**
     * Enregistre une route nommée
     */
    public function registerNamedRoute(string $name, Route $route): void
    {
        if (isset($this->namedRoutes[$name])) {
            throw new \InvalidArgumentException("Route '{$name}' déjà définie");
        }
        
        $this->namedRoutes[$name] = $route;
        
        // Ajoute la route au générateur d'URLs
        $this->getUrlGenerator()->addRoute($name, $route);
    }
    
    /**
     * Récupère le générateur d'URLs
     */    public function getUrlGenerator(): UrlGenerator
    {
        if ($this->urlGenerator === null) {
            $this->urlGenerator = new UrlGenerator($this->namedRoutes);
        }
        
        return $this->urlGenerator;
    }
    
    /**
     * Génère une URL à partir d'un nom de route (méthode raccourci)
     */    public function url(string $name, array $params = [], array $query = []): string
    {
        return $this->getUrlGenerator()->route($name, $params, $query);
    }
    
    /**
     * Récupère une route par son nom
     */    public function getRoute(string $name): ?Route
    {
        return $this->namedRoutes[$name] ?? null;
    }
    
    /**
     * Vérifie si une route nommée existe
     */    public function hasRoute(string $name): bool
    {
        return isset($this->namedRoutes[$name]);
    }
}

/**
 * Modification de la classe Route pour gérer les noms
 */
class Route
{
    // ...existing code...
    
    /**
     * Définit le nom de la route et l'enregistre dans le routeur
     */
    public function name(string $name): self
    {
        $this->name = $name;
        
        // Si on a accès au routeur, enregistre la route nommée
        if (isset($this->router)) {
            $this->router->registerNamedRoute($name, $this);
        }
        
        return $this;
    }
}

// Dans un contrôleur
class UserController
{    protected $router;
    
    public function __construct(Router $router)
    {
        $this->router = $router;
    }
    
    public function store($request)
    {
        // Logique de création de l'utilisateur...
          $user = $this->userRepository->create($validatedData);
        
        // Redirection vers la page de l'utilisateur créé
        $redirectUrl = $this->router->url('users.show', ['id' => $user->id]);
        
        return new RedirectResponse($redirectUrl, [
            'success' => 'Utilisateur créé avec succès'
        ]);
    }
      public function edit($request)    {
        $user = $this->userRepository->find($request->params['id']);
        
        // Génération d'URLs pour la vue
        $urls = [
            'update' => $this->router->url('users.update', ['id' => $user->id]),
            'show' => $this->router->url('users.show', ['id' => $user->id]),
            'index' => $this->router->url('users.index')
        ];
        
        return new View('users/edit', [
            'user' => $user,
            'urls' => $urls
        ]);
    }
}

// Fonction helper globale (à inclure dans functions.php)

/**
 * Instance globale du routeur
 */
$globalRouter = null;

/**
 * Définit le routeur global */
function setGlobalRouter(Router $router): void
{
    global $globalRouter;
    $globalRouter = $router;
}

/**
 * Génère une URL à partir d'un nom de route
 */
function route(string $name, array $params = [], array $query = []): string
{
    global $globalRouter;
    
    if ($globalRouter === null) {
        throw new \RuntimeException('Router global non défini');
    }
    
    return $globalRouter->url($name, $params, $query);
}

/**
 * Génère une URL absolue
 */
function route_absolute(string $name, array $params = [], array $query = []): string
{
    global $globalRouter;
    
    return $globalRouter->getUrlGenerator()->routeAbsolute($name, $params, $query);
}

/**
 * Génère une URL d'asset
 */
function asset(string $path, bool $absolute = false): string
{
    global $globalRouter;
    
    return $globalRouter->getUrlGenerator()->asset($path, $absolute);
}

/**
 * Vérifie si la route actuelle correspond au nom donné
 */
function is_current_route(string $name): bool
{
    // Cette fonction nécessiterait de stocker la route courante
    // dans une variable globale lors du dispatch
    global $currentRoute;
    
    return $currentRoute && $currentRoute->getName() === $name;
}

<nav class="main-navigation">
    <ul>
        <li class="<?= is_current_route('home') ? 'active' : '' ?>">
            <a href="<?= route('home') ?>">Accueil</a>
        </li>
        <li class="<?= is_current_route('blog.index') ? 'active' : '' ?>">
            <a href="<?= route('blog.index') ?>">Blog</a>
        </li>
        <li class="<?= is_current_route('about') ? 'active' : '' ?>">
            <a href="<?= route('about') ?>">À propos</a>
        </li>
        <li class="<?= is_current_route('contact') ? 'active' : '' ?>">
            <a href="<?= route('contact') ?>">Contact</a>
        </li>
    </ul>
</nav>


<form method="POST" action="<?= route('contact.submit') ?>">
    <label>Nom:
        <input type="text" name="name" required>
    </label>
      <label>Email:
        <input type="email" name="email" required>
    </label>
    
    <label>Message:
        <textarea name="message" required></textarea>
    </label>
    
    <button type="submit">Envoyer</button>
</form>


<div class="user-list">    <?php foreach ($users as $user): ?>
        <div class="user-card">
            <h3><a href="<?= route('users.show', ['id' => $user->id]) ?>">
                <?= htmlspecialchars($user->name) ?>
            </a></h3>
            
            <p><?= htmlspecialchars($user->email) ?></p>
            
            <div class="actions">
                <a href="<?= route('users.edit', ['id' => $user->id]) ?>" class="btn btn-primary">Modifier</a>
                
                <form method="POST" action="<?= route('users.destroy', ['id' => $user->id]) ?>" style="display: inline;">
                    <input type="hidden" name="_method" value="DELETE">                    <button type="submit" class="btn btn-danger" onclick="return confirm('Êtes-vous sûr ?')">
                        Supprimer                    </button>                </form>
            </div>
        </div>
    
</div>


<div class="pagination">
    
        <a href="<?= route('users.index', [], ['page' => $currentPage - 1]) ?>">« Précédent</a>
    
    
    Page <?= $currentPage ?> sur <?= $totalPages ?>
    
    
        <a href="<?= route('users.index', [], ['page' => $currentPage + 1]) ?>">Suivant »</a>
    
</div>


<link rel="stylesheet" href="<?= asset('css/main.css') ?>">
<script src="<?= asset('js/app.js') ?>"></script>