🏗️ Design Patterns en PHP : Le Guide Complet avec Exemples Pratiques

// ✅ SINGLETON : CONNEXION BASE DE DONNÉES
<?php

class DatabaseConnection {
    private static $instance = null;
    private $connection;

    // Constructeur privé pour empêcher l'instanciation directe
    private function __construct() {
        $this->connection = new PDO(
            'mysql:host=localhost;dbname=test',
            'username',
            'password'
        );
        $this->connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    }

    // Empêcher le clonage
    private function __clone() {}

    // Empêcher la désérialisation
    public function __wakeup() {
        throw new Exception("Cannot unserialize singleton");
    }

    // Méthode statique pour obtenir l'instance unique
    public static function getInstance() {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    // Méthode pour obtenir la connexion
    public function getConnection() {
        return $this->connection;
    }
}

// UTILISATION
$db1 = DatabaseConnection::getInstance();
$db2 = DatabaseConnection::getInstance();

var_dump($db1 === $db2); // bool(true) - Même instance

// Utilisation de la connexion
$stmt = $db1->getConnection()->prepare("SELECT * FROM users");
$stmt->execute();
$results = $stmt->fetchAll(PDO::FETCH_ASSOC);
?>

// ✅ FACTORY PATTERN : SYSTÈME DE NOTIFICATION
<?php

// Interface commune
interface Notification {
    public function send($message, $recipient);
}

// Implémentations concrètes
class EmailNotification implements Notification {
    public function send($message, $recipient) {
        echo "Envoi d'email à $recipient : $message<br>";
        // Logique d'envoi d'email réelle
        return true;
    }
}

class SMSNotification implements Notification {
    public function send($message, $recipient) {
        echo "Envoi de SMS à $recipient : $message<br>";
        // Logique d'envoi SMS réelle
        return true;
    }
}

class PushNotification implements Notification {
    public function send($message, $recipient) {
        echo "Envoi de notification push à $recipient : $message<br>";
        // Logique d'envoi push réelle
        return true;
    }
}

// Factory pour créer les notifications
class NotificationFactory {
    public static function createNotification($type) {
        switch (strtolower($type)) {
            case 'email':
                return new EmailNotification();
            case 'sms':
                return new SMSNotification();
            case 'push':
                return new PushNotification();
            default:
                throw new InvalidArgumentException("Type de notification non supporté: $type");
        }
    }
}

// UTILISATION
try {
    $emailNotif = NotificationFactory::createNotification('email');
    $smsNotif = NotificationFactory::createNotification('sms');
    $pushNotif = NotificationFactory::createNotification('push');

    $emailNotif->send("Bienvenue sur notre site!", "user@example.com");
    $smsNotif->send("Votre code de vérification: 123456", "+33612345678");
    $pushNotif->send("Nouveau message reçu", "device_token_abc");
} catch (Exception $e) {
    echo "Erreur: " . $e->getMessage();
}
?>

// ✅ BUILDER PATTERN : CONSTRUCTION DE REQUÊTES SQL
<?php

class QueryBuilder {
    private $select = ['*'];
    private $from;
    private $where = [];
    private $orderBy = [];
    private $limit;
    private $offset;

    public function select($columns) {
        $this->select = is_array($columns) ? $columns : func_get_args();
        return $this;
    }

    public function from($table, $alias = null) {
        $this->from = $alias ? "$table AS $alias" : $table;
        return $this;
    }

    public function where($column, $operator, $value = null) {
        if ($value === null) {
            $value = $operator;
            $operator = '=';
        }
        $this->where[] = [$column, $operator, $value];
        return $this;
    }

    public function orderBy($column, $direction = 'ASC') {
        $this->orderBy[] = [$column, $direction];
        return $this;
    }

    public function limit($limit) {
        $this->limit = $limit;
        return $this;
    }

    public function offset($offset) {
        $this->offset = $offset;
        return $this;
    }

    public function build() {
        $sql = "SELECT " . implode(', ', $this->select);
        $sql .= " FROM " . $this->from;

        if (!empty($this->where)) {
            $sql .= " WHERE ";
            $conditions = [];
            foreach ($this->where as $where) {
                $conditions[] = "$where[0] $where[1] ?";
            }
            $sql .= implode(' AND ', $conditions);
        }

        if (!empty($this->orderBy)) {
            $sql .= " ORDER BY ";
            $orders = [];
            foreach ($this->orderBy as $order) {
                $orders[] = "$order[0] $order[1]";
            }
            $sql .= implode(', ', $orders);
        }

        if ($this->limit !== null) {
            $sql .= " LIMIT " . $this->limit;
        }

        if ($this->offset !== null) {
            $sql .= " OFFSET " . $this->offset;
        }

        return $sql;
    }

