Option 1 : SQLite (recommandé pour démarrer, sans serveur externe)
Backend complet (server.js)

const express = require('express');
const cors = require('cors');
const sqlite3 = require('sqlite3').verbose();
const { open } = require('sqlite');
const bcrypt = require('bcrypt');
const jwt = require('jsonwebtoken');

const app = express();
const PORT = 3000;
const SECRET_KEY = 'votre_cle_secrete_tres_longue_et_complexe_2025';

app.use(cors());
app.use(express.json());

// Initialisation de la base de données SQLite
let db;

async function initDatabase() {
    db = await open({
        filename: './dream_journal.db',
        driver: sqlite3.Database
    });

    // Table des utilisateurs
    await db.exec(`
        CREATE TABLE IF NOT EXISTS users (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            username TEXT UNIQUE NOT NULL,
            password_hash TEXT NOT NULL,
            created_at DATETIME DEFAULT CURRENT_TIMESTAMP
        )
    `);

    // Table des rêves
    await db.exec(`
        CREATE TABLE IF NOT EXISTS dreams (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            user_id INTEGER NOT NULL,
            date_time DATETIME NOT NULL,
            title TEXT,
            story TEXT NOT NULL,
            emotions TEXT,
            symbols TEXT,
            interpretation TEXT,
            prayer_action TEXT,
            followup TEXT,
            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
            FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
        )
    `);

    // Index pour optimiser les recherches
    await db.exec(`
        CREATE INDEX IF NOT EXISTS idx_dreams_user_date ON dreams(user_id, date_time);
        CREATE INDEX IF NOT EXISTS idx_dreams_user_title ON dreams(user_id, title);
    `);

    console.log("✅ Base de données SQLite initialisée");
}

// ============ ROUTES AUTH ============

// Inscription
app.post('/api/register', async (req, res) => {
    try {
        const { username, password } = req.body;
        if (!username || !password) {
            return res.status(400).json({ error: "Nom d'utilisateur et mot de passe requis" });
        }

        const existingUser = await db.get('SELECT id FROM users WHERE username = ?', [username]);
        if (existingUser) {
            return res.status(400).json({ error: "Cet utilisateur existe déjà" });
        }

        const passwordHash = await bcrypt.hash(password, 10);
        const result = await db.run(
            'INSERT INTO users (username, password_hash) VALUES (?, ?)',
            [username, passwordHash]
        );

        const token = jwt.sign({ userId: result.lastID, username }, SECRET_KEY, { expiresIn: '30d' });
        res.json({ token, username, userId: result.lastID });
    } catch (error) {
        console.error(error);
        res.status(500).json({ error: "Erreur serveur" });
    }
});

// Connexion
app.post('/api/login', async (req, res) => {
    try {
        const { username, password } = req.body;
        const user = await db.get('SELECT * FROM users WHERE username = ?', [username]);
        
        if (!user) {
            return res.status(401).json({ error: "Identifiants incorrects" });
        }

        const validPassword = await bcrypt.compare(password, user.password_hash);
        if (!validPassword) {
            return res.status(401).json({ error: "Identifiants incorrects" });
        }

        const token = jwt.sign({ userId: user.id, username }, SECRET_KEY, { expiresIn: '30d' });
        res.json({ token, username, userId: user.id });
    } catch (error) {
        res.status(500).json({ error: "Erreur serveur" });
    }
});

// Middleware d'authentification
function authenticateToken(req, res, next) {
    const authHeader = req.headers['authorization'];
    const token = authHeader && authHeader.split(' ')[1];
    
    if (!token) {
        return res.status(401).json({ error: "Token manquant" });
    }

    jwt.verify(token, SECRET_KEY, (err, user) => {
        if (err) return res.status(403).json({ error: "Token invalide" });
        req.user = user;
        next();
    });
}

// ============ ROUTES DREAMS ============

// Récupérer tous les rêves d'un utilisateur
app.get('/api/dreams', authenticateToken, async (req, res) => {
    try {
        const dreams = await db.all(
            `SELECT * FROM dreams WHERE user_id = ? ORDER BY date_time DESC`,
            [req.user.userId]
        );
        res.json(dreams);
    } catch (error) {
        res.status(500).json({ error: "Erreur lors de la récupération" });
    }
});

