chore: Version auf v0.1.6.2 erhöht

- HelpTooltip-Komponente verwendet jetzt ℹ statt ?
- Help-Button im Header verwendet jetzt ℹ statt ❓
- Konsistenteres Design mit Informations-Icon

README.md

@@ -15,6 +15,7 @@ Eine Web-App inspiriert von Heardle, bei der Nutzer täglich einen Song anhand k
     - Bearbeitung von Metadaten.
     - Sortierbare Song-Bibliothek (Titel, Interpret, Hinzugefügt am, Erscheinungsjahr, Aktivierungen, Rating).
     - Play/Pause-Funktion zum Vorhören in der Bibliothek.
+    - **Kuratoren-Verwaltung:** Erstellen und Verwalten von Kurator-Accounts mit Zuweisung zu Genres und Specials.
 - **Cover Art:**
     - Automatische Extraktion von Cover-Bildern aus MP3-Dateien.
     - Anzeige des Covers nach Spielende (Sieg/Niederlage).
@@ -42,7 +43,6 @@ Eine Web-App inspiriert von Heardle, bei der Nutzer täglich einen Song anhand k
     - Live-Vorschau beim Hovern über die Waveform.
     - Playback-Cursor zeigt aktuelle Abspielposition.
     - Einzelne Segmente zum Testen abspielen.
-    - Einzelne Segmente zum Testen abspielen.
     - Manuelle Speicherung mit visueller Bestätigung.
 - **News & Announcements:**
     - Integriertes News-System für Ankündigungen (z.B. neue Specials, Features).
@@ -51,6 +51,25 @@ Eine Web-App inspiriert von Heardle, bei der Nutzer täglich einen Song anhand k
     - **Featured News:** Hervorhebung wichtiger Ankündigungen.
     - Special-Verknüpfung: Direkte Links zu Specials in News-Beiträgen.
     - Verwaltung über das Admin-Dashboard.
