# OS et serveur web
Ubuntu 22.04 LTS
Nginx 1.20+ ou Apache 2.4+ avec mod_pagespeed
PHP 8.2+ avec OPcache
MySQL 8.0 ou MariaDB 10.6+
Redis pour object cache

# Configuration PHP optimisée
memory_limit = 512M
max_execution_time = 300
max_input_vars = 3000
upload_max_filesize = 128M
post_max_size = 128M
opcache.enable = 1
opcache.memory_consumption = 256
opcache.max_accelerated_files = 10000

-- Configuration my.cnf
[mysqld]
innodb_buffer_pool_size = 70% of total RAM
innodb_file_per_table = 1
innodb_flush_log_at_trx_commit = 2
innodb_flush_method = O_DIRECT
query_cache_type = 1
query_cache_size = 128M
query_cache_limit = 2M

-- Index WooCommerce custom
CREATE INDEX idx_meta_key_value ON wp_postmeta (meta_key, meta_value(20));
CREATE INDEX idx_user_meta_key ON wp_usermeta (meta_key);
CREATE INDEX idx_options_autoload ON wp_options (autoload);

-- Suppression données inutiles
DELETE FROM wp_postmeta WHERE meta_key = '_edit_lock';
DELETE FROM wp_postmeta WHERE meta_key = '_edit_last';
DELETE FROM wp_options WHERE option_name LIKE '_transient_%';
DELETE FROM wp_options WHERE option_name LIKE '_site_transient_%';

-- Optimisation tables
OPTIMIZE TABLE wp_posts, wp_postmeta, wp_options, wp_woocommerce_sessions;

server {
    listen 80;
    server_name example.com;
    root /var/www/example.com/public_html;
    index index.php index.html;

    # Gzip compression
    gzip on;
    gzip_vary on;
    gzip_min_length 1024;
    gzip_types
        application/atom+xml
        application/javascript
        application/json
        application/rss+xml
        application/vnd.ms-fontobject
        application/x-font-ttf
        application/x-web-app-manifest+json
        application/xhtml+xml
        application/xml
        font/opentype
        image/svg+xml
        image/x-icon
        text/css
        text/plain
        text/x-component;

    # Browser caching
    location ~* \.(css|js|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
        expires 1y;
        add_header Cache-Control "public, immutable";
        add_header Vary Accept-Encoding;
    }

    # WooCommerce security
    location ~ ^/wp-content/uploads/wc-logs/ {
        deny all;
    }
    
    location ~ ^/wp-content/uploads/.*\.php$ {
        deny all;
    }

    # PHP-FPM optimized
    location ~ \.php$ {
        fastcgi_pass unix:/var/run/php/php8.2-fpm.sock;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        
        # Cache PHP scripts
        fastcgi_cache_valid 200 60m;
        fastcgi_cache_key $scheme$request_method$host$request_uri;
        add_header X-FastCGI-Cache $upstream_cache_status;
    }
}

# Installation Redis
sudo apt install redis-server

# Configuration wp-config.php
define('WP_REDIS_HOST', '127.0.0.1');
define('WP_REDIS_PORT', 6379);
define('WP_REDIS_PASSWORD', 'your_secure_password');
define('WP_REDIS_DATABASE', 0);
define('WP_REDIS_MAXTTL', 86400);

# Plugin Redis Object Cache
wp plugin install redis-cache --activate
wp redis enable

// Configuration avancée W3TC
$config = array(
    'pgcache.enabled' => true,
    'pgcache.engine' => 'redis',
    'pgcache.cache.home' => true,
    'pgcache.cache.feed' => true,
    'pgcache.cache.nginx_handle_xml' => true,
    
    // Database cache
    'dbcache.enabled' => true,
    'dbcache.engine' => 'redis',
    
    // Object cache
    'objectcache.enabled' => true,
    'objectcache.engine' => 'redis',
    
    // Browser cache
    'browsercache.enabled' => true,
    'browsercache.cssjs.expires' => 31536000,
    'browsercache.html.expires' => 3600,
);

// Pages dynamiques WooCommerce
$exclude_pages = array(
    '/cart/',
    '/checkout/',
    '/my-account/',
    '/wc-api/*',
    '/*add-to-cart=*',
    '/*remove_item=*',
    '/wishlist/',
    '/*?wc-ajax=*'
);