    public function getParams() {
        $params = [];
        foreach ($this->where as $where) {
            $params[] = $where[2];
        }
        return $params;
    }
}

// UTILISATION
$queryBuilder = new QueryBuilder();

$query = $queryBuilder
    ->select(['id', 'name', 'email'])
    ->from('users')
    ->where('status', '=', 'active')
    ->where('age', '>', 18)
    ->orderBy('name', 'ASC')
    ->limit(10)
    ->offset(0)
    ->build();

$params = $queryBuilder->getParams();

echo "Requête SQL: $query<br>";
echo "Paramètres: " . implode(', ', $params);
?>

// ✅ ADAPTER PATTERN : API EXTERNE PAYPAL
<?php

// Interface que notre système attend
interface PaymentProcessor {
    public function processPayment($amount, $currency);
}

// API PayPal externe (interface différente)
class PayPalApi {
    public function sendPayment($amountInCents, $currencyCode) {
        echo "PayPal: Paiement de $amountInCents cents en $currencyCode<br>";
        return "PAYPAL_TRX_" . uniqid();
    }

    public function getTransactionStatus($transactionId) {
        return "COMPLETED";
    }
}

// Adaptateur pour PayPal
class PayPalAdapter implements PaymentProcessor {
    private $paypal;

    public function __construct(PayPalApi $paypal) {
        $this->paypal = $paypal;
    }

    public function processPayment($amount, $currency) {
        // Conversion: euros en cents pour PayPal
        $amountInCents = $amount * 100;

        // Conversion: code devise complet vers code ISO
        $currencyCode = strtoupper(substr($currency, 0, 3));

        $transactionId = $this->paypal->sendPayment($amountInCents, $currencyCode);

        return [
            'success' => true,
            'transaction_id' => $transactionId,
            'amount' => $amount,
            'currency' => $currency
        ];
    }
}

// UTILISATION
$paypalApi = new PayPalApi();
$paypalAdapter = new PayPalAdapter($paypalApi);

function processOrder(PaymentProcessor $processor, $amount, $currency) {
    echo "Traitement de la commande...<br>";
    $result = $processor->processPayment($amount, $currency);
    echo "Résultat: " . json_encode($result) . "<br>";
}

// Notre système peut maintenant utiliser PayPal via l'adaptateur
processOrder($paypalAdapter, 99.99, 'EUR');
?>

// ✅ DECORATOR PATTERN : SYSTÈME DE CACHE
<?php

// Interface commune
interface DataService {
    public function getData($id);
}

// Service concret (coûteux en performance)
class DatabaseService implements DataService {
    public function getData($id) {
        // Simulation d'une requête coûteuse
        sleep(1);
        echo "Requête DB pour ID: $id<br>";
        return ['id' => $id, 'data' => "Données depuis DB pour $id"];
    }
}

// Decorator de base (abstrait)
abstract class DataServiceDecorator implements DataService {
    protected $wrappedService;

    public function __construct(DataService $service) {
        $this->wrappedService = $service;
    }

    public function getData($id) {
        return $this->wrappedService->getData($id);
    }
}

// Decorator de cache
class CacheDecorator extends DataServiceDecorator {
    private $cache = [];
    private $ttl = 3600; // 1 heure
    private $cacheTimestamps = [];

    public function getData($id) {
        if ($this->hasValidCache($id)) {
            echo "Cache HIT pour ID: $id<br>";
            return $this->cache[$id];
        }

        echo "Cache MISS pour ID: $id<br>";
        $data = parent::getData($id);

        // Mettre en cache
        $this->cache[$id] = $data;
        $this->cacheTimestamps[$id] = time();

        return $data;
    }

    private function hasValidCache($id) {
        if (!isset($this->cache[$id])) {
            return false;
        }

        $cacheAge = time() - $this->cacheTimestamps[$id];
        return $cacheAge < $this->ttl;
    }

    public function clearCache() {
        $this->cache = [];
        $this->cacheTimestamps = [];
    }
}

// Decorator de logging
class LoggingDecorator extends DataServiceDecorator {
    private $logs = [];

