function switchAdminTab(tabName) {
    ['users', 'payouts', 'actions', 'stats', 'banner', 'changelog'].forEach(t => {
        const tabEl = document.getElementById(`admin-tab-${t}`);
        const btnEl = document.getElementById(`admin-tab-${t}-btn`);
        if (tabEl) tabEl.classList.add('hidden');
        if (btnEl) {
            btnEl.classList.remove('bg-indigo-600', 'text-white');
            btnEl.classList.add('text-slate-400');
        }
    });
    const currentTab = document.getElementById(`admin-tab-${tabName}`);
    const currentBtn = document.getElementById(`admin-tab-${tabName}-btn`);
    if (currentTab) currentTab.classList.remove('hidden');
    if (currentBtn) {
        currentBtn.classList.add('bg-indigo-600', 'text-white');
        currentBtn.classList.remove('text-slate-400');
    }

    if (tabName === 'payouts') {
        loadAdminApprovalTasks();
        loadAdminTaskCatalog();
        loadAdminPayouts();
    }
    if (tabName === 'stats') loadAdminStats();
    if (tabName === 'changelog') loadAdminChangelogView();
}

async function undoActivityLog(logId, roomName, actionText) {
    if (!isAdmin()) return;

    if (!confirm(`Möchtest du diese Aktion wirklich rückgängig machen?\n\n"${actionText}"`)) return;

    if (actionText.includes('als erledigt') || actionText.includes('erledigt')) {
        const room = allRoomsData.find(r => r.room_number === roomName);
        if (room && room.tasks) {
            const match = actionText.match(/"([^"]+)"/);
            const taskName = match ? match[1] : null;

            const task = room.tasks.find(t => taskName ? t.task_name === taskName : t.is_completed);
            if (task) {
                await supabaseClient.from('tasks').update({
                    is_completed: false,
                    is_approved: false,
                    is_paid: false,
                    paid_amount: 0,
                    paid_at: null
                }).eq('id', task.id);

                task.is_completed = false;
                task.is_approved = false;
                task.is_paid = false;
                task.paid_amount = 0;
                task.paid_at = null;
            }
        }
    } 
    else if (actionText.includes('ausbezahlt')) {
        const match = actionText.match(/an ([^ ]+)/);
        if (match) {
            const alias = match[1];
            const profile = allProfiles.find(p => p.alias === alias);
            if (profile) {
                const paidTasks = [];
                allRoomsData.forEach(r => {
                    if (r.tasks) {
                        r.tasks.forEach(t => {
                            if (t.assigned_to === profile.id && (t.is_paid || (t.paid_amount && t.paid_amount > 0))) {
                                paidTasks.push(t.id);
                            }
                        });
                    }
                });

                if (paidTasks.length > 0) {
                    await supabaseClient.from('tasks').update({ is_paid: false, paid_amount: 0, paid_at: null }).in('id', paidTasks);
                    allRoomsData.forEach(r => {
                        if (r.tasks) {
                            r.tasks.forEach(t => {
                                if (paidTasks.includes(t.id)) {
                                    t.is_paid = false;
                                    t.paid_amount = 0;
                                    t.paid_at = null;
                                }
                            });
                        }
                    });
                }
            }
        }
    }

    await supabaseClient.from('activity_logs').delete().eq('id', logId);
    logActivity(null, `[ADMIN UNDO] hat die Aktion "${actionText}" rückgängig gemacht`);

    loadRooms();
    loadAdminPayouts();
    loadAdminApprovalTasks();
    fetchGlobalActivityLog();
    alert('Aktion wurde erfolgreich rückgängig gemacht!');
}

async function publishChangelog() {
    if (!isAdmin()) return;
    const version = document.getElementById('admin-changelog-version').value.trim();
    const content = document.getElementById('admin-changelog-content').value.trim();

    if (!version || !content) {
        alert('Bitte gib eine Versionsnummer und den Inhalt des Changelogs ein.');
        return;
    }

    const { error } = await supabaseClient.from('activity_logs').insert([{
        user_alias: 'CHANGELOG_UPDATE',
        room_name: version,
        action_text: content
    }]);

    if (!error) {
        alert(`Changelog für Version ${version} wurde erfolgreich veröffentlicht!`);
        document.getElementById('admin-changelog-version').value = '';
        document.getElementById('admin-changelog-content').value = '';
        fetchLatestChangelog();
        loadAdminChangelogView();
    } else {
        alert('Fehler beim Veröffentlichen des Changelogs.');
    }
}