// Cookies à exclure
$exclude_cookies = array(
    'woocommerce_cart_hash',
    'woocommerce_items_in_cart', 
    'wp_woocommerce_session_',
    'woocommerce_recently_viewed'
);

<!-- Picture element pour compatibilité -->
<picture>
    <source srcset="product-image.webp" type="image/webp">
    <source srcset="product-image.avif" type="image/avif">
    <img src="product-image.jpg" alt="Description produit" loading="lazy">
</picture>

// Hook pour conversion WebP automatique
add_filter('wp_generate_attachment_metadata', 'convert_to_webp');

function convert_to_webp($metadata) {
    if (!isset($metadata['file'])) return $metadata;
    
    $upload_dir = wp_upload_dir();
    $file_path = $upload_dir['basedir'] . '/' . $metadata['file'];
    
    // Conversion WebP
    if (function_exists('imagewebp')) {
        $image = wp_get_image_editor($file_path);
        if (!is_wp_error($image)) {
            $webp_path = str_replace(array('.jpg', '.png'), '.webp', $file_path);
            $image->save($webp_path, 'image/webp');
        }
    }
    
    return $metadata;
}

// Lazy loading images optimisé
const imageObserver = new IntersectionObserver((entries, observer) => {
    entries.forEach(entry => {
        if (entry.isIntersecting) {
            const img = entry.target;
            
            // Preload de l'image
            const imageLoader = new Image();
            imageLoader.onload = () => {
                img.src = img.dataset.src;
                img.classList.add('loaded');
            };
            imageLoader.src = img.dataset.src;
            
            observer.unobserve(img);
        }
    });
}, {
    rootMargin: '50px 0px',
    threshold: 0.01
});

// Observer toutes les images lazy
document.querySelectorAll('img[data-src]').forEach(img => {
    imageObserver.observe(img);
});

<!-- Images produits responsive -->
<img src="product-300x300.jpg"
     srcset="product-150x150.jpg 150w,
             product-300x300.jpg 300w,
             product-600x600.jpg 600w,
             product-1024x1024.jpg 1024w"
     sizes="(max-width: 480px) 150px,
            (max-width: 768px) 300px,
            (max-width: 1024px) 600px,
            1024px"
     alt="Nom du produit">

// gulpfile.js pour WooCommerce
const gulp = require('gulp');
const concat = require('gulp-concat');
const uglify = require('gulp-uglify');
const cleanCSS = require('gulp-clean-css');

// CSS optimization
gulp.task('css', () => {
    return gulp.src([
        'assets/css/normalize.css',
        'assets/css/woocommerce.css',
        'assets/css/theme.css'
    ])
    .pipe(concat('bundle.min.css'))
    .pipe(cleanCSS({compatibility: 'ie8'}))
    .pipe(gulp.dest('dist/css/'));
});

// JavaScript optimization  
gulp.task('js', () => {
    return gulp.src([
        'assets/js/jquery.min.js',
        'assets/js/woocommerce.js',
        'assets/js/theme.js'
    ])
    .pipe(concat('bundle.min.js'))
    .pipe(uglify())
    .pipe(gulp.dest('dist/js/'));
});