    public function getData($id) {
        $startTime = microtime(true);

        $this->log("Début requête pour ID: $id");
        $data = parent::getData($id);

        $endTime = microtime(true);
        $duration = round(($endTime - $startTime) * 1000, 2);

        $this->log("Fin requête pour ID: $id - Durée: $duration ms");

        return $data;
    }

    private function log($message) {
        $timestamp = date('Y-m-d H:i:s');
        $logEntry = "[$timestamp] $message";
        $this->logs[] = $logEntry;
        echo "LOG: $logEntry<br>";
    }

    public function getLogs() {
        return $this->logs;
    }
}

// UTILISATION : Empilement de décorateurs
echo "=== Sans décorateurs ===<br>";
$simpleService = new DatabaseService();
$simpleService->getData(1);
$simpleService->getData(1); // Toujours lent

echo "<br>=== Avec cache ===<br>";
$cachedService = new CacheDecorator(new DatabaseService());
$cachedService->getData(2); // Lent (cache miss)
$cachedService->getData(2); // Rapide (cache hit)

echo "<br>=== Avec cache ET logging ===<br>";
$fullService = new LoggingDecorator(
    new CacheDecorator(
        new DatabaseService()
    )
);

$fullService->getData(3);
$fullService->getData(3);
?>

// ✅ FACADE PATTERN : API SIMPLIFIÉE PAIEMENT
<?php

// Sous-systèmes complexes
class PaymentGateway {
    public function processCreditCard($cardNumber, $amount) {
        // Logique complexe de traitement de carte
        echo "Processing credit card payment of $amount€<br>";
        return "CC_TRX_" . uniqid();
    }

    public function processPayPal($email, $amount) {
        echo "Processing PayPal payment of $amount€ to $email<br>";
        return "PP_TRX_" . uniqid();
    }
}

class InventoryManager {
    public function checkStock($productId, $quantity) {
        // Logique complexe de vérification de stock
        echo "Checking stock for product $productId<br>";
        return true; // Simulation
    }

    public function updateStock($productId, $quantity) {
        echo "Updating stock for product $productId (-$quantity)<br>";
        return true;
    }
}

class ShippingService {
    public function calculateShipping($address, $weight) {
        // Logique complexe de calcul de frais de port
        echo "Calculating shipping to $address<br>";
        return 5.99; // Frais de port fixes pour l'exemple
    }

    public function scheduleDelivery($address, $items) {
        echo "Scheduling delivery to $address<br>";
        return "DELIVERY_" . uniqid();
    }
}

class EmailService {
    public function sendOrderConfirmation($email, $orderDetails) {
        echo "Sending confirmation email to $email<br>";
        return true;
    }
}

// Facade : Interface simplifiée
class OrderFacade {
    private $paymentGateway;
    private $inventoryManager;
    private $shippingService;
    private $emailService;

    public function __construct() {
        $this->paymentGateway = new PaymentGateway();
        $this->inventoryManager = new InventoryManager();
        $this->shippingService = new ShippingService();
        $this->emailService = new EmailService();
    }