+- **Kurator-System:**
+    - **Kurator-Accounts:** Separate Login-Accounts für Kuratoren (nicht Admins).
+    - **Genre- & Special-Zuweisung:** Kuratoren können einzelnen Genres oder Specials zugewiesen werden.
+    - **Global-Kuratoren:** Optionale globale Kuratoren, die für alle Rätsel zuständig sind.
+    - **Kurator-Dashboard:** Eigene Dashboard-Seite (`/curator` oder `/de/curator`, `/en/curator`) für Kuratoren.
+    - **Song-Verwaltung:** Kuratoren können Songs hochladen, bearbeiten und Genres/Specials zuweisen.
+    - **Batch-Edit:** Mehrere Titel gleichzeitig bearbeiten (Genre/Special Toggle, Artist ändern, Exclude Global Flag setzen).
+    - **Kommentar-Verwaltung:** Kuratoren können Spieler-Kommentare zu ihren Rätseln einsehen, als gelesen markieren und archivieren.
+- **Spieler-Kommentare:**
+    - **Feedback an Kuratoren:** Spieler können nach Abschluss eines Rätsels optional eine Nachricht an die Kuratoren senden.
+    - **Automatische Zuordnung:** Kommentare werden automatisch an relevante Kuratoren verteilt (Genre-Kuratoren, Special-Kuratoren, Global-Kuratoren).
+    - **Rate-Limiting:** Pro Spieler nur ein Kommentar pro Puzzle möglich.
+    - **Kontext-Informationen:** Kommentare enthalten vollständigen Rätsel-Kontext (Hördle #, Genre/Special, Titel/Artist).
+    - **Kommentar-Verwaltung:** Kuratoren sehen Kommentare in ihrem Dashboard mit Badge für neue/ungelesene Nachrichten.
+- **Analytics:**
+    - **Plausible Analytics:** Integration mit Plausible Analytics für anonyme Nutzungsstatistiken.
+    - **Automatisches Domain-Tracking:** Unterstützt mehrere Domains mit automatischer Erkennung.
+    - **Privacy-First:** Keine Cookies, kein Cross-Site-Tracking.
+    - 👉 **[Plausible Setup-Dokumentation](docs/PLAUSIBLE_SETUP.md)**
 
 ## Internationalisierung (i18n)
 
@@ -139,6 +158,7 @@ Das Projekt ist für den Betrieb mit Docker optimiert.
    - `GOTIFY_URL`: URL deines Gotify Servers (z.B. `https://gotify.example.com`)
    - `GOTIFY_APP_TOKEN`: App Token für Gotify (z.B. `A...`)
    - `OPENROUTER_API_KEY`: API-Key für OpenRouter (für KI-Kategorisierung, optional)
+   - `NEXT_PUBLIC_PLAUSIBLE_SCRIPT_SRC`: URL zum Plausible Analytics Script (z.B. `https://plausible.example.com/js/script.js`, optional)
 
 2. **Starten:**
    ```bash
@@ -156,7 +176,18 @@ Das Projekt ist für den Betrieb mit Docker optimiert.
    - URL: `/de/admin` oder `/en/admin`
    - Standard-Passwort: `admin123` (Bitte in `docker-compose.yml` ändern! Muss als Hash hinterlegt werden.)
 
-5. **Special Curation & Scheduling verwenden:**
+5. **Kurator-Zugang:**
+   - URL: `/de/curator` oder `/en/curator`
+   - Kurator-Accounts werden vom Admin erstellt und verwaltet.
+   - Kuratoren können Songs hochladen und verwalten, sowie Kommentare von Spielern einsehen.
+   - **Batch-Edit-Funktionalität:** 
+     - Mehrere Titel über Checkboxen auswählen
+     - Genre/Special Toggle (hinzufügen/entfernen)
+     - Artist-Änderung für alle ausgewählten Titel
+     - Exclude Global Flag setzen/entfernen (nur für Global-Kuratoren)
+     - Toolbar erscheint automatisch bei Auswahl von Titeln
+
+6. **Special Curation & Scheduling verwenden:**
    - Erstelle ein Special im Admin-Dashboard:
      - Gib Name, Max Attempts und Unlock Steps ein.
      - **Optional:** Setze ein Startdatum (Launch Date) und Enddatum.

app/[locale]/curator/help/page.tsx

@@ -0,0 +1,8 @@
+'use client';
+
+import CuratorHelpInner from '../../../curator/help/page';
+
+export default function CuratorHelpPage() {
+    return <CuratorHelpInner />;
+}
+

app/api/songs/batch/route.ts

@@ -0,0 +1,266 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { PrismaClient } from '@prisma/client';
+import { requireStaffAuth, StaffContext } from '@/lib/auth';
+
+const prisma = new PrismaClient();
+
+async function getCuratorAssignments(curatorId: number) {
+    const [genres, specials] = await Promise.all([
+        prisma.curatorGenre.findMany({
+            where: { curatorId },
+            select: { genreId: true },
+        }),
+        prisma.curatorSpecial.findMany({
+            where: { curatorId },
+            select: { specialId: true },
+        }),
+    ]);
+
+    return {
+        genreIds: new Set(genres.map(g => g.genreId)),
+        specialIds: new Set(specials.map(s => s.specialId)),
+    };
+}
+
+function curatorCanEditSong(context: StaffContext, song: any, assignments: { genreIds: Set<number>; specialIds: Set<number> }) {
+    if (context.role === 'admin') return true;
+
+    const songGenreIds = (song.genres || []).map((g: any) => g.id);
+    const songSpecialIds = (song.specials || [])
+        .map((s: any) => {
+            if (s?.specialId != null) return s.specialId;
+            if (s?.special?.id != null) return s.special.id;
+            if (s?.id != null && s?.specialId == null && s?.special == null) return s.id;
+            return undefined;
+        })
+        .filter((id: any): id is number => typeof id === 'number');
+
+    if (songGenreIds.length === 0 && songSpecialIds.length === 0) {
+        return true;
+    }
+
+    const hasGenre = songGenreIds.some((id: number) => assignments.genreIds.has(id));
+    const hasSpecial = songSpecialIds.some((id: number) => assignments.specialIds.has(id));
+
+    return hasGenre || hasSpecial;
+}
+
+export async function POST(request: Request) {
+    const { error, context } = await requireStaffAuth(request as unknown as NextRequest);
+    if (error || !context) return error!;
+
+    try {
+        const { songIds, genreToggleIds, specialToggleIds, artist, excludeFromGlobal } = await request.json();
+
+        if (!songIds || !Array.isArray(songIds) || songIds.length === 0) {
+            return NextResponse.json({ error: 'Missing or invalid songIds array' }, { status: 400 });
+        }
+
+        // Validate that at least one operation is requested
+        const hasGenreToggle = genreToggleIds && Array.isArray(genreToggleIds) && genreToggleIds.length > 0;
+        const hasSpecialToggle = specialToggleIds && Array.isArray(specialToggleIds) && specialToggleIds.length > 0;
+        const hasArtistChange = artist !== undefined && artist !== null && artist.trim() !== '';
+        const hasExcludeGlobalChange = excludeFromGlobal !== undefined;
+
+        if (!hasGenreToggle && !hasSpecialToggle && !hasArtistChange && !hasExcludeGlobalChange) {
+            return NextResponse.json({ error: 'No update operations specified' }, { status: 400 });
+        }
+
+        // Validate artist if provided
+        if (hasArtistChange && artist.trim() === '') {
+            return NextResponse.json({ error: 'Artist cannot be empty' }, { status: 400 });
+        }
+
+        // Validate excludeFromGlobal permission
+        if (hasExcludeGlobalChange && context.role === 'curator' && !context.curator.isGlobalCurator) {
+            return NextResponse.json(
+                { error: 'Forbidden: Only global curators or admins can change global playlist flag' },
+                { status: 403 }
+            );
+        }
+
+        let assignments: { genreIds: Set<number>; specialIds: Set<number> } | null = null;
+        if (context.role === 'curator') {
+            const curatorAssignments = await getCuratorAssignments(context.curator.id);
+            assignments = curatorAssignments;
+
+            // Validate genre/special toggles are within curator's assignments
+            if (hasGenreToggle) {
+                const invalidGenre = genreToggleIds.some((id: number) => !curatorAssignments.genreIds.has(id));
+                if (invalidGenre) {
+                    return NextResponse.json(
+                        { error: 'Curators may only toggle their own genres' },
+                        { status: 403 }
+                    );
+                }
+            }
+
+            if (hasSpecialToggle) {
+                const invalidSpecial = specialToggleIds.some((id: number) => !curatorAssignments.specialIds.has(id));
+                if (invalidSpecial) {
+                    return NextResponse.json(
+                        { error: 'Curators may only toggle their own specials' },
+                        { status: 403 }
+                    );
+                }
+            }
+        }
+
+        // Load all songs with relations for permission checks
+        const songs = await prisma.song.findMany({
+            where: { id: { in: songIds.map((id: any) => Number(id)) } },
+            include: {
+                genres: true,
+                specials: {
+                    include: {
+                        special: true
+                    }
+                },
+            },
+        });
+
+        if (songs.length === 0) {
+            return NextResponse.json({ error: 'No songs found' }, { status: 404 });
+        }
+
+        // Filter songs that can be edited
+        const editableSongs = context.role === 'admin'
+            ? songs
+            : songs.filter(song => curatorCanEditSong(context, song, assignments!));
+
+        if (editableSongs.length === 0) {
+            return NextResponse.json(
+                { error: 'No songs can be edited with current permissions' },
+                { status: 403 }
+            );
+        }
+
+        const results = {
+            total: songIds.length,
+            processed: editableSongs.length,
+            skipped: songs.length - editableSongs.length,
+            success: 0,
+            errors: [] as Array<{ songId: number; error: string }>,
+        };
+
+        // Process each song in a transaction
+        for (const song of editableSongs) {
+            try {
+                await prisma.$transaction(async (tx) => {
+                    const updateData: any = {};
+
+                    // Handle artist change
+                    if (hasArtistChange) {
+                        updateData.artist = artist.trim();
+                    }
+
+                    // Handle excludeFromGlobal change
+                    if (hasExcludeGlobalChange) {
+                        updateData.excludeFromGlobal = excludeFromGlobal;
+                    }
+
+                    // Handle genre toggles
+                    if (hasGenreToggle) {
+                        const currentGenreIds = song.genres.map(g => g.id);
+                        const genreIdsToToggle = genreToggleIds as number[];
+
+                        // Determine which genres to add/remove
+                        const genresToAdd = genreIdsToToggle.filter(id => !currentGenreIds.includes(id));
+                        const genresToRemove = genreIdsToToggle.filter(id => currentGenreIds.includes(id));
+
+                        // For curators, preserve genres they can't manage
+                        let finalGenreIds: number[];
+                        if (context.role === 'curator') {
+                            const fixedGenreIds = currentGenreIds.filter(gid => !assignments!.genreIds.has(gid));
+                            const managedGenreIds = currentGenreIds
+                                .filter(gid => assignments!.genreIds.has(gid) && !genresToRemove.includes(gid))
+                                .concat(genresToAdd);
+                            finalGenreIds = Array.from(new Set([...fixedGenreIds, ...managedGenreIds]));
+                        } else {
+                            const newGenreIds = currentGenreIds
+                                .filter(id => !genresToRemove.includes(id))
+                                .concat(genresToAdd);
+                            finalGenreIds = Array.from(new Set(newGenreIds));
+                        }
+
+                        updateData.genres = {
+                            set: finalGenreIds.map(gId => ({ id: gId }))
+                        };
+                    }
+
+                    // Update song basic data
+                    if (Object.keys(updateData).length > 0) {
+                        await tx.song.update({
+                            where: { id: song.id },
+                            data: updateData,
+                        });
+                    }
+
+                    // Handle special toggles
+                    if (hasSpecialToggle) {
+                        const currentSpecials = await tx.specialSong.findMany({
+                            where: { songId: song.id }
+                        });
+                        const currentSpecialIds = currentSpecials.map(ss => ss.specialId);
+                        const specialIdsToToggle = specialToggleIds as number[];
+
+                        // Determine which specials to add/remove
+                        const specialsToAdd = specialIdsToToggle.filter(id => !currentSpecialIds.includes(id));
+                        const specialsToRemove = specialIdsToToggle.filter(id => currentSpecialIds.includes(id));
+
+                        // For curators, preserve specials they can't manage
+                        let finalSpecialIds: number[];
+                        if (context.role === 'curator') {
+                            const fixedSpecialIds = currentSpecialIds.filter(sid => !assignments!.specialIds.has(sid));
+                            const managedSpecialIds = currentSpecialIds
+                                .filter(sid => assignments!.specialIds.has(sid) && !specialsToRemove.includes(sid))
+                                .concat(specialsToAdd);
+                            finalSpecialIds = Array.from(new Set([...fixedSpecialIds, ...managedSpecialIds]));
+                        } else {
+                            const newSpecialIds = currentSpecialIds
+                                .filter(id => !specialsToRemove.includes(id))
+                                .concat(specialsToAdd);
+                            finalSpecialIds = Array.from(new Set(newSpecialIds));
+                        }
+
+                        // Delete removed specials
+                        const toDelete = currentSpecialIds.filter(sid => !finalSpecialIds.includes(sid));
+                        if (toDelete.length > 0) {
+                            await tx.specialSong.deleteMany({
+                                where: {
+                                    songId: song.id,
+                                    specialId: { in: toDelete }
+                                }
+                            });
+                        }
+
+                        // Add new specials
+                        const toAdd = finalSpecialIds.filter(sid => !currentSpecialIds.includes(sid));
+                        if (toAdd.length > 0) {
+                            await tx.specialSong.createMany({
+                                data: toAdd.map(specialId => ({
+                                    songId: song.id,
+                                    specialId,
+                                    startTime: 0
+                                }))
+                            });
+                        }
+                    }
+                });
+
+                results.success++;
+            } catch (error: any) {
+                results.errors.push({
+                    songId: song.id,
+                    error: error.message || 'Unknown error'
+                });
+            }
+        }
+
+        return NextResponse.json(results);
+    } catch (error) {
+        console.error('Error in batch update:', error);
+        return NextResponse.json({ error: 'Internal Server Error' }, { status: 500 });
+    }
+}
+

app/api/songs/route.ts

@@ -35,11 +35,15 @@ function curatorCanEditSong(context: StaffContext, song: any, assignments: { gen
     // - `SpecialSong`    (mit `specialId`)
     // - `SpecialSong`    (mit Relation `special.id`)
     // sein. Wir normalisieren hier auf reine Zahlen-IDs.
+    // WICHTIG: Bei SpecialSong-Objekten ist s.id die SpecialSong-ID, nicht die Special-ID!
+    // Daher zuerst specialId oder special.id prüfen.
     const songSpecialIds = (song.specials || [])
         .map((s: any) => {
-            if (s?.id != null) return s.id;
+            // Priorität: specialId oder special.id (die tatsächliche Special-ID)
             if (s?.specialId != null) return s.specialId;
             if (s?.special?.id != null) return s.special.id;
+            // Nur wenn es direkt ein Special-Objekt ist (nicht SpecialSong), verwende s.id
+            if (s?.id != null && s?.specialId == null && s?.special == null) return s.id;
             return undefined;
         })
         .filter((id: any): id is number => typeof id === 'number');
@@ -59,11 +63,15 @@ function curatorCanDeleteSong(context: StaffContext, song: any, assignments: { g
     if (context.role === 'admin') return true;
 
     const songGenreIds = (song.genres || []).map((g: any) => g.id);
+    // WICHTIG: Bei SpecialSong-Objekten ist s.id die SpecialSong-ID, nicht die Special-ID!
+    // Daher zuerst specialId oder special.id prüfen.
     const songSpecialIds = (song.specials || [])
         .map((s: any) => {
-            if (s?.id != null) return s.id;
+            // Priorität: specialId oder special.id (die tatsächliche Special-ID)
             if (s?.specialId != null) return s.specialId;
             if (s?.special?.id != null) return s.special.id;
+            // Nur wenn es direkt ein Special-Objekt ist (nicht SpecialSong), verwende s.id
+            if (s?.id != null && s?.specialId == null && s?.special == null) return s.id;
             return undefined;
         })
         .filter((id: any): id is number => typeof id === 'number');
@@ -382,7 +390,11 @@ export async function PUT(request: Request) {
             where: { id: Number(id) },
             include: {
                 genres: true,
-                specials: true,
+                specials: {
+                    include: {
+                        special: true
+                    }
+                },
             },
         });
 

app/curator/CuratorPageClient.tsx

@@ -2,6 +2,8 @@
 
 import { useEffect, useRef, useState } from 'react';
 import { useTranslations, useLocale } from 'next-intl';
+import { Link } from '@/lib/navigation';
+import HelpTooltip from '@/components/HelpTooltip';
 
 interface Genre {
     id: number;
@@ -83,6 +85,8 @@ function getCuratorUploadHeaders() {
 export default function CuratorPageClient() {
     const t = useTranslations('Curator');
     const tNav = useTranslations('Navigation');
+    const tHelp = useTranslations('CuratorHelp');
+    const locale = useLocale();
     const [username, setUsername] = useState('');
     const [password, setPassword] = useState('');
     const [isAuthenticated, setIsAuthenticated] = useState(false);
@@ -129,6 +133,14 @@ export default function CuratorPageClient() {
     const [loadingComments, setLoadingComments] = useState(false);
     const [showComments, setShowComments] = useState(false);
 
+    // Batch edit state
+    const [selectedSongIds, setSelectedSongIds] = useState<Set<number>>(new Set());
+    const [batchGenreIds, setBatchGenreIds] = useState<number[]>([]);
+    const [batchSpecialIds, setBatchSpecialIds] = useState<number[]>([]);
+    const [batchArtist, setBatchArtist] = useState('');
+    const [batchExcludeFromGlobal, setBatchExcludeFromGlobal] = useState<boolean | undefined>(undefined);
+    const [isBatchUpdating, setIsBatchUpdating] = useState(false);
+
     useEffect(() => {
         const authToken = localStorage.getItem('hoerdle_curator_auth');
         const storedUsername = localStorage.getItem('hoerdle_curator_username');
@@ -384,6 +396,96 @@ export default function CuratorPageClient() {
         }
     };
 
+    // Batch edit functions
+    const toggleSongSelection = (songId: number) => {
+        setSelectedSongIds(prev => {
+            const newSet = new Set(prev);
+            if (newSet.has(songId)) {
+                newSet.delete(songId);
+            } else {
+                // Only allow selection of editable songs
+                const song = songs.find(s => s.id === songId);
+                if (song && canEditSong(song)) {
+                    newSet.add(songId);
+                }
+            }
+            return newSet;
+        });
+    };
+
+    const selectAllVisible = () => {
+        const editableVisibleIds = visibleSongs
+            .filter(song => canEditSong(song))
+            .map(song => song.id);
+        setSelectedSongIds(new Set(editableVisibleIds));
+    };
+
+    const clearSelection = () => {
+        setSelectedSongIds(new Set());
+        setBatchGenreIds([]);
+        setBatchSpecialIds([]);
+        setBatchArtist('');
+        setBatchExcludeFromGlobal(undefined);
+    };
+
+    const handleBatchUpdate = async () => {
+        if (selectedSongIds.size === 0) {
+            setMessage(t('noSongsSelected') || 'No songs selected');
+            return;
+        }
+
+        const hasGenreToggle = batchGenreIds.length > 0;
+        const hasSpecialToggle = batchSpecialIds.length > 0;
+        const hasArtistChange = batchArtist.trim() !== '';
+        const hasExcludeGlobalChange = batchExcludeFromGlobal !== undefined;
+
+        if (!hasGenreToggle && !hasSpecialToggle && !hasArtistChange && !hasExcludeGlobalChange) {
+            setMessage(t('noBatchOperations') || 'No batch operations specified');
+            return;
+        }
+
+        setIsBatchUpdating(true);
+        setMessage('');
+
+        try {
+            const res = await fetch('/api/songs/batch', {
+                method: 'POST',
+                headers: getCuratorAuthHeaders(),
+                body: JSON.stringify({
+                    songIds: Array.from(selectedSongIds),
+                    genreToggleIds: hasGenreToggle ? batchGenreIds : undefined,
+                    specialToggleIds: hasSpecialToggle ? batchSpecialIds : undefined,
+                    artist: hasArtistChange ? batchArtist.trim() : undefined,
+                    excludeFromGlobal: hasExcludeGlobalChange ? batchExcludeFromGlobal : undefined,
+                }),
+            });
+
+            if (res.ok) {
+                const result = await res.json();
+                await fetchSongs();
+                
+                let msg = t('batchUpdateSuccess') || `Successfully updated ${result.success} of ${result.processed} songs`;
+                if (result.skipped > 0) {
+                    msg += ` (${result.skipped} skipped)`;
+                }
+                if (result.errors.length > 0) {
+                    msg += `\nErrors: ${result.errors.map((e: any) => `Song ${e.songId}: ${e.error}`).join(', ')}`;
+                }
+                setMessage(msg);
+                
+                // Clear selection after successful update
+                clearSelection();
+            } else {
+                const errText = await res.text();
+                setMessage(t('batchUpdateError') || `Error: ${errText}`);
+            }
+        } catch (e) {
+            setMessage(t('batchUpdateNetworkError') || 'Network error during batch update');
+        } finally {
+            setIsBatchUpdating(false);
+        }
+    };
+
     const handleSort = (field: SortField) => {
         if (sortField === field) {
             setSortDirection(sortDirection === 'asc' ? 'desc' : 'asc');
@@ -689,7 +791,14 @@ export default function CuratorPageClient() {
                 }}
             >
                 <div>
-                    <h1 style={{ fontSize: '1.75rem', marginBottom: '0.25rem' }}>Kuratoren-Dashboard</h1>
+                    <div style={{ display: 'flex', alignItems: 'center', gap: '0.5rem' }}>
+                        <h1 style={{ fontSize: '1.75rem', marginBottom: '0.25rem' }}>Kuratoren-Dashboard</h1>
+                        <HelpTooltip
+                            shortText={tHelp('tooltipDashboardShort')}
+                            longText={tHelp('tooltipDashboardLong')}
+                            position="bottom"
+                        />
+                    </div>
                     {curatorInfo && (
                         <p style={{ color: '#4b5563', fontSize: '0.9rem' }}>
                             {t('loggedInAs', { username: curatorInfo.username })}
@@ -697,20 +806,47 @@ export default function CuratorPageClient() {
                         </p>
                     )}
                 </div>
-                <button
+                <div style={{ display: 'flex', gap: '0.5rem', alignItems: 'center' }}>
-                    type="button"
+                    <Link
-                    onClick={handleLogout}
+                        href="/curator/help"
-                    style={{
+                        style={{
-                        padding: '0.5rem 1rem',
+                            padding: '0.5rem 1rem',
-                        background: '#6b7280',
+                            background: '#3b82f6',
-                        color: 'white',
+                            color: 'white',
-                        border: 'none',
+                            textDecoration: 'none',
-                        borderRadius: '0.375rem',
+                            borderRadius: '0.375rem',
-                        cursor: 'pointer',
+                            fontSize: '0.9rem',
-                    }}
+                            display: 'inline-flex',
-                >
+                            alignItems: 'center',
-                    {t('logout')}
+                            gap: '0.25rem',
-                </button>
+                            lineHeight: '1.5',
+                            boxSizing: 'border-box',
+                            fontFamily: 'inherit',
+                        }}
+                    >
+                        ℹ {tHelp('helpButton')}
+                    </Link>
+                    <button
+                        type="button"
+                        onClick={handleLogout}
+                        style={{
+                            padding: '0.5rem 1rem',
+                            background: '#6b7280',
+                            color: 'white',
+                            border: 'none',
+                            borderRadius: '0.375rem',
+                            cursor: 'pointer',
+                            fontSize: '0.9rem',
+                            display: 'inline-flex',
+                            alignItems: 'center',
+                            lineHeight: '1.5',
+                            boxSizing: 'border-box',
+                            fontFamily: 'inherit',
+                        }}
+                    >
+                        {t('logout')}
+                    </button>
+                </div>
             </header>
 
             {loading && <p>{t('loadingData')}</p>}
@@ -727,9 +863,16 @@ export default function CuratorPageClient() {
                     <section style={{ marginBottom: '2rem' }}>
                         <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '0.75rem' }}>
                             <div style={{ display: 'flex', alignItems: 'baseline', gap: '0.75rem' }}>
-                                <h2 style={{ fontSize: '1.25rem', marginBottom: 0 }}>
+                                <div style={{ display: 'flex', alignItems: 'center', gap: '0.5rem' }}>
-                                    {t('commentsTitle')} ({comments.length})
+                                    <h2 style={{ fontSize: '1.25rem', marginBottom: 0 }}>
-                                </h2>
+                                        {t('commentsTitle')} ({comments.length})
+                                    </h2>
+                                    <HelpTooltip
+                                        shortText={tHelp('tooltipCommentsShort')}
+                                        longText={tHelp('tooltipCommentsLong')}
+                                        position="right"
+                                    />
+                                </div>
                                 {hasUnread && (
                                     <span style={{
                                         padding: '0.25rem 0.75rem',
@@ -880,7 +1023,14 @@ export default function CuratorPageClient() {
             })()}
 
             <section style={{ marginBottom: '2rem' }}>
-                <h2 style={{ fontSize: '1.25rem', marginBottom: '0.75rem' }}>{t('uploadSectionTitle')}</h2>
+                <div style={{ display: 'flex', alignItems: 'center', gap: '0.5rem', marginBottom: '0.75rem' }}>
+                    <h2 style={{ fontSize: '1.25rem', margin: 0 }}>{t('uploadSectionTitle')}</h2>
+                    <HelpTooltip
+                        shortText={tHelp('tooltipUploadShort')}
+                        longText={tHelp('tooltipUploadLong')}
+                        position="right"
+                    />
+                </div>
                 <p style={{ marginBottom: '0.75rem', color: '#4b5563', fontSize: '0.9rem' }}>
                     {t('uploadSectionDescription')}
                 </p>
@@ -980,7 +1130,14 @@ export default function CuratorPageClient() {
                     )}
 
                     <div>
-                        <div style={{ fontWeight: 500, marginBottom: '0.25rem' }}>{t('assignGenresLabel')}</div>
+                        <div style={{ display: 'flex', alignItems: 'center', gap: '0.5rem', marginBottom: '0.25rem' }}>
+                            <div style={{ fontWeight: 500 }}>{t('assignGenresLabel')}</div>
+                            <HelpTooltip
+                                shortText={tHelp('tooltipGenreAssignmentShort')}
+                                longText={tHelp('tooltipGenreAssignmentLong')}
+                                position="right"
+                            />
+                        </div>
                         <div style={{ display: 'flex', flexWrap: 'wrap', gap: '0.25rem' }}>
                             {genres
                                 .filter(g => curatorInfo?.genreIds?.includes(g.id))
@@ -1056,70 +1213,91 @@ export default function CuratorPageClient() {
             </section>
 
             <section style={{ marginBottom: '2rem' }}>
-                <h2 style={{ fontSize: '1.25rem', marginBottom: '0.75rem' }}>
+                <div style={{ display: 'flex', alignItems: 'center', gap: '0.5rem', marginBottom: '0.75rem' }}>
-                    {t('tracklistTitle', { count: filteredSongs.length })}
+                    <h2 style={{ fontSize: '1.25rem', margin: 0 }}>
-                </h2>
+                        {t('tracklistTitle', { count: filteredSongs.length })}
+                    </h2>
+                    <HelpTooltip
+                        shortText={tHelp('tooltipTracklistShort')}
+                        longText={tHelp('tooltipTracklistLong')}
+                        position="right"
+                    />
+                </div>
                 <p style={{ marginBottom: '0.75rem', color: '#4b5563', fontSize: '0.9rem' }}>
                     {t('tracklistDescription')}
                 </p>
 
                 {/* Suche & Filter */}
-                <div style={{ marginBottom: '0.75rem', display: 'flex', gap: '0.5rem', flexWrap: 'wrap' }}>
+                <div style={{ marginBottom: '0.75rem', display: 'flex', gap: '0.5rem', flexWrap: 'wrap', alignItems: 'center' }}>
-                    <input
+                    <div style={{ flex: '1', minWidth: '200px', display: 'flex', alignItems: 'center', gap: '0.25rem' }}>
-                        type="text"
+                        <input
-                        placeholder={t('searchPlaceholder')}
+                            type="text"
-                        value={searchQuery}
+                            placeholder={t('searchPlaceholder')}
-                        onChange={e => {
+                            value={searchQuery}
-                            setSearchQuery(e.target.value);
+                            onChange={e => {
-                            setCurrentPage(1);
+                                setSearchQuery(e.target.value);
-                        }}
+                                setCurrentPage(1);
-                        style={{
+                            }}
-                            flex: '1',
+                            style={{
-                            minWidth: '200px',
+                                flex: '1',
-                            padding: '0.4rem 0.6rem',
+                                minWidth: '200px',
-                            borderRadius: '0.25rem',
+                                padding: '0.4rem 0.6rem',
-                            border: '1px solid #d1d5db',
+                                borderRadius: '0.25rem',
-                        }}
+                                border: '1px solid #d1d5db',
-                    />
+                            }}
-                    <select
+                        />
-                        value={selectedFilter}
+                        <HelpTooltip
-                        onChange={e => {
+                            shortText={tHelp('tooltipSearchShort')}
-                            setSelectedFilter(e.target.value);
+                            longText={tHelp('tooltipSearchLong')}
-                            setCurrentPage(1);
+                            position="top"
-                        }}
+                        />
-                        style={{
+                    </div>
-                            minWidth: '180px',
+                    <div style={{ display: 'flex', alignItems: 'center', gap: '0.25rem' }}>
-                            padding: '0.4rem 0.6rem',
+                        <select
-                            borderRadius: '0.25rem',
+                            value={selectedFilter}
-                            border: '1px solid #d1d5db',
+                            onChange={e => {
-                        }}
+                                setSelectedFilter(e.target.value);
-                    >
+                                setCurrentPage(1);
-                        <option value="">{t('filterAll')}</option>
+                            }}
-                        <option value="no-global">{t('filterNoGlobal')}</option>
+                            style={{
-                        <optgroup label="Genres">
+                                minWidth: '180px',
-                            {genres
+                                padding: '0.4rem 0.6rem',
-                                .filter(g => curatorInfo?.genreIds?.includes(g.id))
+                                borderRadius: '0.25rem',
-                                .map(genre => (
+                                border: '1px solid #d1d5db',
-                                    <option key={genre.id} value={`genre:${genre.id}`}>
+                            }}
-                                        {typeof genre.name === 'string'
+                        >
-                                            ? genre.name
+                            <option value="">{t('filterAll')}</option>
-                                            : genre.name?.de ?? genre.name?.en}
+                            <option value="no-global">{t('filterNoGlobal')}</option>
-                                    </option>
+                            <optgroup label="Genres">
-                                ))}
+                                {genres
-                        </optgroup>
+                                    .filter(g => curatorInfo?.genreIds?.includes(g.id))
-                        <optgroup label="Specials">
+                                    .map(genre => (
-                            {specials
+                                        <option key={genre.id} value={`genre:${genre.id}`}>
-                                .filter(s => curatorInfo?.specialIds?.includes(s.id))
+                                            {typeof genre.name === 'string'
-                                .map(special => (
+                                                ? genre.name
-                                    <option key={special.id} value={`special:${special.id}`}>
+                                                : genre.name?.de ?? genre.name?.en}
-                                        ★{' '}
+                                        </option>
-                                        {typeof special.name === 'string'
+                                    ))}
-                                            ? special.name
+                            </optgroup>
-                                            : special.name?.de ?? special.name?.en}
+                            <optgroup label="Specials">
-                                    </option>
+                                {specials
-                                ))}
+                                    .filter(s => curatorInfo?.specialIds?.includes(s.id))
-                        </optgroup>
+                                    .map(special => (
-                    </select>
+                                        <option key={special.id} value={`special:${special.id}`}>
+                                            ★{' '}
+                                            {typeof special.name === 'string'
+                                                ? special.name
+                                                : special.name?.de ?? special.name?.en}
+                                        </option>
+                                    ))}
+                            </optgroup>
+                        </select>
+                        <HelpTooltip
+                            shortText={tHelp('tooltipFilterShort')}
+                            longText={tHelp('tooltipFilterLong')}
+                            position="top"
+                        />
+                    </div>
                     {(searchQuery || selectedFilter) && (
                         <button
                             type="button"
@@ -1146,6 +1324,225 @@ export default function CuratorPageClient() {
                     <p>{t('noSongsInScope')}</p>
                 ) : (
                     <>
+                        {/* Batch Edit Toolbar */}
+                        {selectedSongIds.size > 0 && (
+                            <div
+                                style={{
+                                    marginBottom: '1rem',
+                                    padding: '1rem',
+                                    background: '#f0f9ff',
+                                    border: '1px solid #bae6fd',
+                                    borderRadius: '0.5rem',
+                                }}
+                            >
+                                <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '0.75rem' }}>
+                                    <div style={{ display: 'flex', alignItems: 'center', gap: '0.5rem' }}>
+                                        <strong style={{ fontSize: '1rem' }}>
+                                            {t('batchEditTitle') || `Batch Edit: ${selectedSongIds.size} ${selectedSongIds.size === 1 ? 'song' : 'songs'} selected`}
+                                        </strong>
+                                        <HelpTooltip
+                                            shortText={tHelp('tooltipBatchEditShort')}
+                                            longText={tHelp('tooltipBatchEditLong')}
+                                            position="right"
+                                        />
+                                    </div>
+                                    <button
+                                        type="button"
+                                        onClick={clearSelection}
+                                        style={{
+                                            padding: '0.25rem 0.5rem',
+                                            background: '#e5e7eb',
+                                            border: 'none',
+                                            borderRadius: '0.25rem',
+                                            cursor: 'pointer',
+                                            fontSize: '0.85rem',
+                                        }}
+                                    >
+                                        {t('clearSelection') || 'Clear Selection'}
+                                    </button>
+                                </div>
+                                
+                                <div style={{ display: 'flex', flexDirection: 'column', gap: '0.75rem' }}>
+                                    {/* Genre Toggle */}
+                                    <div>
+                                        <div style={{ display: 'flex', alignItems: 'center', gap: '0.5rem', marginBottom: '0.25rem' }}>
+                                            <label style={{ display: 'block', fontWeight: 500, fontSize: '0.9rem', margin: 0 }}>
+                                                {t('batchToggleGenres') || 'Toggle Genres'}
+                                            </label>
+                                            <HelpTooltip
+                                                shortText={tHelp('tooltipBatchGenreToggleShort')}
+                                                longText={tHelp('tooltipBatchGenreToggleLong')}
+                                                position="right"
+                                            />
+                                        </div>
+                                        <div style={{ display: 'flex', flexWrap: 'wrap', gap: '0.25rem' }}>
+                                            {genres
+                                                .filter(g => curatorInfo?.genreIds?.includes(g.id))
+                                                .map(genre => (
+                                                    <label
+                                                        key={genre.id}
+                                                        style={{
+                                                            display: 'flex',
+                                                            alignItems: 'center',
+                                                            gap: '0.25rem',
+                                                            padding: '0.25rem 0.5rem',
+                                                            borderRadius: '999px',
+                                                            background: batchGenreIds.includes(genre.id) ? '#e5f3ff' : '#f3f4f6',
+                                                            fontSize: '0.8rem',
+                                                            cursor: 'pointer',
+                                                        }}
+                                                    >
+                                                        <input
+                                                            type="checkbox"
+                                                            checked={batchGenreIds.includes(genre.id)}
+                                                            onChange={() => {
+                                                                setBatchGenreIds(prev =>
+                                                                    prev.includes(genre.id)
+                                                                        ? prev.filter(id => id !== genre.id)
+                                                                        : [...prev, genre.id]
+                                                                );
+                                                            }}
+                                                        />
+                                                        {typeof genre.name === 'string'
+                                                            ? genre.name
+                                                            : genre.name?.de ?? genre.name?.en}
+                                                    </label>
+                                                ))}
+                                        </div>
+                                    </div>
+
+                                    {/* Special Toggle */}
+                                    <div>
+                                        <div style={{ display: 'flex', alignItems: 'center', gap: '0.5rem', marginBottom: '0.25rem' }}>
+                                            <label style={{ display: 'block', fontWeight: 500, fontSize: '0.9rem', margin: 0 }}>
+                                                {t('batchToggleSpecials') || 'Toggle Specials'}
+                                            </label>
+                                            <HelpTooltip
+                                                shortText={tHelp('tooltipBatchSpecialToggleShort')}
+                                                longText={tHelp('tooltipBatchSpecialToggleLong')}
+                                                position="right"
+                                            />
+                                        </div>
+                                        <div style={{ display: 'flex', flexWrap: 'wrap', gap: '0.25rem' }}>
+                                            {specials
+                                                .filter(s => curatorInfo?.specialIds?.includes(s.id))
+                                                .map(special => (
+                                                    <label
+                                                        key={special.id}
+                                                        style={{
+                                                            display: 'flex',
+                                                            alignItems: 'center',
+                                                            gap: '0.25rem',
+                                                            padding: '0.25rem 0.5rem',
+                                                            borderRadius: '999px',
+                                                            background: batchSpecialIds.includes(special.id) ? '#fee2e2' : '#f3f4f6',
+                                                            fontSize: '0.8rem',
+                                                            cursor: 'pointer',
+                                                        }}
+                                                    >
+                                                        <input
+                                                            type="checkbox"
+                                                            checked={batchSpecialIds.includes(special.id)}
+                                                            onChange={() => {
+                                                                setBatchSpecialIds(prev =>
+                                                                    prev.includes(special.id)
+                                                                        ? prev.filter(id => id !== special.id)
+                                                                        : [...prev, special.id]
+                                                                );
+                                                            }}
+                                                        />
+                                                        ★{' '}
+                                                        {typeof special.name === 'string'
+                                                            ? special.name
+                                                            : special.name?.de ?? special.name?.en}
+                                                    </label>
+                                                ))}
+                                        </div>
+                                    </div>
+
+                                    {/* Artist Change */}
+                                    <div>
+                                        <div style={{ display: 'flex', alignItems: 'center', gap: '0.5rem', marginBottom: '0.25rem' }}>
+                                            <label style={{ display: 'block', fontWeight: 500, fontSize: '0.9rem', margin: 0 }}>
+                                                {t('batchChangeArtist') || 'Change Artist'}
+                                            </label>
+                                            <HelpTooltip
+                                                shortText={tHelp('tooltipBatchArtistShort')}
+                                                longText={tHelp('tooltipBatchArtistLong')}
+                                                position="right"
+                                            />
+                                        </div>
+                                        <input
+                                            type="text"
+                                            value={batchArtist}
+                                            onChange={e => setBatchArtist(e.target.value)}
+                                            placeholder={t('batchArtistPlaceholder') || 'Enter new artist name'}
+                                            style={{
+                                                width: '100%',
+                                                maxWidth: '400px',
+                                                padding: '0.4rem 0.6rem',
+                                                borderRadius: '0.25rem',
+                                                border: '1px solid #d1d5db',
+                                                fontSize: '0.9rem',
+                                            }}
+                                        />
+                                    </div>
+
+                                    {/* Exclude Global Flag */}
+                                    {curatorInfo?.isGlobalCurator && (
+                                        <div>
+                                            <label style={{ display: 'block', fontWeight: 500, marginBottom: '0.25rem', fontSize: '0.9rem' }}>
+                                                {t('batchExcludeGlobal') || 'Exclude from Global'}
+                                            </label>
+                                            <select
+                                                value={batchExcludeFromGlobal === undefined ? '' : batchExcludeFromGlobal ? 'true' : 'false'}
+                                                onChange={e => {
+                                                    if (e.target.value === '') {
+                                                        setBatchExcludeFromGlobal(undefined);
+                                                    } else {
+                                                        setBatchExcludeFromGlobal(e.target.value === 'true');
+                                                    }
+                                                }}
+                                                style={{
+                                                    padding: '0.4rem 0.6rem',
+                                                    borderRadius: '0.25rem',
+                                                    border: '1px solid #d1d5db',
+                                                    fontSize: '0.9rem',
+                                                }}
+                                            >
+                                                <option value="">{t('batchNoChange') || 'No change'}</option>
+                                                <option value="true">{t('batchExclude') || 'Exclude'}</option>
+                                                <option value="false">{t('batchInclude') || 'Include'}</option>
+                                            </select>
+                                        </div>
+                                    )}
+
+                                    {/* Apply Button */}
+                                    <div>
+                                        <button
+                                            type="button"
+                                            onClick={handleBatchUpdate}
+                                            disabled={isBatchUpdating}
+                                            style={{
+                                                padding: '0.5rem 1rem',
+                                                background: isBatchUpdating ? '#9ca3af' : '#10b981',
+                                                color: 'white',
+                                                border: 'none',
+                                                borderRadius: '0.375rem',
+                                                cursor: isBatchUpdating ? 'not-allowed' : 'pointer',
+                                                fontWeight: 'bold',
+                                                fontSize: '0.9rem',
+                                            }}
+                                        >
+                                            {isBatchUpdating
+                                                ? (t('batchUpdating') || 'Updating...')
+                                                : (t('batchApply') || 'Apply Changes')}
+                                        </button>
+                                    </div>
+                                </div>
+                            </div>
+                        )}
+                        
                         <div style={{ overflowX: 'auto' }}>
                             <table
                                 style={{
@@ -1156,6 +1553,21 @@ export default function CuratorPageClient() {
                             >
                                 <thead>
                                     <tr style={{ borderBottom: '1px solid #e5e7eb' }}>
+                                        <th style={{ padding: '0.5rem', width: '40px' }}>
+                                            <input
+                                                type="checkbox"
+                                                checked={visibleSongs.length > 0 && visibleSongs.every(song => canEditSong(song) && selectedSongIds.has(song.id))}
+                                                onChange={(e) => {
+                                                    if (e.target.checked) {
+                                                        selectAllVisible();
+                                                    } else {
+                                                        clearSelection();
+                                                    }
+                                                }}
+                                                style={{ cursor: 'pointer' }}
+                                                title={t('selectAll') || 'Select all'}
+                                            />
+                                        </th>
                                         <th
                                             style={{ padding: '0.5rem', cursor: 'pointer' }}
                                             onClick={() => handleSort('id')}
@@ -1214,8 +1626,26 @@ export default function CuratorPageClient() {
                                                 ? `${(song.averageRating || 0).toFixed(1)} (${song.ratingCount})`
                                                 : '-';
 
+                                        const isSelected = selectedSongIds.has(song.id);
+                                        
                                         return (
-                                            <tr key={song.id} style={{ borderBottom: '1px solid #f3f4f6' }}>
+                                            <tr 
+                                                key={song.id} 
+                                                style={{ 
+                                                    borderBottom: '1px solid #f3f4f6',
+                                                    backgroundColor: isSelected ? '#eff6ff' : 'transparent',
+                                                }}
+                                            >
+                                                <td style={{ padding: '0.5rem' }}>
+                                                    <input
+                                                        type="checkbox"
+                                                        checked={isSelected}
+                                                        onChange={() => toggleSongSelection(song.id)}
+                                                        disabled={!editable}
+                                                        style={{ cursor: editable ? 'pointer' : 'not-allowed' }}
+                                                        title={editable ? (t('selectSong') || 'Select song') : (t('cannotEditSong') || 'Cannot edit this song')}
+                                                    />
+                                                </td>
                                                 <td style={{ padding: '0.5rem' }}>{song.id}</td>
                                                 <td style={{ padding: '0.5rem' }}>
                                                     <button
@@ -1316,6 +1746,41 @@ export default function CuratorPageClient() {
                                                                                 : genre.name?.de ?? genre.name?.en}
                                                                         </label>
                                                                     ))}
+                                                                {specials
+                                                                    .filter(s => curatorInfo?.specialIds?.includes(s.id))
+                                                                    .map(special => (
+                                                                        <label
+                                                                            key={special.id}
+                                                                            style={{
+                                                                                display: 'flex',
+                                                                                alignItems: 'center',
+                                                                                gap: '0.25rem',
+                                                                                padding: '0.15rem 0.4rem',
+                                                                                borderRadius: '999px',
+                                                                                background: editSpecialIds.includes(special.id)
+                                                                                    ? '#fee2e2'
+                                                                                    : '#f3f4f6',
+                                                                                fontSize: '0.8rem',
+                                                                                cursor: 'pointer',
+                                                                            }}
+                                                                        >
+                                                                            <input
+                                                                                type="checkbox"
+                                                                                checked={editSpecialIds.includes(special.id)}
+                                                                                onChange={() =>
+                                                                                    setEditSpecialIds(prev =>
+                                                                                        prev.includes(special.id)
+                                                                                            ? prev.filter(id => id !== special.id)
+                                                                                            : [...prev, special.id]
+                                                                                    )
+                                                                                }
+                                                                            />
+                                                                            ★{' '}
+                                                                            {typeof special.name === 'string'
+                                                                                ? special.name
+                                                                                : special.name?.de ?? special.name?.en}
+                                                                        </label>
+                                                                    ))}
                                                             </div>
                                                             <div style={{ display: 'flex', flexWrap: 'wrap', gap: '0.25rem' }}>
                                                                 {song.genres
@@ -1337,21 +1802,26 @@ export default function CuratorPageClient() {
                                                                                 : g.name?.de ?? g.name?.en}
                                                                         </span>
                                                                     ))}
-                                                                {song.specials.map(s => (
+                                                                {song.specials
-                                                                    <span
+                                                                    .filter(
-                                                                        key={`s-${s.id}`}
+                                                                        s => !curatorInfo?.specialIds?.includes(s.id)
-                                                                        style={{
+                                                                    )
-                                                                            padding: '0.1rem 0.4rem',
+                                                                    .map(s => (
-                                                                            borderRadius: '999px',
+                                                                        <span
-                                                                            background: '#fee2e2',
+                                                                            key={`fixed-s-${s.id}`}
-                                                                            fontSize: '0.8rem',
+                                                                            style={{
-                                                                        }}
+                                                                                padding: '0.1rem 0.4rem',
-                                                                    >
+                                                                                borderRadius: '999px',
-                                                                        {typeof s.name === 'string'
+                                                                                background: '#fee2e2',
-                                                                            ? s.name
+                                                                                fontSize: '0.8rem',
-                                                                            : s.name?.de ?? s.name?.en}
+                                                                            }}
-                                                                    </span>
+                                                                        >
-                                                                ))}
+                                                                            ★{' '}
+                                                                            {typeof s.name === 'string'
+                                                                                ? s.name
+                                                                                : s.name?.de ?? s.name?.en}
+                                                                        </span>
+                                                                    ))}
                                                             </div>
                                                         </div>
                                                     ) : (

app/curator/help/CuratorHelpClient.tsx

@@ -0,0 +1,149 @@
+'use client';
+
+import { useTranslations, useLocale } from 'next-intl';
+import { Link } from '@/lib/navigation';
+
+export default function CuratorHelpClient() {
+    const t = useTranslations('CuratorHelp');
+    const locale = useLocale();
+
+    return (
+        <main style={{ maxWidth: '960px', margin: '2rem auto', padding: '1rem' }}>
+            <header style={{ marginBottom: '2rem' }}>
+                <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
+                    <h1 style={{ fontSize: '1.75rem', marginBottom: '0.25rem' }}>{t('title')}</h1>
+                    <Link
+                        href="/curator"
+                        style={{
+                            padding: '0.5rem 1rem',
+                            background: '#6b7280',
+                            color: 'white',
+                            textDecoration: 'none',
+                            borderRadius: '0.375rem',
+                            fontSize: '0.9rem',
+                        }}
+                    >
+                        {t('backToDashboard')}
+                    </Link>
+                </div>
+            </header>
+
+            <div style={{ display: 'flex', flexDirection: 'column', gap: '2rem' }}>
+                {/* Einführung */}
+                <section>
+                    <h2 style={{ fontSize: '1.5rem', marginBottom: '1rem', borderBottom: '2px solid #e5e7eb', paddingBottom: '0.5rem' }}>
+                        {t('introductionTitle')}
+                    </h2>
+                    <div style={{ fontSize: '0.95rem', lineHeight: '1.7' }}>
+                        <p style={{ marginBottom: '1rem' }}>{t('introductionText')}</p>
+                        <h3 style={{ fontSize: '1.1rem', marginTop: '1.5rem', marginBottom: '0.75rem' }}>{t('permissionsTitle')}</h3>
+                        <ul style={{ marginLeft: '1.5rem', marginBottom: '1rem' }}>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('permission1')}</li>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('permission2')}</li>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('permission3')}</li>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('permission4')}</li>
+                        </ul>
+                        <p style={{ marginTop: '1rem', padding: '0.75rem', background: '#fef3c7', borderRadius: '0.375rem', border: '1px solid #fbbf24' }}>
+                            <strong>{t('note')}:</strong> {t('permissionNote')}
+                        </p>
+                    </div>
+                </section>
+
+                {/* Song-Upload */}
+                <section>
+                    <h2 style={{ fontSize: '1.5rem', marginBottom: '1rem', borderBottom: '2px solid #e5e7eb', paddingBottom: '0.5rem' }}>
+                        {t('uploadTitle')}
+                    </h2>
+                    <div style={{ fontSize: '0.95rem', lineHeight: '1.7' }}>
+                        <h3 style={{ fontSize: '1.1rem', marginTop: '1rem', marginBottom: '0.75rem' }}>{t('uploadStepsTitle')}</h3>
+                        <ol style={{ marginLeft: '1.5rem', marginBottom: '1rem' }}>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('uploadStep1')}</li>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('uploadStep2')}</li>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('uploadStep3')}</li>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('uploadStep4')}</li>
+                        </ol>
+                        <h3 style={{ fontSize: '1.1rem', marginTop: '1.5rem', marginBottom: '0.75rem' }}>{t('uploadBestPracticesTitle')}</h3>
+                        <ul style={{ marginLeft: '1.5rem', marginBottom: '1rem' }}>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('uploadBestPractice1')}</li>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('uploadBestPractice2')}</li>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('uploadBestPractice3')}</li>
+                        </ul>
+                        <p style={{ marginTop: '1rem', padding: '0.75rem', background: '#dbeafe', borderRadius: '0.375rem', border: '1px solid #3b82f6' }}>
+                            <strong>{t('tip')}:</strong> {t('uploadTip')}
+                        </p>
+                    </div>
+                </section>
+
+                {/* Song-Bearbeitung */}
+                <section>
+                    <h2 style={{ fontSize: '1.5rem', marginBottom: '1rem', borderBottom: '2px solid #e5e7eb', paddingBottom: '0.5rem' }}>
+                        {t('editingTitle')}
+                    </h2>
+                    <div style={{ fontSize: '0.95rem', lineHeight: '1.7' }}>
+                        <h3 style={{ fontSize: '1.1rem', marginTop: '1rem', marginBottom: '0.75rem' }}>{t('singleEditTitle')}</h3>
+                        <p style={{ marginBottom: '1rem' }}>{t('singleEditText')}</p>
+                        <h3 style={{ fontSize: '1.1rem', marginTop: '1.5rem', marginBottom: '0.75rem' }}>{t('batchEditTitle')}</h3>
+                        <p style={{ marginBottom: '1rem' }}>{t('batchEditText')}</p>
+                        <ul style={{ marginLeft: '1.5rem', marginBottom: '1rem' }}>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('batchEditFeature1')}</li>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('batchEditFeature2')}</li>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('batchEditFeature3')}</li>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('batchEditFeature4')}</li>
+                        </ul>
+                        <h3 style={{ fontSize: '1.1rem', marginTop: '1.5rem', marginBottom: '0.75rem' }}>{t('genreSpecialAssignmentTitle')}</h3>
+                        <p style={{ marginBottom: '1rem' }}>{t('genreSpecialAssignmentText')}</p>
+                    </div>
+                </section>
+
+                {/* Kommentar-Verwaltung */}
+                <section>
+                    <h2 style={{ fontSize: '1.5rem', marginBottom: '1rem', borderBottom: '2px solid #e5e7eb', paddingBottom: '0.5rem' }}>
+                        {t('commentsTitle')}
+                    </h2>
+                    <div style={{ fontSize: '0.95rem', lineHeight: '1.7' }}>
+                        <p style={{ marginBottom: '1rem' }}>{t('commentsText')}</p>
+                        <h3 style={{ fontSize: '1.1rem', marginTop: '1rem', marginBottom: '0.75rem' }}>{t('commentsActionsTitle')}</h3>
+                        <ul style={{ marginLeft: '1.5rem', marginBottom: '1rem' }}>
+                            <li style={{ marginBottom: '0.5rem' }}><strong>{t('markAsRead')}:</strong> {t('markAsReadText')}</li>
+                            <li style={{ marginBottom: '0.5rem' }}><strong>{t('archive')}:</strong> {t('archiveText')}</li>
+                        </ul>
+                    </div>
+                </section>
+
+                {/* Best Practices */}
+                <section>
+                    <h2 style={{ fontSize: '1.5rem', marginBottom: '1rem', borderBottom: '2px solid #e5e7eb', paddingBottom: '0.5rem' }}>
+                        {t('bestPracticesTitle')}
+                    </h2>
+                    <div style={{ fontSize: '0.95rem', lineHeight: '1.7' }}>
+                        <ul style={{ marginLeft: '1.5rem', marginBottom: '1rem' }}>
+                            <li style={{ marginBottom: '0.75rem' }}>{t('bestPractice1')}</li>
+                            <li style={{ marginBottom: '0.75rem' }}>{t('bestPractice2')}</li>
+                            <li style={{ marginBottom: '0.75rem' }}>{t('bestPractice3')}</li>
+                            <li style={{ marginBottom: '0.75rem' }}>{t('bestPractice4')}</li>
+                            <li style={{ marginBottom: '0.75rem' }}>{t('bestPractice5')}</li>
+                        </ul>
+                    </div>
+                </section>
+
+                {/* Troubleshooting */}
+                <section>
+                    <h2 style={{ fontSize: '1.5rem', marginBottom: '1rem', borderBottom: '2px solid #e5e7eb', paddingBottom: '0.5rem' }}>
+                        {t('troubleshootingTitle')}
+                    </h2>
+                    <div style={{ fontSize: '0.95rem', lineHeight: '1.7' }}>
+                        <h3 style={{ fontSize: '1.1rem', marginTop: '1rem', marginBottom: '0.75rem' }}>{t('troubleshootingQ1')}</h3>
+                        <p style={{ marginBottom: '1rem', marginLeft: '1rem' }}>{t('troubleshootingA1')}</p>
+                        <h3 style={{ fontSize: '1.1rem', marginTop: '1rem', marginBottom: '0.75rem' }}>{t('troubleshootingQ2')}</h3>
+                        <p style={{ marginBottom: '1rem', marginLeft: '1rem' }}>{t('troubleshootingA2')}</p>
+                        <h3 style={{ fontSize: '1.1rem', marginTop: '1rem', marginBottom: '0.75rem' }}>{t('troubleshootingQ3')}</h3>
+                        <p style={{ marginBottom: '1rem', marginLeft: '1rem' }}>{t('troubleshootingA3')}</p>
+                        <h3 style={{ fontSize: '1.1rem', marginTop: '1rem', marginBottom: '0.75rem' }}>{t('troubleshootingQ4')}</h3>
+                        <p style={{ marginBottom: '1rem', marginLeft: '1rem' }}>{t('troubleshootingA4')}</p>
+                    </div>
+                </section>
+            </div>
+        </main>
+    );
+}
+

app/curator/help/page.tsx

@@ -0,0 +1,8 @@
+export const dynamic = 'force-dynamic';
+
+import CuratorHelpClient from './CuratorHelpClient';
+
+export default function CuratorHelpPage() {
+    return <CuratorHelpClient />;
+}
+

components/HelpTooltip.tsx

@@ -0,0 +1,175 @@
+'use client';
+
+import { useState, useRef, useEffect } from 'react';
+import { useTranslations } from 'next-intl';
+
+interface HelpTooltipProps {
+    shortText: string; // Text für Hover
+    longText: string; // Text für Click/Modal
+    position?: 'top' | 'bottom' | 'left' | 'right';
+}
+
+export default function HelpTooltip({ shortText, longText, position = 'top' }: HelpTooltipProps) {
+    const t = useTranslations('CuratorHelp');
+    const [showHover, setShowHover] = useState(false);
+    const [showModal, setShowModal] = useState(false);
+    const tooltipRef = useRef<HTMLDivElement>(null);
+    const buttonRef = useRef<HTMLButtonElement>(null);
+
+    useEffect(() => {
+        function handleClickOutside(event: MouseEvent) {
+            if (
+                tooltipRef.current &&
+                !tooltipRef.current.contains(event.target as Node) &&
+                buttonRef.current &&
+                !buttonRef.current.contains(event.target as Node)
+            ) {
+                setShowModal(false);
+            }
+        }
+
+        if (showModal) {
+            document.addEventListener('mousedown', handleClickOutside);
+            return () => {
+                document.removeEventListener('mousedown', handleClickOutside);
+            };
+        }
+    }, [showModal]);
+
+    const positionStyles = {
+        top: { bottom: '100%', left: '50%', transform: 'translateX(-50%)', marginBottom: '0.5rem' },
+        bottom: { top: '100%', left: '50%', transform: 'translateX(-50%)', marginTop: '0.5rem' },
+        left: { right: '100%', top: '50%', transform: 'translateY(-50%)', marginRight: '0.5rem' },
+        right: { left: '100%', top: '50%', transform: 'translateY(-50%)', marginLeft: '0.5rem' },
+    };
+
+    return (
+        <div style={{ position: 'relative', display: 'inline-block' }}>
+            <button
+                ref={buttonRef}
+                type="button"
+                onClick={() => setShowModal(!showModal)}
+                onMouseEnter={() => setShowHover(true)}
+                onMouseLeave={() => setShowHover(false)}
+                style={{
+                    background: 'none',
+                    border: 'none',
+                    cursor: 'pointer',
+                    color: '#6b7280',
+                    fontSize: '1rem',
+                    padding: '0.25rem',
+                    display: 'inline-flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    borderRadius: '50%',
+                    width: '1.5rem',
+                    height: '1.5rem',
+                    transition: 'background-color 0.2s',
+                }}
+                onMouseOver={(e) => {
+                    e.currentTarget.style.backgroundColor = '#f3f4f6';
+                }}
+                onMouseOut={(e) => {
+                    e.currentTarget.style.backgroundColor = 'transparent';
+                }}
+                aria-label="Help"
+            >
+                ℹ
+            </button>
+
+            {/* Hover Tooltip */}
+            {showHover && !showModal && (
+                <div
+                    ref={tooltipRef}
+                    style={{
+                        position: 'absolute',
+                        ...positionStyles[position],
+                        background: '#1f2937',
+                        color: 'white',
+                        padding: '0.5rem 0.75rem',
+                        borderRadius: '0.375rem',
+                        fontSize: '0.875rem',
+                        whiteSpace: 'normal',
+                        zIndex: 1000,
+                        pointerEvents: 'none',
+                        maxWidth: '250px',
+                    }}
+                >
+                    {shortText}
+                    <div
+                        style={{
+                            position: 'absolute',
+                            ...(position === 'top' && { top: '100%', left: '50%', transform: 'translateX(-50%)', borderLeft: '6px solid transparent', borderRight: '6px solid transparent', borderTop: '6px solid #1f2937' }),
+                            ...(position === 'bottom' && { bottom: '100%', left: '50%', transform: 'translateX(-50%)', borderLeft: '6px solid transparent', borderRight: '6px solid transparent', borderBottom: '6px solid #1f2937' }),
+                            ...(position === 'left' && { left: '100%', top: '50%', transform: 'translateY(-50%)', borderTop: '6px solid transparent', borderBottom: '6px solid transparent', borderLeft: '6px solid #1f2937' }),
+                            ...(position === 'right' && { right: '100%', top: '50%', transform: 'translateY(-50%)', borderTop: '6px solid transparent', borderBottom: '6px solid transparent', borderRight: '6px solid #1f2937' }),
+                        }}
+                    />
+                </div>
+            )}
+
+            {/* Modal für detaillierte Informationen */}
+            {showModal && (
+                <>
+                    {/* Overlay */}
+                    <div
+                        style={{
+                            position: 'fixed',
+                            top: 0,
+                            left: 0,
+                            right: 0,
+                            bottom: 0,
+                            background: 'rgba(0, 0, 0, 0.5)',
+                            zIndex: 9998,
+                        }}
+                        onClick={() => setShowModal(false)}
+                    />
+                    {/* Modal Content */}
+                    <div
+                        ref={tooltipRef}
+                        style={{
+                            position: 'fixed',
+                            top: '50%',
+                            left: '50%',
+                            transform: 'translate(-50%, -50%)',
+                            background: 'white',
+                            padding: '1.5rem',
+                            borderRadius: '0.5rem',
+                            boxShadow: '0 10px 25px rgba(0, 0, 0, 0.2)',
+                            maxWidth: '500px',
+                            width: '90%',
+                            maxHeight: '80vh',
+                            overflowY: 'auto',
+                            zIndex: 9999,
+                        }}
+                        onClick={(e) => e.stopPropagation()}
+                    >
+                        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'start', marginBottom: '1rem' }}>
+                            <h3 style={{ margin: 0, fontSize: '1.25rem', fontWeight: 'bold' }}>{t('modalTitle')}</h3>
+                            <button
+                                type="button"
+                                onClick={() => setShowModal(false)}
+                                style={{
+                                    background: 'none',
+                                    border: 'none',
+                                    fontSize: '1.5rem',
+                                    cursor: 'pointer',
+                                    color: '#6b7280',
+                                    padding: '0',
+                                    lineHeight: '1',
+                                }}
+                                aria-label="Close"
+                            >
+                                ×
+                            </button>
+                        </div>
+                        <div style={{ fontSize: '0.9rem', lineHeight: '1.6', whiteSpace: 'pre-wrap' }}>
+                            {longText}
+                        </div>
+                    </div>
+                </>
+            )}
+        </div>
+    );
+}
+

messages/de.json

@@ -252,7 +252,109 @@
       "archiveComment": "Archivieren",
       "archiveCommentConfirm": "Möchtest du diesen Kommentar wirklich archivieren?",
       "archiveCommentError": "Fehler beim Archivieren des Kommentars.",
-      "newComments": "neu"
+      "newComments": "neu",
+      "batchEditTitle": "Batch-Bearbeitung",
+      "clearSelection": "Auswahl aufheben",
+      "batchToggleGenres": "Genres umschalten",
+      "batchToggleSpecials": "Specials umschalten",
+      "batchChangeArtist": "Artist ändern",
+      "batchArtistPlaceholder": "Neuen Artist-Namen eingeben",
+      "batchExcludeGlobal": "Von Global ausschließen",
+      "batchNoChange": "Keine Änderung",
+      "batchExclude": "Ausschließen",
+      "batchInclude": "Einschließen",
+      "batchUpdating": "Aktualisiere...",
+      "batchApply": "Änderungen anwenden",
+      "selectAll": "Alle auswählen",
+      "selectSong": "Titel auswählen",
+      "cannotEditSong": "Dieser Titel kann nicht bearbeitet werden",
+      "noSongsSelected": "Keine Titel ausgewählt",
+      "noBatchOperations": "Keine Batch-Operationen angegeben",
+      "batchUpdateSuccess": "Erfolgreich {success} von {processed} Titeln aktualisiert",
+      "batchUpdateError": "Fehler: {error}",
+      "batchUpdateNetworkError": "Netzwerkfehler bei der Batch-Aktualisierung"
+    },
+    "CuratorHelp": {
+      "title": "Kurator-Hilfe & Handbuch",
+      "backToDashboard": "Zurück zum Dashboard",
+      "helpButton": "Hilfe",
+      "modalTitle": "Hilfe",
+      "introductionTitle": "Einführung",
+      "introductionText": "Als Kurator bist du verantwortlich für die Verwaltung von Songs in deinen zugewiesenen Genres und Specials. Dieses Dashboard ermöglicht es dir, Musik für das Hördle-Spiel hochzuladen, zu bearbeiten und zu organisieren.",
+      "permissionsTitle": "Deine Berechtigungen",
+      "permission1": "MP3-Dateien hochladen und deinen Genres zuordnen",
+      "permission2": "Songs bearbeiten, die mindestens einem deiner Genres oder Specials zugeordnet sind",
+      "permission3": "Songs löschen, die ausschließlich deinen Genres/Specials zugeordnet sind",
+      "permission4": "Kommentare von Spielern zu deinen Rätseln einsehen und verwalten",
+      "note": "Hinweis",
+      "permissionNote": "Du kannst nur Songs bearbeiten oder löschen, die deinen Genres/Specials zugeordnet sind. Songs, die anderen Kuratoren zugeordnet sind, kannst du nicht ändern.",
+      "uploadTitle": "Songs hochladen",
+      "uploadStepsTitle": "Schritt-für-Schritt-Anleitung",
+      "uploadStep1": "MP3-Dateien in den Upload-Bereich ziehen oder klicken, um Dateien auszuwählen",
+      "uploadStep2": "Ein oder mehrere Genres auswählen, um sie den hochgeladenen Songs zuzuordnen",
+      "uploadStep3": "Auf 'Upload starten' klicken, um den Upload-Prozess zu beginnen",
+      "uploadStep4": "Das System extrahiert automatisch Metadaten (Titel, Artist, Erscheinungsjahr) aus den Dateien",
+      "uploadBestPracticesTitle": "Best Practices",
+      "uploadBestPractice1": "Stelle sicher, dass MP3-Dateien korrekte ID3-Tags (Titel, Artist) für die automatische Metadaten-Extraktion haben",
+      "uploadBestPractice2": "Passende Genres vor dem Upload auswählen, um spätere manuelle Zuordnung zu vermeiden",
+      "uploadBestPractice3": "Vor dem Upload auf Duplikate prüfen - das System warnt dich, wenn ein Song bereits existiert",
+      "tip": "Tipp",
+      "uploadTip": "Alle von Kuratoren hochgeladenen Songs werden automatisch von der globalen Playlist ausgeschlossen. Nur Admins können diese Einstellung ändern.",
+      "editingTitle": "Songs bearbeiten",
+      "singleEditTitle": "Einzelne Song-Bearbeitung",
+      "singleEditText": "Klicke auf den Bearbeiten-Button (✏️) neben einem Song, um Titel, Artist, Erscheinungsjahr, Genres, Specials oder das Exclude-Global-Flag zu ändern. Nur Songs, die du bearbeiten kannst, haben einen aktiven Bearbeiten-Button.",
+      "batchEditTitle": "Batch-Bearbeitung",
+      "batchEditText": "Wähle mehrere Songs über die Checkboxen aus, dann nutze die Batch-Bearbeitungs-Toolbar, um Änderungen auf alle ausgewählten Songs gleichzeitig anzuwenden:",
+      "batchEditFeature1": "Genre Toggle: Genres zu allen ausgewählten Songs hinzufügen oder entfernen",
+      "batchEditFeature2": "Special Toggle: Specials zu allen ausgewählten Songs hinzufügen oder entfernen",
+      "batchEditFeature3": "Artist ändern: Gleichen Artist-Namen für alle ausgewählten Songs setzen",
+      "batchEditFeature4": "Exclude Global Flag: Exclude-Global-Flag setzen oder entfernen (nur Global-Kuratoren)",
+      "genreSpecialAssignmentTitle": "Genre & Special Zuordnung",
+      "genreSpecialAssignmentText": "Du kannst Songs nur Genres und Specials zuordnen, für die du verantwortlich bist. Songs können mehrere Genres und Specials haben. Beim Bearbeiten kannst du Zuordnungen umschalten - wenn ein Genre/Special bereits zugeordnet ist, wird es entfernt; wenn nicht, wird es hinzugefügt.",
+      "commentsTitle": "Kommentare verwalten",
+      "commentsText": "Spieler können dir Feedback zu Rätseln in deinen Genres oder Specials senden. Kommentare erscheinen in deinem Dashboard mit einem Badge für ungelesene Nachrichten.",
+      "commentsActionsTitle": "Verfügbare Aktionen",
+      "markAsRead": "Als gelesen markieren",
+      "markAsReadText": "Klicke auf einen Kommentar, um ihn als gelesen zu markieren. Gelesene Kommentare werden mit einem grauen Rahmen angezeigt.",
+      "archive": "Archivieren",
+      "archiveText": "Archiviere Kommentare, die du nicht mehr benötigst. Archivierte Kommentare werden aus deiner Ansicht entfernt.",
+      "bestPracticesTitle": "Best Practices für Kuratoren",
+      "bestPractice1": "Metadaten korrekt halten: Stelle sicher, dass Song-Titel und Artist-Namen korrekt und konsistent sind",
+      "bestPractice2": "Passende Genres verwenden: Ordne Songs den relevantesten Genres zu, um Spielern zu helfen, Musik zu entdecken",
+      "bestPractice3": "Auf Kommentare reagieren: Prüfe Kommentare regelmäßig und berücksichtige Spieler-Feedback beim Kuratieren",
+      "bestPractice4": "Qualität wahren: Überprüfe hochgeladene Songs auf Audio-Qualität und Metadaten-Genauigkeit",
+      "bestPractice5": "Batch-Bearbeitung effizient nutzen: Wenn du ähnliche Änderungen an mehreren Songs vornehmen musst, nutze die Batch-Bearbeitung, um Zeit zu sparen",
+      "troubleshootingTitle": "Troubleshooting",
+      "troubleshootingQ1": "Warum kann ich einen Song nicht bearbeiten?",
+      "troubleshootingA1": "Du kannst nur Songs bearbeiten, die mindestens einem deiner Genres oder Specials zugeordnet sind. Wenn ein Song keine Genres/Specials zugeordnet hat, kannst du ihn bearbeiten. Wenn er nur anderen Kuratoren zugeordnet ist, kannst du ihn nicht bearbeiten.",
+      "troubleshootingQ2": "Warum kann ich einen Song nicht löschen?",
+      "troubleshootingA2": "Du kannst nur Songs löschen, die ausschließlich deinen Genres/Specials zugeordnet sind. Wenn ein Song Genres oder Specials hat, die anderen Kuratoren zugeordnet sind, kannst du ihn nicht löschen.",
+      "troubleshootingQ3": "Warum kann ich ein Genre/Special nicht zuordnen?",
+      "troubleshootingA3": "Du kannst Songs nur Genres und Specials zuordnen, für die du verantwortlich bist. Wende dich an den Admin, wenn du Zugriff auf zusätzliche Genres oder Specials benötigst.",
+      "troubleshootingQ4": "Warum ist die Exclude-Global-Checkbox deaktiviert?",
+      "troubleshootingA4": "Nur Global-Kuratoren können das Exclude-Global-Flag ändern. Wenn du diese Berechtigung benötigst, wende dich an den Admin.",
+      "tooltipDashboardShort": "Übersicht über dein Kuratoren-Dashboard",
+      "tooltipDashboardLong": "Dies ist dein Haupt-Dashboard, wo du Songs hochladen, deine Track-Liste verwalten und Kommentare von Spielern einsehen kannst. Nutze den Hilfe-Button (❓), um auf das vollständige Handbuch zuzugreifen.",
+      "tooltipUploadShort": "MP3-Dateien zu deinen Genres hochladen",
+      "tooltipUploadLong": "Ziehe MP3-Dateien per Drag & Drop oder klicke, um sie auszuwählen. Das System extrahiert automatisch Metadaten (Titel, Artist, Erscheinungsjahr) aus ID3-Tags. Wähle Genres vor dem Upload aus, um Songs automatisch zuzuordnen. Alle Kuratoren-Uploads sind standardmäßig von der globalen Playlist ausgeschlossen.",
+      "tooltipGenreAssignmentShort": "Genres zu hochgeladenen Songs zuordnen",
+      "tooltipGenreAssignmentLong": "Wähle ein oder mehrere Genres vor dem Upload aus. Die ausgewählten Genres werden allen erfolgreich hochgeladenen Songs zugeordnet. Du kannst nur Genres zuordnen, für die du verantwortlich bist. Wenn du keine Genres auswählst, kannst du sie später durch Bearbeitung der Songs zuordnen.",
+      "tooltipTracklistShort": "Deine Songs verwalten",
+      "tooltipTracklistLong": "Diese Tabelle zeigt alle Songs in deinen Genres und Specials. Du kannst suchen, filtern, sortieren und Songs bearbeiten. Nutze die Checkboxen, um mehrere Songs für die Batch-Bearbeitung auszuwählen. Nur Songs, die du bearbeiten kannst, haben eine aktive Checkbox.",
+      "tooltipSearchShort": "Nach Titel oder Artist suchen",
+      "tooltipSearchLong": "Tippe in das Suchfeld, um Songs nach Titel oder Artist-Namen zu filtern. Die Suche ist nicht case-sensitive und findet Teiltexte. Leere das Suchfeld, um alle Songs wieder anzuzeigen.",
+      "tooltipFilterShort": "Nach Genre, Special oder Global-Flag filtern",
+      "tooltipFilterLong": "Nutze das Filter-Dropdown, um nur Songs aus einem bestimmten Genre, Special oder Songs, die von der globalen Playlist ausgeschlossen sind, anzuzeigen. Kombiniere mit der Suche für präzisere Filterung.",
+      "tooltipBatchEditShort": "Mehrere Songs gleichzeitig bearbeiten",
+      "tooltipBatchEditLong": "Wähle mehrere Songs über Checkboxen aus, dann nutze die Batch-Bearbeitungs-Toolbar, um Änderungen auf alle ausgewählten Songs gleichzeitig anzuwenden. Du kannst Genres/Specials umschalten, Artist-Namen ändern oder das Exclude-Global-Flag ändern (nur Global-Kuratoren).",
+      "tooltipBatchGenreToggleShort": "Genres hinzufügen oder entfernen",
+      "tooltipBatchGenreToggleLong": "Wähle Genres zum Umschalten aus. Wenn ein ausgewählter Song das Genre bereits hat, wird es entfernt. Wenn nicht, wird es hinzugefügt. Dies ermöglicht es dir, schnell Genres zu mehreren Songs hinzuzufügen oder zu entfernen.",
+      "tooltipBatchSpecialToggleShort": "Specials hinzufügen oder entfernen",
+      "tooltipBatchSpecialToggleLong": "Wähle Specials zum Umschalten aus. Wenn ein ausgewählter Song das Special bereits hat, wird es entfernt. Wenn nicht, wird es hinzugefügt. Du kannst nur Specials umschalten, für die du verantwortlich bist.",
+      "tooltipBatchArtistShort": "Artist für alle ausgewählten Songs ändern",
+      "tooltipBatchArtistLong": "Gib einen neuen Artist-Namen ein, um ihn für alle ausgewählten Songs zu setzen. Dies ist nützlich, um Artist-Namen zu korrigieren oder Namenskonventionen über mehrere Songs hinweg zu standardisieren.",
+      "tooltipCommentsShort": "Spieler-Feedback und Kommentare",
+      "tooltipCommentsLong": "Spieler können dir Nachrichten zu Rätseln in deinen Genres oder Specials senden. Ungelesene Kommentare sind mit einem blauen Rahmen und Badge hervorgehoben. Klicke auf einen Kommentar, um ihn als gelesen zu markieren, oder archiviere ihn, wenn du ihn nicht mehr benötigst."
     },
     "About": {
     "title": "Über Hördle & Impressum",

messages/en.json

@@ -252,7 +252,109 @@
       "archiveComment": "Archive",
       "archiveCommentConfirm": "Do you really want to archive this comment?",
       "archiveCommentError": "Error archiving comment.",
-      "newComments": "new"
+      "newComments": "new",
+      "batchEditTitle": "Batch Edit",
+      "clearSelection": "Clear Selection",
+      "batchToggleGenres": "Toggle Genres",
+      "batchToggleSpecials": "Toggle Specials",
+      "batchChangeArtist": "Change Artist",
+      "batchArtistPlaceholder": "Enter new artist name",
+      "batchExcludeGlobal": "Exclude from Global",
+      "batchNoChange": "No change",
+      "batchExclude": "Exclude",
+      "batchInclude": "Include",
+      "batchUpdating": "Updating...",
+      "batchApply": "Apply Changes",
+      "selectAll": "Select all",
+      "selectSong": "Select song",
+      "cannotEditSong": "Cannot edit this song",
+      "noSongsSelected": "No songs selected",
+      "noBatchOperations": "No batch operations specified",
+      "batchUpdateSuccess": "Successfully updated {success} of {processed} songs",
+      "batchUpdateError": "Error: {error}",
+      "batchUpdateNetworkError": "Network error during batch update"
+    },
+    "CuratorHelp": {
+      "title": "Curator Help & Manual",
+      "backToDashboard": "Back to Dashboard",
+      "helpButton": "Help",
+      "modalTitle": "Help",
+      "introductionTitle": "Introduction",
+      "introductionText": "As a curator, you are responsible for managing songs within your assigned genres and specials. This dashboard allows you to upload, edit, and organize music for the Hördle game.",
+      "permissionsTitle": "Your Permissions",
+      "permission1": "Upload MP3 files and assign them to your genres",
+      "permission2": "Edit songs that are assigned to at least one of your genres or specials",
+      "permission3": "Delete songs that are exclusively assigned to your genres/specials",
+      "permission4": "View and manage comments from players about your puzzles",
+      "note": "Note",
+      "permissionNote": "You can only edit or delete songs that are assigned to your genres/specials. Songs assigned to other curators' genres cannot be modified by you.",
+      "uploadTitle": "Uploading Songs",
+      "uploadStepsTitle": "Step-by-Step Guide",
+      "uploadStep1": "Drag MP3 files into the upload area or click to select files",
+      "uploadStep2": "Select one or more genres to assign to the uploaded songs",
+      "uploadStep3": "Click 'Start upload' to begin the upload process",
+      "uploadStep4": "The system will automatically extract metadata (title, artist, release year) from the files",
+      "uploadBestPracticesTitle": "Best Practices",
+      "uploadBestPractice1": "Ensure MP3 files have correct ID3 tags (title, artist) for automatic metadata extraction",
+      "uploadBestPractice2": "Select appropriate genres before uploading to avoid manual assignment later",
+      "uploadBestPractice3": "Check for duplicates before uploading - the system will warn you if a song already exists",
+      "tip": "Tip",
+      "uploadTip": "All songs uploaded by curators are automatically excluded from the global playlist. Only admins can change this setting.",
+      "editingTitle": "Editing Songs",
+      "singleEditTitle": "Single Song Editing",
+      "singleEditText": "Click the edit button (✏️) next to a song to modify its title, artist, release year, genres, specials, or exclude-from-global flag. Only songs you can edit will have an active edit button.",
+      "batchEditTitle": "Batch Editing",
+      "batchEditText": "Select multiple songs using the checkboxes, then use the batch edit toolbar to apply changes to all selected songs at once:",
+      "batchEditFeature1": "Genre Toggle: Add or remove genres from all selected songs",
+      "batchEditFeature2": "Special Toggle: Add or remove specials from all selected songs",
+      "batchEditFeature3": "Artist Change: Set the same artist name for all selected songs",
+      "batchEditFeature4": "Exclude Global Flag: Set or remove the exclude-from-global flag (Global Curators only)",
+      "genreSpecialAssignmentTitle": "Genre & Special Assignment",
+      "genreSpecialAssignmentText": "You can only assign songs to genres and specials that you are responsible for. Songs can have multiple genres and specials. When editing, you can toggle assignments - if a genre/special is already assigned, it will be removed; if not, it will be added.",
+      "commentsTitle": "Managing Comments",
+      "commentsText": "Players can send you feedback about puzzles in your genres or specials. Comments appear in your dashboard with a badge showing unread messages.",
+      "commentsActionsTitle": "Available Actions",
+      "markAsRead": "Mark as Read",
+      "markAsReadText": "Click on a comment to mark it as read. Read comments are displayed with a gray border.",
+      "archive": "Archive",
+      "archiveText": "Archive comments you no longer need. Archived comments are removed from your view.",
+      "bestPracticesTitle": "Best Practices for Curators",
+      "bestPractice1": "Keep metadata accurate: Ensure song titles and artist names are correct and consistent",
+      "bestPractice2": "Use appropriate genres: Assign songs to the most relevant genres to help players discover music",
+      "bestPractice3": "Respond to comments: Check comments regularly and consider player feedback when curating",
+      "bestPractice4": "Maintain quality: Review uploaded songs for audio quality and metadata accuracy",
+      "bestPractice5": "Use batch editing efficiently: When making similar changes to multiple songs, use batch edit to save time",
+      "troubleshootingTitle": "Troubleshooting",
+      "troubleshootingQ1": "Why can't I edit a song?",
+      "troubleshootingA1": "You can only edit songs that are assigned to at least one of your genres or specials. If a song has no genres/specials assigned, you can edit it. If it's assigned to other curators' genres only, you cannot edit it.",
+      "troubleshootingQ2": "Why can't I delete a song?",
+      "troubleshootingA2": "You can only delete songs that are exclusively assigned to your genres/specials. If a song has any genres or specials assigned to other curators, you cannot delete it.",
+      "troubleshootingQ3": "Why can't I assign a genre/special?",
+      "troubleshootingA3": "You can only assign songs to genres and specials that you are responsible for. Contact the admin if you need access to additional genres or specials.",
+      "troubleshootingQ4": "Why is the exclude-from-global checkbox disabled?",
+      "troubleshootingA4": "Only Global Curators can change the exclude-from-global flag. If you need this permission, contact the admin.",
+      "tooltipDashboardShort": "Overview of your curator dashboard",
+      "tooltipDashboardLong": "This is your main dashboard where you can upload songs, manage your track list, and view comments from players. Use the help button (❓) to access the full manual.",
+      "tooltipUploadShort": "Upload MP3 files to your genres",
+      "tooltipUploadLong": "Drag and drop MP3 files or click to select. The system will automatically extract metadata (title, artist, release year) from ID3 tags. Select genres before uploading to automatically assign songs. All curator uploads are excluded from the global playlist by default.",
+      "tooltipGenreAssignmentShort": "Assign genres to uploaded songs",
+      "tooltipGenreAssignmentLong": "Select one or more genres before uploading. The selected genres will be assigned to all successfully uploaded songs. You can only assign genres that you are responsible for. If you don't select any genres, you can assign them later by editing the songs.",
+      "tooltipTracklistShort": "Manage your songs",
+      "tooltipTracklistLong": "This table shows all songs in your genres and specials. You can search, filter, sort, and edit songs. Use the checkboxes to select multiple songs for batch editing. Only songs you can edit will have an active checkbox.",
+      "tooltipSearchShort": "Search by title or artist",
+      "tooltipSearchLong": "Type in the search box to filter songs by title or artist name. The search is case-insensitive and matches partial text. Clear the search to show all songs again.",
+      "tooltipFilterShort": "Filter by genre, special, or global flag",
+      "tooltipFilterLong": "Use the filter dropdown to show only songs from a specific genre, special, or songs excluded from the global playlist. Combine with search for more precise filtering.",
+      "tooltipBatchEditShort": "Edit multiple songs at once",
+      "tooltipBatchEditLong": "Select multiple songs using checkboxes, then use the batch edit toolbar to apply changes to all selected songs simultaneously. You can toggle genres/specials, change artist names, or modify the exclude-from-global flag (Global Curators only).",
+      "tooltipBatchGenreToggleShort": "Add or remove genres",
+      "tooltipBatchGenreToggleLong": "Select genres to toggle. If a selected song already has the genre, it will be removed. If it doesn't have the genre, it will be added. This allows you to quickly add or remove genres from multiple songs at once.",
+      "tooltipBatchSpecialToggleShort": "Add or remove specials",
+      "tooltipBatchSpecialToggleLong": "Select specials to toggle. If a selected song already has the special, it will be removed. If it doesn't have the special, it will be added. You can only toggle specials you are responsible for.",
+      "tooltipBatchArtistShort": "Change artist for all selected songs",
+      "tooltipBatchArtistLong": "Enter a new artist name to set it for all selected songs. This is useful for correcting artist names or standardizing naming conventions across multiple songs.",
+      "tooltipCommentsShort": "Player feedback and comments",
+      "tooltipCommentsLong": "Players can send you messages about puzzles in your genres or specials. Unread comments are highlighted with a blue border and badge. Click on a comment to mark it as read, or archive it if you no longer need it."
     },
   "About": {
     "title": "About Hördle & Imprint",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hoerdle",
-  "version": "0.1.6.0",
+  "version": "0.1.6.2",
   "private": true,
   "scripts": {
     "dev": "next dev",