// Critical CSS pour WooCommerce
function inline_critical_css() {
    if (is_front_page() || is_shop() || is_product()) {
        $critical_css = '
        .header{display:flex;justify-content:space-between;padding:1rem}
        .woocommerce-products-header{margin-bottom:2rem}
        .products{display:grid;grid-template-columns:repeat(auto-fit,minmax(280px,1fr));gap:2rem}
        .product{border:1px solid #ddd;border-radius:8px;overflow:hidden;transition:transform .2s}
        .product:hover{transform:translateY(-2px)}
        .woocommerce-loop-product__title{font-size:1.2rem;margin:.5rem 0}
        .price{font-size:1.1rem;font-weight:bold;color:#333}
        ';
        
        echo '<style id="critical-css">' . $critical_css . '</style>';
    }
}
add_action('wp_head', 'inline_critical_css', 1);

// Defer/async JavaScript loading
function optimize_script_loading($tag, $handle, $src) {
    // Scripts à déférer
    $defer_scripts = array('woocommerce', 'jquery-blockui', 'js-cookie');
    
    // Scripts à charger async
    $async_scripts = array('google-analytics', 'facebook-pixel');
    
    if (in_array($handle, $defer_scripts)) {
        return str_replace('<script ', '<script defer ', $tag);
    }
    
    if (in_array($handle, $async_scripts)) {
        return str_replace('<script ', '<script async ', $tag);
    }
    
    return $tag;
}
add_filter('script_loader_tag', 'optimize_script_loading', 10, 3);

// Plugin performance monitor
class Plugin_Performance_Monitor {
    private $start_time;
    private $plugin_times = array();
    
    public function __construct() {
        add_action('plugins_loaded', array($this, 'start_monitoring'));
        add_action('wp_footer', array($this, 'display_results'));
    }
    
    public function start_monitoring() {
        foreach (get_option('active_plugins') as $plugin) {
            $start = microtime(true);
            include_once(WP_PLUGIN_DIR . '/' . $plugin);
            $this->plugin_times[$plugin] = microtime(true) - $start;
        }
    }
    
    public function display_results() {
        if (current_user_can('administrator')) {
            arsort($this->plugin_times);
            echo '<!-- Plugin Load Times: ' . json_encode($this->plugin_times) . ' -->';
        }
    }
}
new Plugin_Performance_Monitor();

// Optimisation queries produits
function optimize_product_queries() {
    // Utiliser transients pour queries coûteuses
    $featured_products = get_transient('featured_products_cache');
    
    if (false === $featured_products) {
        $featured_products = wc_get_products(array(
            'featured' => true,
            'limit' => 12,
            'return' => 'ids'
        ));
        set_transient('featured_products_cache', $featured_products, HOUR_IN_SECONDS);
    }
    
    return $featured_products;
}

// Réduire auto-drafts WooCommerce
function limit_post_revisions() {
    add_filter('wp_revisions_to_keep', function($num, $post) {
        if ($post->post_type === 'product') {
            return 3; // Garder seulement 3 révisions
        }
        return $num;
    }, 10, 2);
}
add_action('init', 'limit_post_revisions');

// Cleanup WooCommerce automatique
function woocommerce_cleanup() {
    // Supprimer sessions expirées
    wc_delete_expired_transients();
    
    // Nettoyer logs anciens
    $log_files = glob(WC_LOG_DIR . '*.log');
    foreach ($log_files as $log_file) {
        if (filemtime($log_file) < time() - (30 * DAY_IN_SECONDS)) {
            unlink($log_file);
        }
    }
    
    // Optimiser tables
    global $wpdb;
    $tables = array(
        $wpdb->prefix . 'woocommerce_sessions',
        $wpdb->prefix . 'woocommerce_order_stats',
        $wpdb->prefix . 'wc_admin_notes'
    );
    
    foreach ($tables as $table) {
        $wpdb->query("OPTIMIZE TABLE {$table}");
    }
}

// Programmer cleanup hebdomadaire
if (!wp_next_scheduled('woocommerce_cleanup')) {
    wp_schedule_event(time(), 'weekly', 'woocommerce_cleanup');
}
add_action('woocommerce_cleanup', 'woocommerce_cleanup');

// Page Rules Cloudflare optimisées
const pageRules = [
    {
        url: "example.com/wp-content/uploads/*",
        settings: {
            cache_level: "cache_everything",
            edge_cache_ttl: 2592000, // 30 jours
            browser_cache_ttl: 31536000 // 1 an
        }
    },
    {
        url: "example.com/cart/*",
        settings: {
            cache_level: "bypass"
        }
    },
    {
        url: "example.com/checkout/*", 
        settings: {
            cache_level: "bypass",
            security_level: "high"
        }
    },
    {
        url: "example.com/my-account/*",
        settings: {
            cache_level: "bypass"
        }
    }
];

// Service d'optimisation images automatique
function cdn_optimized_images($attr, $attachment) {
    if (isset($attr['src'])) {
        $original_src = $attr['src'];
        
        // Paramètres optimisation selon context
        $params = '?auto=compress,format&fit=max&w=800&q=85';
        
        if (is_mobile()) {
            $params = '?auto=compress,format&fit=max&w=400&q=80';
        }
        
        // URL CDN optimisée
        $cdn_url = 'https://cdn.example.com/images/';
        $optimized_src = str_replace(
            wp_upload_dir()['baseurl'], 
            $cdn_url, 
            $original_src
        ) . $params;
        
        $attr['src'] = $optimized_src;
    }
    
    return $attr;
}
add_filter('wp_get_attachment_image_attributes', 'cdn_optimized_images', 10, 2);

// Preloading ressources critiques
function add_resource_hints() {
    if (is_front_page()) {
        echo '<link rel="preload" href="' . get_stylesheet_directory_uri() . '/css/critical.css" as="style">';
        echo '<link rel="prefetch" href="/shop/">';
    }
    
    if (is_shop() || is_product_category()) {
        echo '<link rel="preload" href="' . get_stylesheet_directory_uri() . '/css/woocommerce.css" as="style">';
        echo '<link rel="prefetch" href="/cart/">';
    }
    
    if (is_product()) {
        echo '<link rel="preload" href="' . get_stylesheet_directory_uri() . '/js/single-product.js" as="script">';
        echo '<link rel="prefetch" href="/checkout/">';
    }
}
add_action('wp_head', 'add_resource_hints', 1);

// sw.js - Service Worker WooCommerce
const CACHE_NAME = 'woocommerce-v1';
const urlsToCache = [
    '/',
    '/shop/',
    '/css/critical.css',
    '/js/bundle.min.js'
];

self.addEventListener('install', event => {
    event.waitUntil(
        caches.open(CACHE_NAME)
            .then(cache => cache.addAll(urlsToCache))
    );
});

self.addEventListener('fetch', event => {
    // Strategy: Network first for dynamic content, cache first for static
    if (event.request.url.includes('/cart/') || 
        event.request.url.includes('/checkout/') ||
        event.request.url.includes('/my-account/')) {
        // Network first pour pages dynamiques
        event.respondWith(
            fetch(event.request)
                .then(response => {
                    const responseClone = response.clone();
                    caches.open(CACHE_NAME)
                        .then(cache => cache.put(event.request, responseClone));
                    return response;
                })
                .catch(() => caches.match(event.request))
        );
    } else {
        // Cache first pour ressources statiques  
        event.respondWith(
            caches.match(event.request)
                .then(response => response || fetch(event.request))
        );
    }
});

/* Optimisations touch pour mobile */
.woocommerce .products .product {
    /* Touch targets 44px minimum */
    min-height: 44px;
    
    /* Faster touch response */
    touch-action: manipulation;
    
    /* Prevent tap delay */
    -webkit-tap-highlight-color: transparent;
}

.woocommerce .button {
    /* Touch-friendly buttons */
    min-height: 44px;
    min-width: 44px;
    padding: 12px 24px;
    
    /* Visual feedback */
    transition: background-color 0.1s ease;
}

.woocommerce .button:active {
    background-color: #0056b3;
    transform: translateY(1px);
}

/* Swipe gestures pour galeries */
.woocommerce-product-gallery {
    overflow-x: auto;
    scroll-behavior: smooth;
    -webkit-overflow-scrolling: touch;
}

#!/bin/bash
# performance-monitor.sh

SITE_URL="https://example.com"
ALERT_EMAIL="admin@example.com"
THRESHOLD=3 # seconds

# Test performance
LOAD_TIME=$(curl -o /dev/null -s -w '%{time_total}' $SITE_URL)

# Comparaison seuil
if (( $(echo "$LOAD_TIME > $THRESHOLD" | bc -l) )); then
    # Alert si trop lent
    echo "Site performance alert: ${LOAD_TIME}s load time" | mail -s "Performance Alert" $ALERT_EMAIL
    
    # Logs pour debug
    echo "$(date): Performance issue - ${LOAD_TIME}s" >> /var/log/performance.log
    
    # Actions automatiques
    # Purge cache
    wp cache flush --path=/var/www/example.com/
    
    # Restart services si nécessaire
    sudo systemctl restart nginx
    sudo systemctl restart php8.2-fpm
fi

// Test performance variants
class Performance_AB_Testing {
    public function __construct() {
        add_action('init', array($this, 'setup_variant'));
        add_action('wp_footer', array($this, 'track_performance'));
    }
    
    public function setup_variant() {
        $variant = isset($_COOKIE['perf_variant']) ? $_COOKIE['perf_variant'] : '';
        
        if (empty($variant)) {
            $variant = (rand(1, 2) == 1) ? 'A' : 'B';
            setcookie('perf_variant', $variant, time() + (30 * DAY_IN_SECONDS));
        }
        
        if ($variant == 'B') {
            // Variant B: Plus d'optimisations
            add_action('wp_enqueue_scripts', array($this, 'defer_non_critical_scripts'), 99);
        }
    }
    
    public function track_performance() {
        ?>
        <script>
        // Mesure performance et envoi analytics
        window.addEventListener('load', function() {
            const perfData = performance.getEntriesByType("navigation")[0];
            const loadTime = perfData.loadEventEnd - perfData.loadEventStart;
            
            // Send to analytics
            gtag('event', 'page_load_time', {
                'custom_parameter': loadTime,
                'variant': '<?php echo $_COOKIE["perf_variant"] ?? "A"; ?>'
            });
        });
        </script>
        <?php
    }
}
new Performance_AB_Testing();

# Nginx avec HTTP/3
server {
    listen 443 ssl http2;
    listen 443 http3 reuseport;
    
    ssl_protocols TLSv1.3;
    ssl_ciphers EECDH+AESGCM:EDH+AESGCM;
    
    # HTTP/3 headers
    add_header Alt-Svc 'h3=":443"; ma=86400, h3-29=":443"; ma=86400';
    
    location / {
        # QUIC optimizations
        proxy_set_header Connection "";
        proxy_http_version 1.1;
    }
}

// worker.js - Edge caching pour WooCommerce
addEventListener('fetch', event => {
    event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
    const url = new URL(request.url);
    const cache = caches.default;
    
    // Bypass cache pour pages dynamiques
    if (url.pathname.includes('/cart/') || 
        url.pathname.includes('/checkout/') ||
        url.pathname.includes('/my-account/')) {
        return fetch(request);
    }
    
    // Cache statique agressif
    let response = await cache.match(request);
    
    if (!response) {
        response = await fetch(request);
        
        // Cache selon type de contenu
        if (response.status === 200) {
            const newResponse = new Response(response.body, response);
            
            if (url.pathname.includes('/product/')) {
                newResponse.headers.set('Cache-Control', 'max-age=3600'); // 1h
            } else if (url.pathname === '/' || url.pathname === '/shop/') {
                newResponse.headers.set('Cache-Control', 'max-age=1800'); // 30min
            }
            
            event.waitUntil(cache.put(request, newResponse.clone()));
            return newResponse;
        }
    }
    
    return response;
}

// ML-powered preloading
class PredictivePreloader {
    constructor() {
        this.model = null;
        this.loadModel();
        this.setupObservers();
    }
    
    async loadModel() {
        // Charger modèle TensorFlow.js pré-entraîné
        this.model = await tf.loadLayersModel('/models/user-behavior-model.json');
    }
    
    setupObservers() {
        // Observer comportement utilisateur
        const observer = new IntersectionObserver(entries => {
            entries.forEach(entry => {
                if (entry.isIntersecting) {
                    this.predictNextPage(entry.target);
                }
            });
        });
        
        document.querySelectorAll('.product').forEach(product => {
            observer.observe(product);
        });
    }
    
    async predictNextPage(element) {
        if (!this.model) return;
        
        const features = this.extractFeatures(element);
        const prediction = await this.model.predict(features).data();
        
        // Preload si probabilité > 70%
        if (prediction[0] > 0.7) {
            const productUrl = element.querySelector('a').href;
            this.preloadPage(productUrl);
        }
    }
    
    extractFeatures(element) {
        // Extraction features pour ML
        const rect = element.getBoundingClientRect();
        const features = [
            rect.top / window.innerHeight, // Position viewport
            element.dataset.price || 0, // Prix produit
            Date.now() % 86400000, // Heure de la journée
            window.pageYOffset / document.body.scrollHeight // Scroll progress
        ];
        
        return tf.tensor2d([features]);
    }
    
    preloadPage(url) {
        const link = document.createElement('link');
        link.rel = 'prefetch';
        link.href = url;
        document.head.appendChild(link);
    }
}

new PredictivePreloader();