    public function placeOrder($orderData) {
        echo "=== DÉBUT TRAITEMENT COMMANDE ===<br>";

        // 1. Vérifier le stock
        foreach ($orderData['items'] as $item) {
            if (!$this->inventoryManager->checkStock($item['product_id'], $item['quantity'])) {
                throw new Exception("Stock insuffisant pour le produit $item[product_id]");
            }
        }

        // 2. Calculer les frais de port
        $shippingCost = $this->shippingService->calculateShipping(
            $orderData['shipping_address'],
            $orderData['total_weight']
        );

        // 3. Traiter le paiement
        $totalAmount = $orderData['subtotal'] + $shippingCost;

        if ($orderData['payment_method'] === 'credit_card') {
            $transactionId = $this->paymentGateway->processCreditCard(
                $orderData['card_number'],
                $totalAmount
            );
        } elseif ($orderData['payment_method'] === 'paypal') {
            $transactionId = $this->paymentGateway->processPayPal(
                $orderData['paypal_email'],
                $totalAmount
            );
        }

        // 4. Mettre à jour le stock
        foreach ($orderData['items'] as $item) {
            $this->inventoryManager->updateStock($item['product_id'], $item['quantity']);
        }

        // 5. Planifier la livraison
        $deliveryId = $this->shippingService->scheduleDelivery(
            $orderData['shipping_address'],
            $orderData['items']
        );

        // 6. Envoyer confirmation email
        $this->emailService->sendOrderConfirmation(
            $orderData['customer_email'],
            [
                'transaction_id' => $transactionId,
                'delivery_id' => $deliveryId,
                'total_amount' => $totalAmount
            ]
        );

        echo "=== COMMANDE TERMINÉE AVEC SUCCÈS ===<br><br>";

        return [
            'success' => true,
            'transaction_id' => $transactionId,
            'delivery_id' => $deliveryId,
            'total_amount' => $totalAmount
        ];
    }
}

// UTILISATION SIMPLIFIÉE
$orderFacade = new OrderFacade();

$orderData = [
    'customer_email' => 'client@example.com',
    'payment_method' => 'credit_card',
    'card_number' => '4111-1111-1111-1111',
    'shipping_address' => '123 Rue Exemple, Paris',
    'subtotal' => 99.99,
    'total_weight' => 2.5,
    'items' => [
        ['product_id' => 101, 'quantity' => 2],
        ['product_id' => 202, 'quantity' => 1]
    ]
];

try {
    $result = $orderFacade->placeOrder($orderData);
    echo "Résultat: " . json_encode($result, JSON_PRETTY_PRINT);
} catch (Exception $e) {
    echo "Erreur: " . $e->getMessage();
}
?>

// ✅ OBSERVER PATTERN : NEWSLETTER ET NOTIFICATIONS
<?php

// Interface Observer
interface Observer {
    public function update($event, $data = null);
}

// Interface Subject (Observable)
interface Subject {
    public function attach(Observer $observer);
    public function detach(Observer $observer);
    public function notify($event, $data = null);
}

// Sujet concret : Gestionnaire d'utilisateurs
class UserManager implements Subject {
    private $observers = [];
    private $users = [];

    public function attach(Observer $observer) {
        $this->observers[] = $observer;
    }

    public function detach(Observer $observer) {
        $key = array_search($observer, $this->observers, true);
        if ($key !== false) {
            unset($this->observers[$key]);
        }
    }

    public function notify($event, $data = null) {
        foreach ($this->observers as $observer) {
            $observer->update($event, $data);
        }
    }

    public function registerUser($userData) {
        $userId = uniqid('user_');
        $user = array_merge(['id' => $userId], $userData);
        $this->users[$userId] = $user;

        // Notifier les observateurs
        $this->notify('user_registered', $user);

        echo "Utilisateur enregistré: $user[email]<br>";
        return $userId;
    }

    public function updateUserProfile($userId, $profileData) {
        if (!isset($this->users[$userId])) {
            throw new Exception("Utilisateur non trouvé");
        }

        $this->users[$userId] = array_merge($this->users[$userId], $profileData);

        $this->notify('profile_updated', [
            'user_id' => $userId,
            'profile_data' => $profileData
        ]);

        echo "Profil mis à jour pour l'utilisateur: $userId<br>";
    }

    public function makePurchase($userId, $amount) {
        if (!isset($this->users[$userId])) {
            throw new Exception("Utilisateur non trouvé");
        }

        $purchaseData = [
            'user_id' => $userId,
            'amount' => $amount,
            'date' => date('Y-m-d H:i:s')
        ];

        $this->notify('purchase_made', $purchaseData);

        echo "Achat effectué par $userId : $amount€<br>";
    }
}

// Observateurs concrets
class EmailNotifier implements Observer {
    public function update($event, $data = null) {
        switch ($event) {
            case 'user_registered':
                $this->sendWelcomeEmail($data['email'], $data['name']);
                break;
            case 'purchase_made':
                $user = $this->getUserById($data['user_id']);
                $this->sendPurchaseConfirmation($user['email'], $data['amount']);
                break;
        }
    }

    private function sendWelcomeEmail($email, $name) {
        echo "[EMAIL] Email de bienvenue envoyé à $email (Bonjour $name!)<br>";
    }

    private function sendPurchaseConfirmation($email, $amount) {
        echo "[EMAIL] Confirmation d'achat envoyée à $email ($amount€)<br>";
    }

    private function getUserById($userId) {
        // Simulation - en réalité on irait chercher en DB
        return ['email' => 'user@example.com'];
    }
}

class NewsletterManager implements Observer {
    private $subscribers = [];

    public function update($event, $data = null) {
        if ($event === 'user_registered') {
            $this->addToNewsletter($data['email'], $data['name']);
        }
    }