async function loadAdminChangelogView() {
    const container = document.getElementById('admin-changelog-history');
    if (!container) return;
    container.innerHTML = '<p class="text-xs text-slate-500 italic">Lade Changelogs...</p>';

    const { data } = await supabaseClient
        .from('activity_logs')
        .select('*')
        .eq('user_alias', 'CHANGELOG_UPDATE')
        .order('created_at', { ascending: false });

    if (!data || data.length === 0) {
        container.innerHTML = '<p class="text-xs text-slate-500 italic">Noch keine Changelogs veröffentlicht.</p>';
        return;
    }

    container.innerHTML = '';
    data.forEach(item => {
        const dateStr = new Date(item.created_at).toLocaleDateString('de-DE');
        const div = document.createElement('div');
        div.className = "bg-slate-900 border border-slate-700/80 p-3 rounded-xl space-y-1 text-xs";
        div.innerHTML = `
            <div class="flex justify-between items-center border-b border-slate-800 pb-1">
                <span class="font-bold text-indigo-400">Version ${item.room_name}</span>
                <span class="text-[10px] text-slate-500">${dateStr}</span>
            </div>
            <div class="text-slate-300 whitespace-pre-line mt-1">${item.action_text}</div>
        `;
        container.appendChild(div);
    });
}

async function openAdminUsersModal() {
    if (!isAdmin()) return;

    switchAdminTab('users');
    document.getElementById('admin-users-modal').classList.remove('hidden');

    const tbody = document.getElementById('admin-users-table-body');
    tbody.innerHTML = '<tr><td colspan="5" class="p-4 text-center text-slate-500 italic">Nutzer werden geladen...</td></tr>';

    const { data: profiles, error } = await supabaseClient.from('profiles').select('*');

    if (error || !profiles) {
        tbody.innerHTML = '<tr><td colspan="5" class="p-4 text-center text-red-400">Fehler beim Laden der Nutzerliste.</td></tr>';
        return;
    }

    tbody.innerHTML = '';
    const now = new Date();

    profiles.forEach(p => {
        const tr = document.createElement('tr');
        tr.className = "hover:bg-slate-800/50 transition";

        const lastSeenDate = p.last_seen ? new Date(p.last_seen) : null;
        const isOnline = lastSeenDate && (now - lastSeenDate < 2 * 60 * 1000);

        const statusBadge = isOnline 
            ? '<span class="inline-flex items-center gap-1 bg-emerald-500/20 text-emerald-400 border border-emerald-500/30 px-2 py-0.5 rounded text-[10px] font-bold"><span class="w-1.5 h-1.5 rounded-full bg-emerald-400 animate-pulse"></span> Online</span>'
            : '<span class="inline-flex items-center bg-slate-800 text-slate-500 border border-slate-700 px-2 py-0.5 rounded text-[10px]">Offline</span>';

        const lastSeenText = lastSeenDate 
            ? lastSeenDate.toLocaleDateString('de-DE') + ' ' + lastSeenDate.toLocaleTimeString('de-DE', { hour: '2-digit', minute: '2-digit' })
            : 'Nie';

        const isThisAdmin = (p.id === currentUser.id) || (p.email && p.email.toLowerCase() === ADMIN_EMAIL.toLowerCase());

        let actionBtn = '';
        if (!isThisAdmin) {
            if (p.is_disabled) {
                actionBtn = `<button onclick="toggleUserAccess('${p.id}', false)" class="bg-emerald-600/20 text-emerald-300 border border-emerald-500/30 px-2.5 py-1 rounded text-[10px] font-bold hover:bg-emerald-600/40">Entsperren</button>`;
            } else {
                actionBtn = `<button onclick="toggleUserAccess('${p.id}', true)" class="bg-red-600/20 text-red-300 border border-red-500/30 px-2.5 py-1 rounded text-[10px] font-bold hover:bg-red-600/40">Sperren</button>`;
            }
        } else {
            actionBtn = '<span class="text-[10px] text-purple-400 font-bold">Admin</span>';
        }

        tr.innerHTML = `
            <td class="p-3">${statusBadge}</td>
            <td class="p-3 font-semibold text-white flex items-center gap-2">${p.alias || 'Kein Name'}</td>
            <td class="p-3 text-slate-300 font-mono">${p.email || 'Registrierter Nutzer'}</td>
            <td class="p-3 text-slate-400">${lastSeenText}</td>
            <td class="p-3 text-right">${actionBtn}</td>
        `;
        tbody.appendChild(tr);
    });
}