// Récupérer les 5 derniers rêves
app.get('/api/dreams/recent', authenticateToken, async (req, res) => {
    try {
        const dreams = await db.all(
            `SELECT * FROM dreams WHERE user_id = ? ORDER BY date_time DESC LIMIT 5`,
            [req.user.userId]
        );
        res.json(dreams);
    } catch (error) {
        res.status(500).json({ error: "Erreur lors de la récupération" });
    }
});

// Récupérer un rêve par ID
app.get('/api/dreams/:id', authenticateToken, async (req, res) => {
    try {
        const dream = await db.get(
            `SELECT * FROM dreams WHERE id = ? AND user_id = ?`,
            [req.params.id, req.user.userId]
        );
        if (!dream) {
            return res.status(404).json({ error: "Rêve non trouvé" });
        }
        res.json(dream);
    } catch (error) {
        res.status(500).json({ error: "Erreur lors de la récupération" });
    }
});

// Créer un nouveau rêve
app.post('/api/dreams', authenticateToken, async (req, res) => {
    try {
        const { dateTime, title, story, emotions, symbols, interpretation, prayerAction, followup } = req.body;
        
        if (!dateTime || !story) {
            return res.status(400).json({ error: "Date et récit sont obligatoires" });
        }

        const result = await db.run(
            `INSERT INTO dreams (user_id, date_time, title, story, emotions, symbols, interpretation, prayer_action, followup)
             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
            [req.user.userId, dateTime, title || "", story, emotions || "", symbols || "", interpretation || "", prayerAction || "", followup || ""]
        );

        const newDream = await db.get('SELECT * FROM dreams WHERE id = ?', [result.lastID]);
        res.json(newDream);
    } catch (error) {
        console.error(error);
        res.status(500).json({ error: "Erreur lors de la création" });
    }
});

// Mettre à jour un rêve
app.put('/api/dreams/:id', authenticateToken, async (req, res) => {
    try {
        const { dateTime, title, story, emotions, symbols, interpretation, prayerAction, followup } = req.body;
        
        const dream = await db.get(
            'SELECT * FROM dreams WHERE id = ? AND user_id = ?',
            [req.params.id, req.user.userId]
        );
        
        if (!dream) {
            return res.status(404).json({ error: "Rêve non trouvé" });
        }

        await db.run(
            `UPDATE dreams SET 
                date_time = ?, title = ?, story = ?, emotions = ?, 
                symbols = ?, interpretation = ?, prayer_action = ?, 
                followup = ?, updated_at = CURRENT_TIMESTAMP
             WHERE id = ?`,
            [dateTime, title || "", story, emotions || "", symbols || "", 
             interpretation || "", prayerAction || "", followup || "", req.params.id]
        );

        const updatedDream = await db.get('SELECT * FROM dreams WHERE id = ?', [req.params.id]);
        res.json(updatedDream);
    } catch (error) {
        res.status(500).json({ error: "Erreur lors de la mise à jour" });
    }
});

// Supprimer un rêve
app.delete('/api/dreams/:id', authenticateToken, async (req, res) => {
    try {
        const result = await db.run(
            'DELETE FROM dreams WHERE id = ? AND user_id = ?',
            [req.params.id, req.user.userId]
        );
        
        if (result.changes === 0) {
            return res.status(404).json({ error: "Rêve non trouvé" });
        }
        
        res.json({ success: true, message: "Rêve supprimé" });
    } catch (error) {
        res.status(500).json({ error: "Erreur lors de la suppression" });
    }
});

// Rechercher des rêves
app.post('/api/dreams/search', authenticateToken, async (req, res) => {
    try {
        const { keyword, date } = req.body;
        let query = `SELECT * FROM dreams WHERE user_id = ?`;
        let params = [req.user.userId];
        
        if (keyword && keyword.trim()) {
            query += ` AND (title LIKE ? OR story LIKE ? OR symbols LIKE ? OR emotions LIKE ? OR interpretation LIKE ?)`;
            const searchTerm = `%${keyword.trim()}%`;
            params.push(searchTerm, searchTerm, searchTerm, searchTerm, searchTerm);
        }
        
        if (date && date.trim()) {
            query += ` AND date_time LIKE ?`;
            params.push(`%${date.trim()}%`);
        }
        
        query += ` ORDER BY date_time DESC`;
        
        const dreams = await db.all(query, params);
        res.json(dreams);
    } catch (error) {
        res.status(500).json({ error: "Erreur lors de la recherche" });
    }
});

// Statistiques utilisateur
app.get('/api/stats', authenticateToken, async (req, res) => {
    try {
        const total = await db.get(
            'SELECT COUNT(*) as total FROM dreams WHERE user_id = ?',
            [req.user.userId]
        );
        const lastMonth = await db.get(
            `SELECT COUNT(*) as count FROM dreams WHERE user_id = ? 
             AND date_time >= datetime('now', '-30 days')`,
            [req.user.userId]
        );
        const commonSymbols = await db.all(
            `SELECT symbols, COUNT(*) as count FROM dreams 
             WHERE user_id = ? AND symbols IS NOT NULL AND symbols != ''
             GROUP BY symbols ORDER BY count DESC LIMIT 5`,
            [req.user.userId]
        );
        
        res.json({ total: total.total, lastMonth: lastMonth.count, commonSymbols });
    } catch (error) {
        res.status(500).json({ error: "Erreur" });
    }
});

// Démarrer le serveur
async function start() {
    await initDatabase();
    app.listen(PORT, () => {
        console.log(`🚀 Serveur démarré sur http://localhost:${PORT}`);
    });
}

start();


Installation du backend

# Créer un dossier pour le backend
mkdir dream-journal-backend
cd dream-journal-backend

# Initialiser le projet
npm init -y

# Installer les dépendances
npm install express cors sqlite sqlite3 bcrypt jsonwebtoken
npm install -D nodemon

# Créer le fichier server.js et y coller le code ci-dessus

# Démarrer le serveur
node server.js
# ou avec nodemon pour le développement
npx nodemon server.js


Frontend adapté pour SQL (version simplifiée avec API)

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Journal de mes rêves - Version SQL</title>
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        body { font-family: system-ui, -apple-system, 'Segoe UI', sans-serif; background: #0f0e12; color: #e8e2d4; }
        .container { max-width: 1200px; margin: 0 auto; padding: 2rem; }
        .card { background: rgba(20, 18, 26, 0.9); border-radius: 24px; padding: 1.5rem; margin-bottom: 1.5rem; }
        .auth-form { display: flex; gap: 1rem; flex-wrap: wrap; }
        input, textarea { background: #1e1b24; border: 1px solid #3b3542; border-radius: 12px; padding: 0.7rem; color: white; }
        button { background: #cdbc91; border: none; border-radius: 30px; padding: 0.5rem 1.2rem; cursor: pointer; font-weight: 600; }
        .dream-item { background: rgba(0,0,0,0.3); border-radius: 16px; padding: 1rem; margin-bottom: 1rem; }
        .hidden { display: none; }
        .error { color: #e68a8a; }
        .success { color: #8bc34a; }
        .tabs { display: flex; gap: 0.5rem; margin-bottom: 1rem; flex-wrap: wrap; }
        .tab-btn { background: transparent; color: #ddd0bc; padding: 0.5rem 1rem; }
        .tab-btn.active { background: #dccfad; color: #1e1b24; }
        .tab-content { display: none; }
        .tab-content.active { display: block; }
    </style>
</head>
<body>
<div class="container">
    <h1>📖 Journal de mes rêves</h1>
    
    <!-- Formulaire d'auth -->
    <div id="authPanel" class="card">
        <h2>Connexion / Inscription</h2>
        <div class="auth-form">
            <input type="text" id="username" placeholder="Nom d'utilisateur">
            <input type="password" id="password" placeholder="Mot de passe">
            <button id="loginBtn">Se connecter</button>
            <button id="registerBtn">S'inscrire</button>
        </div>
        <div id="authMessage"></div>
    </div>

    <!-- Interface principale (cachée au départ) -->
    <div id="mainApp" class="hidden">
        <div class="tabs">
            <button class="tab-btn active" data-tab="home">🏠 Accueil</button>
            <button class="tab-btn" data-tab="new">✍️ Nouveau rêve</button>
            <button class="tab-btn" data-tab="archive">📚 Archives</button>
            <button class="tab-btn" data-tab="stats">📊 Statistiques</button>
        </div>

        <div id="home" class="tab-content active">
            <div class="card">
                <h2>✨ Derniers rêves</h2>
                <div id="recentDreams"></div>
            </div>
        </div>

        <div id="new" class="tab-content">
            <div class="card">
                <h2>✍️ Enregistrer un rêve</h2>
                <form id="dreamForm">
                    <input type="hidden" id="dreamId">
                    <div style="margin-bottom: 1rem;">
                        <label>📅 Date et heure</label>
                        <input type="datetime-local" id="dateTime" required style="width:100%">
                    </div>
                    <div style="margin-bottom: 1rem;">
                        <label>🏷️ Titre</label>
                        <input type="text" id="title" style="width:100%">
                    </div>
                    <div style="margin-bottom: 1rem;">
                        <label>📜 Récit *</label>
                        <textarea id="story" rows="4" required style="width:100%"></textarea>
                    </div>
                    <div style="margin-bottom: 1rem;">
                        <label>💭 Émotions</label>
                        <input type="text" id="emotions" style="width:100%">
                    </div>
                    <div style="margin-bottom: 1rem;">
                        <label>🔁 Symboles</label>
                        <input type="text" id="symbols" style="width:100%">
                    </div>
                    <div style="margin-bottom: 1rem;">
                        <label>🕯️ Interprétation</label>
                        <textarea id="interpretation" rows="2" style="width:100%"></textarea>
                    </div>
                    <div style="margin-bottom: 1rem;">
                        <label>🙏 Action de prière</label>
                        <textarea id="prayerAction" rows="2" style="width:100%"></textarea>
                    </div>
                    <div style="margin-bottom: 1rem;">
                        <label>✅ Suivi</label>
                        <textarea id="followup" rows="2" style="width:100%"></textarea>
                    </div>
                    <button type="submit">💾 Enregistrer</button>
                    <button type="button" id="cancelEdit" class="hidden">Annuler modification</button>
                </form>
            </div>
        </div>

        <div id="archive" class="tab-content">
            <div class="card">
                <h2>🔍 Rechercher</h2>
                <div style="display: flex; gap: 1rem; flex-wrap: wrap;">
                    <input type="text" id="searchKeyword" placeholder="Mot-clé...">
                    <input type="text" id="searchDate" placeholder="Date (YYYY-MM)">
                    <button id="searchBtn">Rechercher</button>
                    <button id="resetSearch">Réinitialiser</button>
                </div>
            </div>
            <div class="card">
                <h2>📋 Tous mes rêves</h2>
                <div id="allDreams"></div>
            </div>
        </div>

        <div id="stats" class="tab-content">
            <div class="card">
                <h2>📊 Statistiques</h2>
                <div id="statsContent"></div>
            </div>
        </div>
    </div>
</div>

<script>
    const API_URL = 'http://localhost:3000/api';
    let token = null;
    let currentUser = null;

    // Helper
    function showMessage(element, msg, isError = true) {
        const el = document.getElementById(element);
        if (el) {
            el.innerHTML = `<div class="${isError ? 'error' : 'success'}">${msg}</div>`;
            setTimeout(() => el.innerHTML = '', 3000);
        }
    }

    // Appels API
    async function apiCall(endpoint, method, data = null) {
        const headers = { 'Content-Type': 'application/json' };
        if (token) headers['Authorization'] = `Bearer ${token}`;
        
        const response = await fetch(`${API_URL}${endpoint}`, {
            method,
            headers,
            body: data ? JSON.stringify(data) : null
        });
        
        if (!response.ok) {
            const error = await response.json();
            throw new Error(error.error || "Erreur serveur");
        }
        return response.json();
    }

    // Charger les rêves récents
    async function loadRecentDreams() {
        try {
            const dreams = await apiCall('/dreams/recent', 'GET');
            const container = document.getElementById('recentDreams');
            if (!dreams.length) {
                container.innerHTML = '<p>Aucun rêve pour le moment</p>';
                return;
            }
            container.innerHTML = dreams.map(d => `
                <div class="dream-item">
                    <strong>${d.title || 'Sans titre'}</strong><br>
                    <small>${d.date_time.replace('T', ' ')}</small>
                    <p>${d.story.substring(0, 150)}${d.story.length > 150 ? '…' : ''}</p>
                    <button onclick="editDream(${d.id})">✏️ Modifier</button>
                    <button onclick="deleteDream(${d.id})">🗑️ Supprimer</button>
                </div>
            `).join('');
        } catch (error) {
            console.error(error);
        }
    }

    // Charger tous les rêves (archives)
    async function loadAllDreams(keyword = '', date = '') {
        try {
            let dreams;
            if (keyword || date) {
                dreams = await apiCall('/dreams/search', 'POST', { keyword, date });
            } else {
                dreams = await apiCall('/dreams', 'GET');
            }
            const container = document.getElementById('allDreams');
            if (!dreams.length) {
                container.innerHTML = '<p>Aucun rêve trouvé</p>';
                return;
            }
            container.innerHTML = dreams.map(d => `
                <div class="dream-item">
                    <strong>Rêve #${d.id}</strong> - ${d.title || 'Sans titre'}<br>
                    <small>${d.date_time.replace('T', ' ')}</small>
                    <p><strong>Récit:</strong> ${d.story.substring(0, 100)}…</p>
                    <p><strong>Symboles:</strong> ${d.symbols || '-'}</p>
                    <button onclick="editDream(${d.id})">✏️ Modifier</button>
                    <button onclick="deleteDream(${d.id})">🗑️ Supprimer</button>
                </div>
            `).join('');
        } catch (error) {
            console.error(error);
        }
    }

    // Charger les stats
    async function loadStats() {
        try {
            const stats = await apiCall('/stats', 'GET');
            document.getElementById('statsContent').innerHTML = `
                <p>📊 Total des rêves: <strong>${stats.total}</strong></p>
                <p>📅 Rêves des 30 derniers jours: <strong>${stats.lastMonth}</strong></p>
                <p>🔁 Symboles les plus fréquents:</p>
                <ul>${stats.commonSymbols.map(s => `<li>${s.symbols || 'Non spécifié'}: ${s.count}</li>`).join('') || '<li>Aucun symbole enregistré</li>'}</ul>
            `;
        } catch (error) {
            console.error(error);
        }
    }

    // Créer ou modifier un rêve
    async function saveDream(dreamData, isEdit = false, dreamId = null) {
        try {
            if (isEdit && dreamId) {
                await apiCall(`/dreams/${dreamId}`, 'PUT', dreamData);
                showMessage('authMessage', '✅ Rêve modifié avec succès', false);
            } else {
                await apiCall('/dreams', 'POST', dreamData);
                showMessage('authMessage', '✅ Rêve enregistré', false);
            }
            document.getElementById('dreamForm').reset();
            document.getElementById('cancelEdit').classList.add('hidden');
            document.getElementById('dreamId').value = '';
            
            // Recharger les affichages
            loadRecentDreams();
            loadAllDreams();
        } catch (error) {
            showMessage('authMessage', error.message);
        }
    }

    // Éditer un rêve
    window.editDream = async function(id) {
        try {
            const dream = await apiCall(`/dreams/${id}`, 'GET');
            document.getElementById('dreamId').value = dream.id;
            document.getElementById('dateTime').value = dream.date_time;
            document.getElementById('title').value = dream.title || '';
            document.getElementById('story').value = dream.story;
            document.getElementById('emotions').value = dream.emotions || '';
            document.getElementById('symbols').value = dream.symbols || '';
            document.getElementById('interpretation').value = dream.interpretation || '';
            document.getElementById('prayerAction').value = dream.prayer_action || '';
            document.getElementById('followup').value = dream.followup || '';
            document.getElementById('cancelEdit').classList.remove('hidden');
            
            // Basculer vers l'onglet nouveau
            document.querySelector('.tab-btn[data-tab="new"]').click();
        } catch (error) {
            showMessage('authMessage', error.message);
        }
    };

    // Supprimer un rêve
    window.deleteDream = async function(id) {
        if (!confirm('Supprimer définitivement ce rêve ?')) return;
        try {
            await apiCall(`/dreams/${id}`, 'DELETE');
            showMessage('authMessage', '✅ Rêve supprimé', false);
            loadRecentDreams();
            loadAllDreams();
            loadStats();
        } catch (error) {
            showMessage('authMessage', error.message);
        }
    };

    // Initialisation des onglets
    function initTabs() {
        const tabs = document.querySelectorAll('.tab-btn');
        const contents = document.querySelectorAll('.tab-content');
        
        tabs.forEach(btn => {
            btn.addEventListener('click', () => {
                const tabId = btn.getAttribute('data-tab');
                contents.forEach(c => c.classList.remove('active'));
                document.getElementById(tabId).classList.add('active');
                tabs.forEach(b => b.classList.remove('active'));
                btn.classList.add('active');
                
                // Charger les données selon l'onglet
                if (tabId === 'home') loadRecentDreams();
                if (tabId === 'archive') loadAllDreams();
                if (tabId === 'stats') loadStats();
            });
        });
    }

    // Formulaire de rêve
    function initDreamForm() {
        const form = document.getElementById('dreamForm');
        form.addEventListener('submit', async (e) => {
            e.preventDefault();
            const dreamId = document.getElementById('dreamId').value;
            const dreamData = {
                dateTime: document.getElementById('dateTime').value,
                title: document.getElementById('title').value,
                story: document.getElementById('story').value,
                emotions: document.getElementById('emotions').value,
                symbols: document.getElementById('symbols').value,
                interpretation: document.getElementById('interpretation').value,
                prayerAction: document.getElementById('prayerAction').value,
                followup: document.getElementById('followup').value
            };
            
            if (dreamId) {
                await saveDream(dreamData, true, dreamId);
            } else {
                await saveDream(dreamData);
            }
            
            // Réinitialiser le formulaire
            if (!dreamId) form.reset();
        });
        
        document.getElementById('cancelEdit').addEventListener('click', () => {
            document.getElementById('dreamForm').reset();
            document.getElementById('dreamId').value = '';
            document.getElementById('cancelEdit').classList.add('hidden');
        });
    }

    // Recherche
    function initSearch() {
        document.getElementById('searchBtn').addEventListener('click', () => {
            const keyword = document.getElementById('searchKeyword').value;
            const date = document.getElementById('searchDate').value;
            loadAllDreams(keyword, date);
        });
        document.getElementById('resetSearch').addEventListener('click', () => {
            document.getElementById('searchKeyword').value = '';
            document.getElementById('searchDate').value = '';
            loadAllDreams();
        });
    }

    // Authentification
    async function login(username, password) {
        try {
            const response = await fetch(`${API_URL}/login`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ username, password })
            });
            if (!response.ok) throw new Error('Identifiants incorrects');
            const data = await response.json();
            token = data.token;
            currentUser = data.username;
            localStorage.setItem('dream_token', token);
            localStorage.setItem('dream_user', currentUser);
            document.getElementById('authPanel').classList.add('hidden');
            document.getElementById('mainApp').classList.remove('hidden');
            document.getElementById('authMessage').innerHTML = `<div class="success">Bienvenue ${currentUser} !</div>`;
            loadRecentDreams();
        } catch (error) {
            showMessage('authMessage', error.message);
        }
    }

    async function register(username, password) {
        try {
            const response = await fetch(`${API_URL}/register`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ username, password })
            });
            if (!response.ok) {
                const error = await response.json();
                throw new Error(error.error);
            }
            const data = await response.json();
            token = data.token;
            currentUser = data.username;
            localStorage.setItem('dream_token', token);
            localStorage.setItem('dream_user', currentUser);
            document.getElementById('authPanel').classList.add('hidden');
            document.getElementById('mainApp').classList.remove('hidden');
            showMessage('authMessage', `Bienvenue ${currentUser} !`, false);
        } catch (error) {
            showMessage('authMessage', error.message);
        }
    }

    function logout() {
        token = null;
        currentUser = null;
        localStorage.removeItem('dream_token');
        localStorage.removeItem('dream_user');
        document.getElementById('authPanel').classList.remove('hidden');
        document.getElementById('mainApp').classList.add('hidden');
    }

    // Vérifier session existante
    async function checkSession() {
        const savedToken = localStorage.getItem('dream_token');
        const savedUser = localStorage.getItem('dream_user');
        if (savedToken && savedUser) {
            token = savedToken;
            currentUser = savedUser;
            try {
                await apiCall('/dreams/recent', 'GET');
                document.getElementById('authPanel').classList.add('hidden');
                document.getElementById('mainApp').classList.remove('hidden');
                loadRecentDreams();
                return true;
            } catch (error) {
                logout();
                return false;
            }
        }
        return false;
    }

    // Initialisation
    async function init() {
        initTabs();
        initDreamForm();
        initSearch();
        
        document.getElementById('loginBtn').addEventListener('click', () => {
            const username = document.getElementById('username').value;
            const password = document.getElementById('password').value;
            if (username && password) login(username, password);
            else showMessage('authMessage', 'Veuillez remplir tous les champs');
        });
        
        document.getElementById('registerBtn').addEventListener('click', () => {
            const username = document.getElementById('username').value;
            const password = document.getElementById('password').value;
            if (username && password && password.length >= 4) register(username, password);
            else showMessage('authMessage', 'Mot de passe (min 4 caractères)');
        });
        
        await checkSession();
        
        // Date par défaut
        const now = new Date();
        now.setMinutes(now.getMinutes() - now.getTimezoneOffset());
        document.getElementById('dateTime').value = now.toISOString().slice(0, 16);
    }
    
    init();
</script>
</body>
</html>