    private function addToNewsletter($email, $name) {
        $this->subscribers[] = ['email' => $email, 'name' => $name];
        echo "[NEWSLETTER] $email ajouté à la newsletter<br>";
    }

    public function getSubscribers() {
        return $this->subscribers;
    }
}

class ActivityLogger implements Observer {
    private $logs = [];

    public function update($event, $data = null) {
        $timestamp = date('Y-m-d H:i:s');
        $logEntry = "[$timestamp] Événement: $event";

        if ($data) {
            $logEntry .= " - Données: " . json_encode($data);
        }

        $this->logs[] = $logEntry;
        echo "[LOG] $logEntry<br>";
    }

    public function getLogs() {
        return $this->logs;
    }
}

// UTILISATION
$userManager = new UserManager();

// Création des observateurs
$emailNotifier = new EmailNotifier();
$newsletterManager = new NewsletterManager();
$activityLogger = new ActivityLogger();

// Attachement des observateurs
$userManager->attach($emailNotifier);
$userManager->attach($newsletterManager);
$userManager->attach($activityLogger);

echo "=== Enregistrement d'un nouvel utilisateur ===<br>";
$userId = $userManager->registerUser([
    'name' => 'Alice Dupont',
    'email' => 'alice@example.com'
]);

echo "<br>=== Mise à jour du profil ===<br>";
$userManager->updateUserProfile($userId, [
    'phone' => '0123456789'
]);

echo "<br>=== Achat effectué ===<br>";
$userManager->makePurchase($userId, 99.99);

// Détacher un observateur
$userManager->detach($newsletterManager);

echo "<br>=== Nouvel utilisateur (sans newsletter) ===<br>";
$userManager->registerUser([
    'name' => 'Bob Martin',
    'email' => 'bob@example.com'
]);
?>

// ✅ STRATEGY PATTERN : SYSTÈME DE PAIEMENT
<?php

// Interface Strategy
interface PaymentStrategy {
    public function pay($amount);
    public function getName();
}

// Stratégies concrètes
class CreditCardPayment implements PaymentStrategy {
    private $cardNumber;
    private $cardHolder;
    private $cvv;

    public function __construct($cardNumber, $cardHolder, $cvv) {
        $this->cardNumber = $cardNumber;
        $this->cardHolder = $cardHolder;
        $this->cvv = $cvv;
    }

    public function pay($amount) {
        // Validation de la carte
        if (!$this->validateCard()) {
            throw new Exception("Carte invalide");
        }

        // Logique de paiement par carte
        echo "Processing credit card payment of $amount€<br>";
        echo "Card: **** **** **** " . substr($this->cardNumber, -4) . "<br>";

        return [
            'success' => true,
            'transaction_id' => 'CC_' . uniqid(),
            'amount' => $amount,
            'method' => 'credit_card'
        ];
    }

    public function getName() {
        return "Carte Bancaire";
    }

    private function validateCard() {
        // Validation simple pour l'exemple
        return strlen($this->cardNumber) === 16
            && strlen($this->cvv) === 3;
    }
}

class PayPalPayment implements PaymentStrategy {
    private $email;
    private $password;

    public function __construct($email, $password) {
        $this->email = $email;
        $this->password = $password;
    }

    public function pay($amount) {
        // Authentification PayPal
        if (!$this->authenticate()) {
            throw new Exception("Authentification PayPal échouée");
        }

        echo "Processing PayPal payment of $amount€<br>";
        echo "Account: $this->email<br>";

        return [
            'success' => true,
            'transaction_id' => 'PP_' . uniqid(),
            'amount' => $amount,
            'method' => 'paypal'
        ];
    }

    public function getName() {
        return "PayPal";
    }

    private function authenticate() {
        // Simulation d'authentification
        return !empty($this->email) && !empty($this->password);
    }
}

class BankTransferPayment implements PaymentStrategy {
    private $iban;
    private $bic;

    public function __construct($iban, $bic) {
        $this->iban = $iban;
        $this->bic = $bic;
    }

    public function pay($amount) {
        // Logique de virement bancaire
        echo "Processing bank transfer of $amount€<br>";
        echo "IBAN: **** **** **** " . substr($this->iban, -4) . "<br>";
        echo "BIC: $this->bic<br>";

        return [
            'success' => true,
            'transaction_id' => 'BT_' . uniqid(),
            'amount' => $amount,
            'method' => 'bank_transfer'
        ];
    }