function loadAdminApprovalTasks() {
    const container = document.getElementById('admin-approval-tasks-container');
    container.innerHTML = '';

    const pendingTasks = [];

    allRoomsData.forEach(r => {
        if (r.tasks) {
            r.tasks.forEach(t => {
                if (t.is_completed && !t.is_approved) {
                    let assignedName = "👥 Alle / Nicht zugewiesen";
                    if (t.assigned_to) {
                        const prof = allProfiles.find(p => p.id === t.assigned_to);
                        if (prof && prof.alias) assignedName = `👤 ${prof.alias}`;
                    }
                    pendingTasks.push({ ...t, roomNumber: r.room_number, assignedName });
                }
            });
        }
    });

    if (pendingTasks.length === 0) {
        container.innerHTML = '<p class="text-xs text-slate-500 italic">Keine unüberprüften Aufgaben vorhanden. Alle erledigten Aufgaben sind freigegeben!</p>';
        return;
    }

    pendingTasks.forEach(t => {
        const item = document.createElement('div');
        item.className = "flex items-center justify-between bg-slate-800 border border-amber-500/30 p-2.5 rounded-lg text-xs gap-2";
        const amount = parseFloat(t.reward_amount || 0);

        item.innerHTML = `
            <div>
                <div class="font-bold text-slate-200 flex items-center gap-2">
                    <span>${t.task_name}</span>
                    <span class="text-[10px] bg-slate-900 border border-slate-700 px-1.5 py-0.5 rounded text-amber-300 font-mono">${t.roomNumber}</span>
                </div>
                <div class="text-[11px] text-slate-400 mt-0.5">
                    Erledigt von: <span class="text-slate-200 font-medium">${t.assignedName}</span>
                </div>
            </div>
            <div class="flex items-center gap-2">
                <span class="font-bold text-emerald-400 bg-emerald-950 px-2 py-1 rounded border border-emerald-500/30">${amount.toFixed(2)} €</span>
                <button onclick="approveTask(${t.id}, true)" class="bg-emerald-600 hover:bg-emerald-500 text-white font-bold px-2.5 py-1 rounded transition text-[11px]">✓ Freigeben</button>
                <button onclick="approveTask(${t.id}, false)" class="bg-red-600/30 hover:bg-red-600/50 text-red-300 border border-red-500/30 font-bold px-2.5 py-1 rounded transition text-[11px]" title="Zurückweisen / wieder öffnen">✕ Ablehnen</button>
            </div>
        `;
        container.appendChild(item);
    });
}

async function approveTask(taskId, isApproved) {
    if (!isAdmin()) return;

    const payload = isApproved 
        ? { is_approved: true } 
        : { is_approved: false, is_completed: false };

    const { error } = await supabaseClient.from('tasks').update(payload).eq('id', taskId);

    if (!error) {
        allRoomsData.forEach(r => {
            if (r.tasks) {
                const t = r.tasks.find(x => x.id === taskId);
                if (t) {
                    t.is_approved = isApproved;
                    if (!isApproved) t.is_completed = false;
                }
            }
        });

        loadAdminApprovalTasks();
        loadAdminPayouts();
        calculateUserEarnedAmounts();
        renderMyTasks();
        loadRooms();
    } else {
        alert('Fehler bei der Aufgaben-Freigabe.');
    }
}