    public function getName() {
        return "Virement Bancaire";
    }
}

// Contexte qui utilise une stratégie
class ShoppingCart {
    private $items = [];
    private $paymentStrategy;

    public function addItem($item, $price) {
        $this->items[] = ['item' => $item, 'price' => $price];
    }

    public function getTotal() {
        $total = 0;
        foreach ($this->items as $item) {
            $total += $item['price'];
        }
        return $total;
    }

    public function setPaymentStrategy(PaymentStrategy $strategy) {
        $this->paymentStrategy = $strategy;
    }

    public function checkout() {
        if (empty($this->paymentStrategy)) {
            throw new Exception("Aucune méthode de paiement sélectionnée");
        }

        $total = $this->getTotal();
        if ($total <= 0) {
            throw new Exception("Le panier est vide");
        }

        echo "=== CHECKOUT ===<br>";
        echo "Méthode de paiement: " . $this->paymentStrategy->getName() . "<br>";
        echo "Total: $total€<br>";

        return $this->paymentStrategy->pay($total);
    }

    public function displayItems() {
        echo "=== PANIER ===<br>";
        foreach ($this->items as $item) {
            echo "- $item[item] : $item[price]€<br>";
        }
        echo "Total: " . $this->getTotal() . "€<br><br>";
    }
}

// UTILISATION
$cart = new ShoppingCart();

// Ajout d'articles
$cart->addItem('Laptop', 899.99);
$cart->addItem('Souris', 29.99);
$cart->addItem('Clavier', 59.99);

$cart->displayItems();

echo "=== Test avec Carte Bancaire ===<br>";
$creditCard = new CreditCardPayment(
    '4111111111111111',
    'Alice Dupont',
    '123'
);
$cart->setPaymentStrategy($creditCard);
$result1 = $cart->checkout();

echo "<br>=== Test avec PayPal ===<br>";
$paypal = new PayPalPayment(
    'alice@example.com',
    'secret123'
);
$cart->setPaymentStrategy($paypal);
$result2 = $cart->checkout();

echo "<br>=== Test avec Virement Bancaire ===<br>";
$bankTransfer = new BankTransferPayment(
    'FR7630001007941234567890185',
    'BNPAFRPP'
);
$cart->setPaymentStrategy($bankTransfer);
$result3 = $cart->checkout();

echo "<br>=== Résumé des transactions ===<br>";
echo "1. Carte: " . $result1['transaction_id'] . "<br>";
echo "2. PayPal: " . $result2['transaction_id'] . "<br>";
echo "3. Virement: " . $result3['transaction_id'] . "<br>";
?>

// ✅ COMMAND PATTERN : SYSTÈME UNDO/REDO
<?php

// Interface Command
interface Command {
    public function execute();
    public function undo();
    public function getDescription();
}

// Receiver : Éditeur de texte
class TextEditor {
    private $content = '';
    private $cursorPosition = 0;

    public function getContent() {
        return $this->content;
    }

    public function insertText($text, $position = null) {
        if ($position === null) {
            $position = $this->cursorPosition;
        }

        $before = substr($this->content, 0, $position);
        $after = substr($this->content, $position);
        $this->content = $before . $text . $after;
        $this->cursorPosition = $position + strlen($text);

        return $position;
    }

    public function deleteText($position, $length) {
        if ($position < 0 || $position >= strlen($this->content)) {
            return null;
        }

        $deletedText = substr($this->content, $position, $length);
        $before = substr($this->content, 0, $position);
        $after = substr($this->content, $position + $length);
        $this->content = $before . $after;
        $this->cursorPosition = $position;

        return $deletedText;
    }

    public function setCursorPosition($position) {
        if ($position >= 0 && $position <= strlen($this->content)) {
            $this->cursorPosition = $position;
        }
    }

    public function getCursorPosition() {
        return $this->cursorPosition;
    }

    public function display() {
        echo "Contenu: \"" . $this->content . "\"<br>";
        echo "Curseur: position $this->cursorPosition<br>";
    }
}

// Commandes concrètes
class InsertTextCommand implements Command {
    private $editor;
    private $text;
    private $position;
    private $executedPosition;

    public function __construct(TextEditor $editor, $text, $position = null) {
        $this->editor = $editor;
        $this->text = $text;
        $this->position = $position;
    }

    public function execute() {
        $this->executedPosition = $this->editor->insertText($this->text, $this->position);
}