function loadAdminTaskCatalog() {
    const catalogList = document.getElementById('admin-task-catalog-list');
    catalogList.innerHTML = '';

    const uniqueTaskMap = {};

    allRoomsData.forEach(r => {
        if (r.tasks) {
            r.tasks.forEach(t => {
                const nameKey = t.task_name.trim();
                if (!uniqueTaskMap[nameKey]) {
                    uniqueTaskMap[nameKey] = {
                        name: nameKey,
                        currentReward: parseFloat(t.reward_amount || 0),
                        count: 1
                    };
                } else {
                    uniqueTaskMap[nameKey].count++;
                    if (t.reward_amount > uniqueTaskMap[nameKey].currentReward) {
                        uniqueTaskMap[nameKey].currentReward = parseFloat(t.reward_amount);
                    }
                }
            });
        }
    });

    const taskNames = Object.keys(uniqueTaskMap).sort();

    if (taskNames.length === 0) {
        catalogList.innerHTML = '<p class="text-xs text-slate-500 italic">Noch keine Aufgaben im System vorhanden.</p>';
        return;
    }

    taskNames.forEach(nameKey => {
        const item = uniqueTaskMap[nameKey];
        const row = document.createElement('div');
        row.className = "flex items-center justify-between bg-slate-800 border border-slate-700 p-2.5 rounded-lg text-xs";
        
        row.innerHTML = `
            <div>
                <span class="font-bold text-slate-200">${item.name}</span>
                <span class="text-[10px] text-slate-400 ml-2">(${item.count}x in Zimmern)</span>
            </div>
            <div class="flex items-center gap-2">
                <input type="number" step="0.01" id="catalog-input-${encodeURIComponent(item.name)}" value="${item.currentReward.toFixed(2)}" class="w-24 bg-slate-900 border border-slate-700 rounded px-2 py-1 text-right text-emerald-400 font-bold focus:outline-none focus:border-emerald-500">
                <span class="text-slate-400 font-bold">€</span>
                <button onclick="applyCatalogPrice('${item.name.replace(/'/g, "\\'")}')" class="bg-indigo-600 hover:bg-indigo-500 text-white font-semibold px-2.5 py-1 rounded transition text-[11px]">Preis für alle anwenden</button>
            </div>
        `;
        catalogList.appendChild(row);
    });
}

async function applyCatalogPrice(taskName) {
    if (!isAdmin()) return;

    const input = document.getElementById(`catalog-input-${encodeURIComponent(taskName)}`);
    if (!input) return;

    const newAmount = parseFloat(input.value) || 0;

    const targetIds = [];
    allRoomsData.forEach(r => {
        if (r.tasks) {
            r.tasks.forEach(t => {
                if (t.task_name.trim() === taskName.trim()) {
                    targetIds.push(t.id);
                }
            });
        }
    });

    if (targetIds.length === 0) return;

    const { error } = await supabaseClient
        .from('tasks')
        .update({ reward_amount: newAmount })
        .in('id', targetIds);

    if (!error) {
        allRoomsData.forEach(r => {
            if (r.tasks) {
                r.tasks.forEach(t => {
                    if (targetIds.includes(t.id)) {
                        t.reward_amount = newAmount;
                    }
                });
            }
        });

        alert(`Preis von ${newAmount.toFixed(2)} € für alle "${taskName}"-Aufgaben angewendet!`);
        logActivity(null, `hat Vergütung für alle "${taskName}"-Aufgaben auf ${newAmount.toFixed(2)} € festgelegt`);
        loadAdminTaskCatalog();
        loadAdminPayouts();
        calculateUserEarnedAmounts();
        renderMyTasks();
    } else {
        alert('Fehler beim Aktualisieren der Vergütung.');
    }
}

function loadAdminPayouts() {
    const container = document.getElementById('admin-payouts-container');
    container.innerHTML = '';

    const userMap = {};

    allProfiles.forEach(p => {
        userMap[p.id] = {
            alias: p.alias || 'Kein Name',
            unpaidTasks: [],
            paidTasks: [],
            unpaidTotal: 0,
            paidTotal: 0
        };
    });

    allRoomsData.forEach(r => {
        if (r.tasks) {
            r.tasks.forEach(t => {
                if (t.is_completed && t.is_approved && t.assigned_to && userMap[t.assigned_to]) {
                    const fullReward = parseFloat(t.reward_amount || 0);
                    const alreadyPaid = parseFloat(t.paid_amount || 0);
                    const openForTask = fullReward - alreadyPaid;

                    userMap[t.assigned_to].paidTotal += alreadyPaid;

                    if (!t.is_paid && openForTask > 0) {
                        userMap[t.assigned_to].unpaidTasks.push({ ...t, roomNumber: r.room_number, openForTask });
                        userMap[t.assigned_to].unpaidTotal += openForTask;
                    } else if (t.is_paid) {
                        userMap[t.assigned_to].paidTasks.push({ ...t, roomNumber: r.room_number });
                    }
                }
            });
        }
    });

    Object.keys(userMap).forEach(uid => {
        const u = userMap[uid];
        const card = document.createElement('div');
        card.className = "bg-slate-900 border border-slate-700/80 rounded-xl p-4 space-y-3";

        let unpaidTasksListHTML = '';
        if (u.unpaidTasks.length > 0) {
            unpaidTasksListHTML = u.unpaidTasks.map(t => `
                <div class="flex items-center justify-between text-xs bg-slate-800/80 p-2 rounded border border-slate-700/50">
                    <div>
                        <span class="font-bold text-slate-200">${t.task_name}</span>
                        <span class="text-slate-400 ml-1">(${t.roomNumber})</span>
                    </div>
                    <div class="flex items-center gap-2">
                        <span class="font-bold text-emerald-400">${t.openForTask.toFixed(2)} € offen</span>
                        <button onclick="markTaskPaid(${t.id}, true)" class="bg-emerald-600/30 hover:bg-emerald-600/50 text-emerald-300 border border-emerald-500/30 text-[10px] px-2 py-0.5 rounded font-bold">Als bezahlt abhaken</button>
                    </div>
                </div>
            `).join('');
        } else {
            unpaidTasksListHTML = '<p class="text-xs text-slate-500 italic">Keine offenen Prämien vorhanden.</p>';
        }

        card.innerHTML = `
            <div class="flex flex-col sm:flex-row sm:items-center justify-between gap-2 border-b border-slate-800 pb-3">
                <div>
                    <h4 class="font-bold text-white text-base">👤 ${u.alias}</h4>
                    <div class="flex gap-4 text-xs mt-0.5">
                        <span class="text-emerald-400 font-bold">Offen: ${u.unpaidTotal.toFixed(2)} €</span>
                        <span class="text-slate-400 font-medium">Bereits ausgezahlt: ${u.paidTotal.toFixed(2)} €</span>
                    </div>
                </div>
                <div class="flex items-center gap-2 flex-wrap sm:flex-nowrap">
                    ${u.unpaidTotal > 0 ? `
                        <button onclick="payoutCustomAmount('${uid}', '${u.alias}', ${u.unpaidTotal})" class="bg-indigo-600 hover:bg-indigo-500 text-white font-bold text-xs px-3 py-1.5 rounded-lg transition shadow">
                            ✏️ Teilbetrag auszahlen
                        </button>
                        <button onclick="payoutAllUserTasks('${uid}')" class="bg-emerald-600 hover:bg-emerald-500 text-white font-bold text-xs px-3 py-1.5 rounded-lg transition shadow">
                            💰 Alles (${u.unpaidTotal.toFixed(2)} €) auszahlen
                        </button>
                    ` : ''}
                    <button onclick="generateAdminPayoutReceipt('${uid}', '${u.alias}')" class="bg-slate-800 hover:bg-slate-700 text-slate-300 border border-slate-700 font-bold text-xs px-3 py-1.5 rounded-lg transition shadow flex items-center gap-1">
                        <span>📄</span> Quittung (PDF)
                    </button>
                </div>
            </div>
            <div class="space-y-1.5">
                <span class="text-[10px] font-bold uppercase text-slate-400 tracking-wider">Offene Prämien-Aufgaben:</span>
                ${unpaidTasksListHTML}
            </div>
        `;

        container.appendChild(card);
    });
}