    public function undo() {
        $this->editor->deleteText($this->executedPosition, strlen($this->text));
}

    public function getDescription() {
        return "Insérer '" . substr($this->text, 0, 20) . "...' à la position $this->position";
    }
}

class DeleteTextCommand implements Command {
    private $editor;
    private $position;
    private $length;
    private $deletedText;

    public function __construct(TextEditor $editor, $position, $length) {
        $this->editor = $editor;
        $this->position = $position;
        $this->length = $length;
    }

    public function execute() {
        $this->deletedText = $this->editor->deleteText($this->position, $this->length);
        return $this->deletedText !== null;
}

    public function undo() {
        if ($this->deletedText !== null) {
            $this->editor->insertText($this->deletedText, $this->position);
        }
}

    public function getDescription() {
        return "Supprimer $this->length caractère(s) à la position $this->position";
    }
}

class MoveCursorCommand implements Command {
    private $editor;
    private $newPosition;
    private $oldPosition;

    public function __construct(TextEditor $editor, $newPosition) {
        $this->editor = $editor;
        $this->newPosition = $newPosition;
    }

    public function execute() {
        $this->oldPosition = $this->editor->getCursorPosition();
        $this->editor->setCursorPosition($this->newPosition);
}

    public function undo() {
        $this->editor->setCursorPosition($this->oldPosition);
}

    public function getDescription() {
        return "Déplacer le curseur à la position $this->newPosition";
    }
}

// Invoker : Gestionnaire de commandes (avec undo/redo)
class CommandManager {
    private $undoStack = [];
    private $redoStack = [];
    private $history = [];

    public function executeCommand(Command $command) {
        try {
            $command->execute();
            $this->undoStack[] = $command;
            $this->redoStack = []; // Vider redo quand on fait une nouvelle action
            $this->history[] = [
                'time' => date('H:i:s'),
                'command' => $command->getDescription()
            ];

            echo "✓ Command exécutée: " . $command->getDescription() . "<br>";
            return true;
        } catch (Exception $e) {
            echo "✗ Erreur: " . $e->getMessage() . "<br>";
            return false;
        }
    }

    public function undo() {
        if (empty($this->undoStack)) {
            echo "Rien à annuler<br>";
            return false;
        }

        $command = array_pop($this->undoStack);
        $command->undo();
        $this->redoStack[] = $command;

        echo "↶ Annulé: " . $command->getDescription() . "<br>";
        return true;
    }

    public function redo() {
        if (empty($this->redoStack)) {
            echo "Rien à refaire<br>";
            return false;
        }

        $command = array_pop($this->redoStack);
        $command->execute();
        $this->undoStack[] = $command;

        echo "↷ Refait: " . $command->getDescription() . "<br>";
        return true;
    }

    public function showHistory() {
        echo "=== HISTORIQUE ===<br>";
        foreach ($this->history as $index => $entry) {
            echo "$index+1. [$entry[time]] $entry[command]<br>";
        }
    }

    public function showStatus() {
        echo "=== ÉTAT ===<br>";
        echo "Undo stack: " . count($this->undoStack) . " commandes<br>";
        echo "Redo stack: " . count($this->redoStack) . " commandes<br>";
    }
}

// UTILISATION
$editor = new TextEditor();
$commandManager = new CommandManager();

echo "=== ÉDITEUR DE TEXTE AVEC UNDO/REDO ===<br><br>";

// État initial
$editor->display();
echo "<br>";

// Exécution de commandes
$commandManager->executeCommand(new InsertTextCommand($editor, "Bonjour le monde!"));
$editor->display();
echo "<br>";

$commandManager->executeCommand(new MoveCursorCommand($editor, 8));
$editor->display();
echo "<br>";

$commandManager->executeCommand(new InsertTextCommand($editor, "tout "));
$editor->display();
echo "<br>";

$commandManager->executeCommand(new DeleteTextCommand($editor, 0, 7));
$editor->display();
echo "<br>";

// Annulation
echo "=== ANNULATION ===<br>";
$commandManager->undo();
$editor->display();
echo "<br>";

$commandManager->undo();
$editor->display();
echo "<br>";

// Refaire
echo "=== REFAIRE ===<br>";
$commandManager->redo();
$editor->display();
echo "<br>";

$commandManager->redo();
$editor->display();
echo "<br>";

// Historique et état
$commandManager->showHistory();
echo "<br>";
$commandManager->showStatus();
?>