// Teilzahlungs-Split per Aufgabe (Restbeträge werden exakt als 'partially_paid' verwaltet)
async function payoutCustomAmount(userId, userAlias, currentMaxUnpaid) {
    if (!isAdmin()) return;

    const inputVal = prompt(`Wie viel Euro möchtest du an ${userAlias} auszahlen? (Maximal offen: ${currentMaxUnpaid.toFixed(2)} €):`, currentMaxUnpaid.toFixed(2));
    if (!inputVal) return;

    const amountToPay = parseFloat(inputVal.replace(',', '.'));
    if (isNaN(amountToPay) || amountToPay <= 0) {
        alert('Ungültiger Betrag.');
        return;
    }

    const note = prompt('Optionales Kommentar zur Auszahlung (z. B. "Bar ausbezahlt"):', '') || '';
    let remaining = amountToPay;

    const eligibleTasks = [];
    allRoomsData.forEach(r => {
        if (r.tasks) {
            r.tasks.forEach(t => {
                if (t.is_completed && t.is_approved && t.assigned_to === userId && !t.is_paid) {
                    const fullReward = parseFloat(t.reward_amount || 0);
                    const alreadyPaid = parseFloat(t.paid_amount || 0);
                    const openForTask = fullReward - alreadyPaid;
                    if (openForTask > 0) {
                        eligibleTasks.push({ task: t, openForTask });
                    }
                }
            });
        }
    });

    for (const item of eligibleTasks) {
        if (remaining <= 0) break;
        const t = item.task;
        const currentPaid = parseFloat(t.paid_amount || 0);
        
        if (remaining >= item.openForTask) {
            const newPaid = currentPaid + item.openForTask;
            remaining -= item.openForTask;
            await supabaseClient.from('tasks').update({
                is_paid: true,
                paid_amount: newPaid,
                paid_at: new Date().toISOString()
            }).eq('id', t.id);
            t.is_paid = true;
            t.paid_amount = newPaid;
            t.paid_at = new Date().toISOString();
        } else {
            const newPaid = currentPaid + remaining;
            remaining = 0;
            await supabaseClient.from('tasks').update({
                is_paid: false,
                paid_amount: newPaid
            }).eq('id', t.id);
            t.is_paid = false;
            t.paid_amount = newPaid;
        }
    }

    await logActivity(null, `hat ${amountToPay.toFixed(2)} € an ${userAlias} ausbezahlt${note ? ` (${note})` : ''}`);
    alert(`Auszahlung von ${amountToPay.toFixed(2)} € für ${userAlias} verbucht!`);

    loadAdminPayouts();
    calculateUserEarnedAmounts();
    renderMyTasks();
}

// Admin-Quittung / Auszahlungsbeleg als PDF generieren
function generateAdminPayoutReceipt(userId, userAlias) {
    const { jsPDF } = window.jspdf;
    const doc = new jsPDF();

    doc.setFontSize(16);
    doc.text(`Auszahlungsbeleg / Quittung - ${userAlias}`, 14, 20);
    doc.setFontSize(10);
    doc.text(`Erstellt am: ${new Date().toLocaleDateString('de-DE')} | Administrator-Export`, 14, 26);

    const rows = [];
    let grandTotalPaid = 0;

    allRoomsData.forEach(r => {
        if (r.tasks) {
            r.tasks.forEach(t => {
                if (t.assigned_to === userId && (parseFloat(t.paid_amount || 0) > 0)) {
                    const paid = parseFloat(t.paid_amount);
                    grandTotalPaid += paid;
                    rows.push([
                        t.task_name,
                        r.room_number,
                        `${parseFloat(t.reward_amount || 0).toFixed(2)} €`,
                        `${paid.toFixed(2)} €`,
                        t.is_paid ? 'Vollständig' : 'Teilzahlung',
                        t.paid_at ? new Date(t.paid_at).toLocaleDateString('de-DE') : 'Teilzahlung'
                    ]);
                }
            });
        }
    });

    if (rows.length === 0) {
        alert(`Keine bisherigen Auszahlungen für ${userAlias} vorhanden.`);
        return;
    }

    doc.autoTable({
        startY: 32,
        head: [['Aufgabe', 'Zimmer', 'Gesamt', 'Ausbezahlt', 'Status', 'Datum']],
        body: rows,
        theme: 'striped',
        headStyles: { fillStyle: [79, 70, 229] }
    });

    const finalY = doc.lastAutoTable.finalY + 10;
    doc.setFontSize(12);
    doc.text(`Summe ausbezahlt: ${grandTotalPaid.toFixed(2)} €`, 14, finalY);

    doc.save(`Quittung_${userAlias.replace(/\s+/g, '_')}_${new Date().toISOString().slice(0, 10)}.pdf`);
}

async function markTaskPaid(taskId, isPaid) {
    if (!isAdmin()) return;

    let targetTask = null;
    allRoomsData.forEach(r => {
        if (r.tasks) {
            const t = r.tasks.find(x => x.id === taskId);
            if (t) targetTask = t;
        }
    });

    const fullReward = targetTask ? parseFloat(targetTask.reward_amount || 0) : 0;
    const payload = {
        is_paid: isPaid,
        paid_amount: isPaid ? fullReward : 0,
        paid_at: isPaid ? new Date().toISOString() : null
    };

    const { error } = await supabaseClient.from('tasks').update(payload).eq('id', taskId);

    if (!error && targetTask) {
        targetTask.is_paid = isPaid;
        targetTask.paid_amount = payload.paid_amount;
        targetTask.paid_at = payload.paid_at;
        
        loadAdminPayouts();
        calculateUserEarnedAmounts();
        renderMyTasks();
    }
}

async function payoutAllUserTasks(userId) {
    if (!isAdmin()) return;

    const targetTasks = [];
    let totalAmount = 0;
    let targetAlias = 'Mitarbeiter';

    allProfiles.forEach(p => { if(p.id === userId) targetAlias = p.alias; });

    allRoomsData.forEach(r => {
        if (r.tasks) {
            r.tasks.forEach(t => {
                if (t.is_completed && t.is_approved && t.assigned_to === userId && !t.is_paid) {
                    const fullReward = parseFloat(t.reward_amount || 0);
                    const alreadyPaid = parseFloat(t.paid_amount || 0);
                    targetTasks.push({ id: t.id, fullReward });
                    totalAmount += (fullReward - alreadyPaid);
                }
            });
        }
    });

    if (targetTasks.length === 0) return;

    if (!confirm(`Sollen alle offenen Beträge (${totalAmount.toFixed(2)} €) für ${targetAlias} als ausgezahlt markiert werden?`)) return;

    for (const item of targetTasks) {
        await supabaseClient.from('tasks').update({
            is_paid: true,
            paid_amount: item.fullReward,
            paid_at: new Date().toISOString()
        }).eq('id', item.id);
    }

    allRoomsData.forEach(r => {
        if (r.tasks) {
            r.tasks.forEach(t => {
                const found = targetTasks.find(x => x.id === t.id);
                if (found) {
                    t.is_paid = true;
                    t.paid_amount = found.fullReward;
                    t.paid_at = new Date().toISOString();
                }
            });
        }
    });

    await logActivity(null, `hat ${totalAmount.toFixed(2)} € (Gesamtes Guthaben) an ${targetAlias} ausbezahlt`);
    loadAdminPayouts();
    calculateUserEarnedAmounts();
    renderMyTasks();
    alert('Guthaben erfolgreich als ausgezahlt markiert!');
}

async function toggleUserAccess(userId, disable) {
    await supabaseClient.from('profiles').update({ is_disabled: disable }).eq('id', userId);
    openAdminUsersModal();
}

function copyInviteLink() {
    const url = window.location.href;
    navigator.clipboard.writeText(url);
    alert(`Einladungs-Link kopiert:\n${url}`);
}

function closeAdminUsersModal() {
    document.getElementById('admin-users-modal').classList.add('hidden');
}

async function bulkAddGlobalTask() {
    if (!isAdmin()) return;

    const input = document.getElementById('admin-bulk-task-input');
    const rewardInput = document.getElementById('admin-bulk-task-reward');
    
    const taskName = input.value.trim();
    const rewardAmount = parseFloat(rewardInput.value) || 0;

    if (!taskName) return;

    if (!confirm(`Soll die Aufgabe "${taskName}" wirklich zu ALLEN Räumen hinzugefügt werden?`)) return;

    const inserts = allRoomsData.map(r => ({
        room_id: r.id,
        task_name: taskName,
        is_completed: false,
        reward_amount: rewardAmount
    }));

    const { error } = await supabaseClient.from('tasks').insert(inserts);

    if (!error) {
        input.value = '';
        rewardInput.value = '';
        alert('Aufgabe erfolgreich an alle Räume verteilt!');
        logActivity(null, `hat Standard-Aufgabe "${taskName}" (${rewardAmount.toFixed(2)} €) an alle Räume verteilt`);
        loadRooms();
    }
}

async function bulkUpdateFloorStatus() {
    if (!isAdmin()) return;

    const floor = document.getElementById('admin-bulk-floor').value;
    const newStatus = document.getElementById('admin-bulk-status').value;

    if (!confirm(`Sollen alle Zimmer auf "${floor}" auf "${newStatus}" gesetzt werden?`)) return;

    const targetRooms = allRoomsData.filter(r => r.floor === floor);
    const ids = targetRooms.map(r => r.id);

    if (ids.length === 0) {
        alert('Keine Zimmer auf dieser Etage gefunden.');
        return;
    }

    const { error } = await supabaseClient.from('rooms').update({ status: newStatus }).in('id', ids);

    if (!error) {
        alert(`Status von ${ids.length} Zimmern auf ${floor} wurde aktualisiert.`);
        logActivity(null, `hat Status aller Zimmer auf "${floor}" geändert auf "${newStatus}"`);
        loadRooms();
    }
}

function downloadSystemBackup() {
    const backupData = {
        timestamp: new Date().toISOString(),
        exported_by: currentUserAlias,
        rooms: allRoomsData
    };

    const blob = new Blob([JSON.stringify(backupData, null, 2)], { type: 'application/json' });
    const link = document.createElement("a");
    link.href = URL.createObjectURL(blob);
    link.download = `Mainpark_Backup_${new Date().toISOString().slice(0, 10)}.json`;
    link.click();

    logActivity(null, 'hat System-Backup (JSON) heruntergeladen');
}

function loadAdminStats() {
    const userTaskCounts = {};
    allRoomsData.forEach(r => {
        if (r.tasks) {
            r.tasks.forEach(t => {
                if (t.is_completed && t.assigned_to) {
                    userTaskCounts[t.assigned_to] = (userTaskCounts[t.assigned_to] || 0) + 1;
                }
            });
        }
    });

    let topUser = '-';
    let maxTasks = 0;
    Object.keys(userTaskCounts).forEach(uid => {
        if (userTaskCounts[uid] > maxTasks) {
            maxTasks = userTaskCounts[uid];
            const prof = allProfiles.find(p => p.id === uid);
            if (prof) topUser = `${prof.alias} (${maxTasks} Aufgaben)`;
        }
    });
    document.getElementById('stat-top-performer').textContent = topUser;

    const stuckRooms = allRoomsData.filter(r => getRoomProgress(r) === 0 && r.status === 'In Arbeit').length;
    document.getElementById('stat-stuck-rooms').textContent = `${stuckRooms} Zimmer`;

    const openMat = allRoomsData.filter(r => r.material_status === 'Offen').length;
    document.getElementById('stat-material-open').textContent = `${openMat} Bestellanfragen`;
}

async function publishAnnouncement() {
    const input = document.getElementById('admin-announcement-input');
    const msg = input.value.trim();
    if (!msg) return;

    await supabaseClient.from('activity_logs').insert([{
        user_alias: 'ANNOUNCEMENT',
        room_name: 'SYSTEM',
        action_text: msg
    }]);

    input.value = '';
    checkGlobalAnnouncement();
    alert('Banner veröffentlicht!');
}

async function clearAnnouncement() {
    await supabaseClient.from('activity_logs').insert([{
        user_alias: 'ANNOUNCEMENT',
        room_name: 'SYSTEM',
        action_text: 'CLEAR'
    }]);
    checkGlobalAnnouncement();
}

async function checkGlobalAnnouncement() {
    const { data } = await supabaseClient
        .from('activity_logs')
        .select('*')
        .eq('user_alias', 'ANNOUNCEMENT')
        .order('created_at', { ascending: false })
        .limit(1);

    const bar = document.getElementById('global-announcement-bar');
    const txt = document.getElementById('announcement-text');

    if (data && data.length > 0 && data[0].action_text !== 'CLEAR') {
        txt.textContent = data[0].action_text;
        bar.classList.remove('hidden');
    } else {
        bar.classList.add('hidden');
    }
}