Lutris-Playtime-Report-Generator/templates/script.js

/****************************************************************************************************
 * Copyright (C) 2026 by WallyHackenslacker wallyhackenslacker@noreply.git.hackenslacker.space      *
 *                                                                                                  *
 * Permission to use, copy, modify, and/or distribute this software for any purpose with or without *
 * fee is hereby granted.                                                                           *
 *                                                                                                  *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS     *
 * SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE  *
 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES      *
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,        *
 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE *
 * OF THIS SOFTWARE.                                                                                *
 ****************************************************************************************************/

/*
 * Report UI controller
 * --------------------
 * This script powers all client-side behavior for the generated report page:
 * 1) Theme handling (auto/light/dark) + persistence in localStorage
 * 2) Data aggregation from embedded game data
 * 3) Chart.js chart creation and refresh after filter/theme changes
 * 4) Table rendering with expandable "Others" rows
 * 5) Small UI helpers (tabs, scroll-to-top button)
 *
 * The generator injects placeholders such as __ALL_GAMES__, __TOP_N__, and __THEME_CONFIG__
 * before this script reaches the browser.
 */

// Theme management
const themeToggle = document.getElementById('theme-toggle');
const themeIcon = document.getElementById('theme-icon');
const themes = ['auto', 'light', 'dark'];
let currentThemeIndex = 0;

// Returns the current OS/browser theme preference.
function getSystemTheme() {
    return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
}

/*
 * Updates button icon/title to reflect currently selected mode.
 *
 * Note: "auto" does not hard-force a theme; it follows system preference.
 */
function updateThemeIcon() {
    const theme = themes[currentThemeIndex];
    if (theme === 'auto') {
        themeIcon.textContent = '';
        themeIcon.className = 'icon icon-auto';
        themeToggle.title = 'Theme: Auto (click to change)';
    } else if (theme === 'light') {
        themeIcon.textContent = '\u2600\uFE0F';
        themeIcon.className = 'icon';
        themeToggle.title = 'Theme: Light (click to change)';
    } else {
        themeIcon.textContent = '\uD83C\uDF19';
        themeIcon.className = 'icon';
        themeToggle.title = 'Theme: Dark (click to change)';
    }
}

/*
 * Applies the selected theme mode to the root element and re-syncs all dependent UI.
 *
 * Behavior:
 * - auto: remove data-theme so CSS/media-query driven defaults can apply
 * - light/dark: set data-theme explicitly for deterministic styling
 *
 * Also updates chart legend colors because those are configured in JS, not pure CSS.
 */
function applyTheme() {
    const theme = themes[currentThemeIndex];
    if (theme === 'auto') {
        document.documentElement.removeAttribute('data-theme');
    } else {
        document.documentElement.setAttribute('data-theme', theme);
    }
    updateThemeIcon();
    localStorage.setItem('theme', theme);
    updateChartColors();
}

// Restores previously saved theme mode; defaults to "auto" when absent/invalid.
function loadSavedTheme() {
    const saved = localStorage.getItem('theme');
    if (saved) {
        currentThemeIndex = themes.indexOf(saved);
        if (currentThemeIndex === -1) currentThemeIndex = 0;
    }
    applyTheme();
}

// Cycle theme modes in a fixed order: auto -> light -> dark -> auto.
themeToggle.addEventListener('click', () => {
    currentThemeIndex = (currentThemeIndex + 1) % themes.length;
    applyTheme();
});

// When system theme changes and mode is "auto", refresh theme-dependent UI pieces.
window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', () => {
    if (themes[currentThemeIndex] === 'auto') {
        updateThemeIcon();
        updateChartColors();
    }
});

// Data and chart logic
const allGames = __ALL_GAMES__;
const topN = __TOP_N__;

// Theme-specific configuration
const themeConfig = __THEME_CONFIG__;

// Converts decimal hours to a compact human-friendly string (e.g. 1.5 -> "1h 30m").
function formatTime(hours) {
    const h = Math.floor(hours);
    const m = Math.round((hours - h) * 60);
    if (h === 0) return m + 'm';
    if (m === 0) return h + 'h';
    return h + 'h ' + m + 'm';
}

/*
 * Aggregates game list by service/source for checkbox filter creation.
 *
 * Output is sorted by playtime descending so the most relevant services appear first.
 */
function getServices() {
    const services = {};
    allGames.forEach(g => {
        const s = g.service;
        if (!services[s]) services[s] = { count: 0, playtime: 0 };
        services[s].count++;
        services[s].playtime += g.playtime;
    });
    return Object.entries(services)
    .sort((a, b) => b[1].playtime - a[1].playtime)
    .map(([name, data]) => ({ name, ...data }));
}

const services = getServices();
const filtersDiv = document.getElementById('filters');

// Build one checkbox per service so users can include/exclude data dynamically.
services.forEach(service => {
    const label = document.createElement('label');
    label.className = 'filter-label';
    label.innerHTML = `
    <input type="checkbox" value="${service.name}" checked>
    <span class="service-name">${service.name}</span>
    <span class="service-count">(${service.count})</span>
    `;
    filtersDiv.appendChild(label);
});

let chart = null;
let categoriesChart = null;
let runnersChart = null;
let sourcesChart = null;
const ctx = document.getElementById('playtime-chart').getContext('2d');
const ctxCategories = document.getElementById('categories-chart').getContext('2d');
const ctxRunners = document.getElementById('runners-chart').getContext('2d');
const ctxSources = document.getElementById('sources-chart').getContext('2d');

// Initialize theme after chart variables are declared
loadSavedTheme();

// Reads currently checked service filters from the filter panel.
function getSelectedServices() {
    const checkboxes = filtersDiv.querySelectorAll('input[type="checkbox"]');
    return Array.from(checkboxes)
    .filter(cb => cb.checked)
    .map(cb => cb.value);
}

/*
 * Produces all derived datasets required by charts and tables for the current filters.
 *
 * Returns:
 * - chartData: top games list used by the main playtime chart/table
 * - othersGames: the overflow games collapsed into chartData's "Others" bucket
 * - categoriesData/runnersData/sourcesData: grouped aggregations for secondary views
 * - totalPlaytime/totalGames: summary statistics for header counters and percentages
 *
 * Example (topN = 5):
 * - 18 filtered games => 5 explicit entries + 1 synthetic "Others (13 games)" entry
 * - the 13 overflow games are still accessible in expandable table detail rows
 */
function getFilteredData(selectedServices) {
    const filtered = allGames
    .filter(g => selectedServices.includes(g.service))
    .sort((a, b) => b.playtime - a.playtime);

    if (filtered.length === 0) {
        return { chartData: [], othersGames: [], categoriesData: [], totalPlaytime: 0, totalGames: 0 };
    }

    const totalPlaytime = filtered.reduce((sum, g) => sum + g.playtime, 0);
    const totalGames = filtered.length;

    // Keep only top N games for chart readability.
    const topGames = filtered.slice(0, topN).map(g => ({
        name: g.name,
        playtime: g.playtime,
        service: g.service,
        categories: g.categories || []
    }));

    let othersGames = [];

    // Collapse remaining entries into a single "Others" slice while preserving detail rows.
    if (filtered.length > topN) {
        othersGames = filtered.slice(topN).map(g => ({
            name: g.name,
            playtime: g.playtime,
            service: g.service,
            categories: g.categories || []
        }));
        const othersPlaytime = othersGames.reduce((sum, g) => sum + g.playtime, 0);
        const othersCount = othersGames.length;
        topGames.push({
            name: `Others (${othersCount} games)`,
            playtime: othersPlaytime,
            service: 'others'
        });
    }

    /*
     * Category aggregation notes:
     * - A game's full playtime contributes to each of its categories.
     * - Internal/special categories are intentionally hidden from report views.
     *
     * Example:
     * Game X (10h) in [RPG, Coop] increases RPG by 10h and Coop by 10h.
     */
    const categoryMap = {};
    filtered.forEach(g => {
        if (g.categories && g.categories.length > 0) {
            g.categories.forEach(cat => {
                if (cat === '.hidden' || cat === 'favorite') return;
                if (!categoryMap[cat]) {
                    categoryMap[cat] = { name: cat, playtime: 0, gameCount: 0 };
                }
                categoryMap[cat].playtime += g.playtime;
                categoryMap[cat].gameCount++;
            });
        }
    });
    const categoriesData = Object.values(categoryMap)
    .sort((a, b) => b.playtime - a.playtime);

    // Aggregate by runner (wine, native, dosbox, etc.). Missing values become "unknown".
    const runnerMap = {};
    filtered.forEach(g => {
        const runner = g.runner || 'unknown';
        if (!runnerMap[runner]) {
            runnerMap[runner] = { name: runner, playtime: 0, gameCount: 0 };
        }
        runnerMap[runner].playtime += g.playtime;
        runnerMap[runner].gameCount++;
    });
    const runnersData = Object.values(runnerMap)
    .sort((a, b) => b.playtime - a.playtime);

    // Aggregate by source/service to power the Sources chart.
    const sourceMap = {};
    filtered.forEach(g => {
        const source = g.service || 'unknown';
        if (!sourceMap[source]) {
            sourceMap[source] = { name: source, playtime: 0, gameCount: 0 };
        }
        sourceMap[source].playtime += g.playtime;
        sourceMap[source].gameCount++;
    });
    const sourcesData = Object.values(sourceMap)
    .sort((a, b) => b.playtime - a.playtime);

    return { chartData: topGames, othersGames, categoriesData, runnersData, sourcesData, totalPlaytime, totalGames };
}

// Theme-aware chart text color (explicit mode or system-driven when in auto).
function getChartTextColor() {
    const theme = themes[currentThemeIndex];
    if (theme === 'dark') return themeConfig.textColorDark;
    if (theme === 'light') return themeConfig.textColorLight;
    return getSystemTheme() === 'dark' ? themeConfig.textColorDark : themeConfig.textColorLight;
}

// Theme-aware border color for chart segment separators.
function getChartBorderColor() {
    const theme = themes[currentThemeIndex];
    if (theme === 'dark') return themeConfig.borderColorDark;
    if (theme === 'light') return themeConfig.borderColorLight;
    return getSystemTheme() === 'dark' ? themeConfig.borderColorDark : themeConfig.borderColorLight;
}

/*
 * Updates existing chart instances after theme changes.
 *
 * We only patch runtime options that are theme-sensitive here (legend text color),
 * then call chart.update() so Chart.js redraws without rebuilding datasets.
 */
function updateChartColors() {
    const textColor = getChartTextColor();
    if (typeof chart !== 'undefined' && chart) {
        chart.options.plugins.legend.labels.color = textColor;
        chart.update();
    }
    if (typeof categoriesChart !== 'undefined' && categoriesChart) {
        categoriesChart.options.plugins.legend.labels.color = textColor;
        categoriesChart.update();
    }
    if (typeof runnersChart !== 'undefined' && runnersChart) {
        runnersChart.options.plugins.legend.labels.color = textColor;
        runnersChart.update();
    }
    if (typeof sourcesChart !== 'undefined' && sourcesChart) {
        sourcesChart.options.plugins.legend.labels.color = textColor;
        sourcesChart.update();
    }
}

/*
 * Main render pipeline.
 *
 * This function is triggered on:
 * - initial page load
 * - service filter changes
 *
 * Steps:
 * 1) read active filters and compute all derived data
 * 2) refresh summary counters
 * 3) rebuild charts
 * 4) rebuild data tables (including expandable Others rows)
 */
function updateDisplay() {
    const selectedServices = getSelectedServices();
    const { chartData, othersGames, categoriesData, runnersData, sourcesData, totalPlaytime, totalGames } = getFilteredData(selectedServices);

    document.getElementById('total-games').textContent = totalGames;
    document.getElementById('total-time').textContent = formatTime(totalPlaytime);

    // Destroy old chart instances before creating new ones to avoid stacked canvases/memory leaks.
    if (chart) {
        chart.destroy();
    }
    if (categoriesChart) {
        categoriesChart.destroy();
    }
    if (runnersChart) {
        runnersChart.destroy();
    }
    if (sourcesChart) {
        sourcesChart.destroy();
    }

    if (chartData.length === 0) {
        document.getElementById('games-table').innerHTML =
        '<tr><td colspan="4" class="no-data">No games match the selected filters</td></tr>';
        document.getElementById('categories-table').innerHTML =
        '<tr><td colspan="4" class="no-data">No categories found</td></tr>';
        document.getElementById('runners-table').innerHTML =
        '<tr><td colspan="4" class="no-data">No runners found</td></tr>';
        return;
    }

    const textColor = getChartTextColor();
    const borderColor = getChartBorderColor();

    /*
     * Primary chart: top games by playtime (plus optional Others slice).
     *
     * Tooltip details:
     * - title: game/slice name
     * - beforeBody: service label (when available and not Others)
     * - label: absolute time + percentage of currently filtered total
     */
    chart = new Chart(ctx, {
        type: 'doughnut',
        data: {
            labels: chartData.map(g => g.name),
            datasets: [{
                data: chartData.map(g => g.playtime),
                        backgroundColor: themeConfig.colors.slice(0, chartData.length),
                        borderColor: borderColor,
                        borderWidth: themeConfig.borderWidth
            }]
        },
        options: {
            responsive: true,
            plugins: {
                legend: {
                    position: 'bottom',
                    labels: {
                        color: textColor,
                        font: {
                            family: themeConfig.fontFamily,
                            size: 11,
                            weight: themeConfig.fontWeight
                        },
                        padding: 12,
                        usePointStyle: true,
                        pointStyle: themeConfig.pointStyle
                    }
                },
                tooltip: {
                    backgroundColor: themeConfig.tooltipBg,
                    titleColor: themeConfig.tooltipTitleColor,
                    bodyColor: themeConfig.tooltipBodyColor,
                    borderColor: themeConfig.tooltipBorderColor,
                    borderWidth: themeConfig.tooltipBorderWidth,
                    titleFont: { weight: 'bold', family: themeConfig.fontFamily },
                    bodyFont: { weight: 'normal', family: themeConfig.fontFamily },
                    cornerRadius: themeConfig.tooltipCornerRadius,
                    padding: 12,
                    callbacks: {
                        title: function(context) {
                            return themeConfig.uppercaseTooltip ? context[0].label.toUpperCase() : context[0].label;
                        },
                        beforeBody: function(context) {
                            const index = context[0].dataIndex;
                            const service = chartData[index].service;
                            if (service && service !== 'others') {
                                return themeConfig.uppercaseTooltip ? service.toUpperCase() : service.charAt(0).toUpperCase() + service.slice(1);
                            }
                            return '';
                        },
                        label: function(context) {
                            const value = context.raw;
                            const percent = ((value / totalPlaytime) * 100).toFixed(1);
                            return formatTime(value) + ' (' + percent + '%)';
                        }
                    }
                }
            }
        }
    });

    /*
     * Categories chart uses the same topN + Others strategy as games.
     *
     * Example (topN = 8):
     * 12 categories => 8 visible slices + "Others (4 categories)" slice.
     */
    const topCategoriesChart = categoriesData.slice(0, topN);
    const otherCategoriesChart = categoriesData.slice(topN);
    const categoriesChartData = topCategoriesChart.map(c => ({
        name: c.name,
        playtime: c.playtime
    }));
    if (otherCategoriesChart.length > 0) {
        const othersPlaytime = otherCategoriesChart.reduce((sum, c) => sum + c.playtime, 0);
        categoriesChartData.push({
            name: `Others (${otherCategoriesChart.length} categories)`,
            playtime: othersPlaytime
        });
    }

    if (categoriesChartData.length > 0) {
        categoriesChart = new Chart(ctxCategories, {
            type: 'doughnut',
            data: {
                labels: categoriesChartData.map(c => c.name),
                datasets: [{
                    data: categoriesChartData.map(c => c.playtime),
                                    backgroundColor: themeConfig.colors.slice(0, categoriesChartData.length),
                                    borderColor: borderColor,
                                    borderWidth: themeConfig.borderWidth
                }]
            },
            options: {
                responsive: true,
                plugins: {
                    legend: {
                        position: 'bottom',
                        labels: {
                            color: textColor,
                            font: {
                                family: themeConfig.fontFamily,
                                size: 11,
                                weight: themeConfig.fontWeight
                            },
                            padding: 12,
                            usePointStyle: true,
                            pointStyle: themeConfig.pointStyle
                        }
                    },
                    tooltip: {
                        backgroundColor: themeConfig.tooltipBg,
                        titleColor: themeConfig.tooltipTitleColor,
                        bodyColor: themeConfig.tooltipBodyColor,
                        borderColor: themeConfig.tooltipBorderColor,
                        borderWidth: themeConfig.tooltipBorderWidth,
                        cornerRadius: themeConfig.tooltipCornerRadius,
                        padding: 12,
                        titleFont: { family: themeConfig.fontFamily },
                        bodyFont: { family: themeConfig.fontFamily },
                        callbacks: {
                            label: function(context) {
                                const value = context.raw;
                                const percent = ((value / totalPlaytime) * 100).toFixed(1);
                                return ' ' + formatTime(value) + ' (' + percent + '%)';
                            }
                        }
                    }
                }
            }
        });
    }

    // Runners chart: identical bucketing strategy applied to runner aggregation.
    const topRunnersChart = runnersData.slice(0, topN);
    const otherRunnersChart = runnersData.slice(topN);
    const runnersChartData = topRunnersChart.map(r => ({
        name: r.name,
        playtime: r.playtime
    }));
    if (otherRunnersChart.length > 0) {
        const othersPlaytime = otherRunnersChart.reduce((sum, r) => sum + r.playtime, 0);
        runnersChartData.push({
            name: `Others (${otherRunnersChart.length} runners)`,
            playtime: othersPlaytime
        });
    }

    if (runnersChartData.length > 0) {
        runnersChart = new Chart(ctxRunners, {
            type: 'doughnut',
            data: {
                labels: runnersChartData.map(r => r.name),
                datasets: [{
                    data: runnersChartData.map(r => r.playtime),
                    backgroundColor: themeConfig.colors.slice(0, runnersChartData.length),
                    borderColor: borderColor,
                    borderWidth: themeConfig.borderWidth
                }]
            },
            options: {
                responsive: true,
                plugins: {
                    legend: {
                        position: 'bottom',
                        labels: {
                            color: textColor,
                            font: {
                                family: themeConfig.fontFamily,
                                size: 11,
                                weight: themeConfig.fontWeight
                            },
                            padding: 12,
                            usePointStyle: true,
                            pointStyle: themeConfig.pointStyle
                        }
                    },
                    tooltip: {
                        backgroundColor: themeConfig.tooltipBg,
                        titleColor: themeConfig.tooltipTitleColor,
                        bodyColor: themeConfig.tooltipBodyColor,
                        borderColor: themeConfig.tooltipBorderColor,
                        borderWidth: themeConfig.tooltipBorderWidth,
                        cornerRadius: themeConfig.tooltipCornerRadius,
                        padding: 12,
                        titleFont: { family: themeConfig.fontFamily },
                        bodyFont: { family: themeConfig.fontFamily },
                        callbacks: {
                            label: function(context) {
                                const value = context.raw;
                                const percent = ((value / totalPlaytime) * 100).toFixed(1);
                                return ' ' + formatTime(value) + ' (' + percent + '%)';
                            }
                        }
                    }
                }
            }
        });
    }

    // Sources chart: grouped by service/source, also with topN + Others bucketing.
    const topSourcesChart = sourcesData.slice(0, topN);
    const otherSourcesChart = sourcesData.slice(topN);
    const sourcesChartData = topSourcesChart.map(s => ({
        name: s.name,
        playtime: s.playtime
    }));
    if (otherSourcesChart.length > 0) {
        const othersPlaytime = otherSourcesChart.reduce((sum, s) => sum + s.playtime, 0);
        sourcesChartData.push({
            name: `Others (${otherSourcesChart.length} sources)`,
            playtime: othersPlaytime
        });
    }

    if (sourcesChartData.length > 0) {
        sourcesChart = new Chart(ctxSources, {
            type: 'doughnut',
            data: {
                labels: sourcesChartData.map(s => s.name),
                datasets: [{
                    data: sourcesChartData.map(s => s.playtime),
                    backgroundColor: themeConfig.colors.slice(0, sourcesChartData.length),
                    borderColor: borderColor,
                    borderWidth: themeConfig.borderWidth
                }]
            },
            options: {
                responsive: true,
                plugins: {
                    legend: {
                        position: 'bottom',
                        labels: {
                            color: textColor,
                            font: {
                                family: themeConfig.fontFamily,
                                size: 11,
                                weight: themeConfig.fontWeight
                            },
                            padding: 12,
                            usePointStyle: true,
                            pointStyle: themeConfig.pointStyle
                        }
                    },
                    tooltip: {
                        backgroundColor: themeConfig.tooltipBg,
                        titleColor: themeConfig.tooltipTitleColor,
                        bodyColor: themeConfig.tooltipBodyColor,
                        borderColor: themeConfig.tooltipBorderColor,
                        borderWidth: themeConfig.tooltipBorderWidth,
                        cornerRadius: themeConfig.tooltipCornerRadius,
                        padding: 12,
                        titleFont: { family: themeConfig.fontFamily },
                        bodyFont: { family: themeConfig.fontFamily },
                        callbacks: {
                            label: function(context) {
                                const value = context.raw;
                                const percent = ((value / totalPlaytime) * 100).toFixed(1);
                                return ' ' + formatTime(value) + ' (' + percent + '%)';
                            }
                        }
                    }
                }
            }
        });
    }

    /*
     * Games table rendering
     * ---------------------
     * Mirrors the main chart ordering and values.
     *
     * "Others" behavior:
     * - parent row shows combined totals
     * - click toggles child detail rows for each hidden game
     * - detail index format uses parent.child numbering (e.g. 6.1, 6.2)
     */
    const tbody = document.getElementById('games-table');
    tbody.innerHTML = '';
    chartData.forEach((game, index) => {
        // Percentages are always based on currently filtered total playtime.
        const percent = ((game.playtime / totalPlaytime) * 100).toFixed(1);
        const isOthers = game.service === 'others';
        const serviceBadge = !isOthers
        ? `<span class="service-badge">${game.service}</span>`
        : '';
        const categoriesBadges = !isOthers && game.categories && game.categories.length > 0
        ? game.categories
        .filter(cat => cat !== '.hidden' && cat !== 'favorite')
        .map(cat => `<span class="category-badge">${cat}</span>`)
        .join('')
        : '';
        const row = document.createElement('tr');
        if (isOthers) {
            row.className = 'others-row';
        }
        row.innerHTML = `
        <td>${index + 1}</td>
        <td>
        <span class="color-box" style="background: ${themeConfig.colors[index]}"></span>
        ${game.name}${serviceBadge}${categoriesBadges}
        </td>
        <td class="time">${formatTime(game.playtime)}</td>
        <td class="percent">${percent}%</td>
        `;
        tbody.appendChild(row);

        if (isOthers && othersGames.length > 0) {
            const detailRows = [];
            othersGames.forEach((otherGame, otherIndex) => {
                const otherPercent = ((otherGame.playtime / totalPlaytime) * 100).toFixed(1);
                const otherCategoriesBadges = otherGame.categories && otherGame.categories.length > 0
                ? otherGame.categories
                .filter(cat => cat !== '.hidden' && cat !== 'favorite')
                .map(cat => `<span class="category-badge">${cat}</span>`)
                .join('')
                : '';
                const detailRow = document.createElement('tr');
                detailRow.className = 'others-detail';
                detailRow.innerHTML = `
                <td>${index + 1}.${otherIndex + 1}</td>
                <td>
                ${otherGame.name}
                <span class="service-badge">${otherGame.service}</span>${otherCategoriesBadges}
                </td>
                <td class="time">${formatTime(otherGame.playtime)}</td>
                <td class="percent">${otherPercent}%</td>
                `;
                tbody.appendChild(detailRow);
                detailRows.push(detailRow);
            });

            // Expand/collapse all detail rows tied to this "Others" summary row.
            row.addEventListener('click', () => {
                row.classList.toggle('expanded');
                detailRows.forEach(dr => dr.classList.toggle('visible'));
            });
        }
    });

    // Categories table mirrors chart grouping and supports expandable "Others" rows.
    const catTbody = document.getElementById('categories-table');
    catTbody.innerHTML = '';
    if (categoriesData.length === 0) {
        catTbody.innerHTML = '<tr><td colspan="4" class="no-data">No categories found</td></tr>';
    } else {
        const topCategories = categoriesData.slice(0, topN);
        const otherCategories = categoriesData.slice(topN);

        topCategories.forEach((cat, index) => {
            const percent = ((cat.playtime / totalPlaytime) * 100).toFixed(1);
            const row = document.createElement('tr');
            row.innerHTML = `
            <td>${index + 1}</td>
            <td>
            <span class="color-box" style="background: ${themeConfig.colors[index]}"></span>
            ${cat.name} <span class="service-badge">${cat.gameCount} games</span>
            </td>
            <td class="time">${formatTime(cat.playtime)}</td>
            <td class="percent">${percent}%</td>
            `;
            catTbody.appendChild(row);
        });

        if (otherCategories.length > 0) {
            const othersPlaytime = otherCategories.reduce((sum, c) => sum + c.playtime, 0);
            const othersPercent = ((othersPlaytime / totalPlaytime) * 100).toFixed(1);
            const othersIndex = topCategories.length;

            const othersRow = document.createElement('tr');
            othersRow.className = 'others-row';
            othersRow.innerHTML = `
            <td>${othersIndex + 1}</td>
            <td>
            <span class="color-box" style="background: ${themeConfig.colors[othersIndex]}"></span>
            Others (${otherCategories.length} categories)
            </td>
            <td class="time">${formatTime(othersPlaytime)}</td>
            <td class="percent">${othersPercent}%</td>
            `;
            catTbody.appendChild(othersRow);

            const detailRows = [];
            otherCategories.forEach((otherCat, otherIndex) => {
                const otherPercent = ((otherCat.playtime / totalPlaytime) * 100).toFixed(1);
                const detailRow = document.createElement('tr');
                detailRow.className = 'others-detail';
                detailRow.innerHTML = `
                <td>${othersIndex + 1}.${otherIndex + 1}</td>
                <td>
                ${otherCat.name} <span class="service-badge">${otherCat.gameCount} games</span>
                </td>
                <td class="time">${formatTime(otherCat.playtime)}</td>
                <td class="percent">${otherPercent}%</td>
                `;
                catTbody.appendChild(detailRow);
                detailRows.push(detailRow);
            });

            othersRow.addEventListener('click', () => {
                othersRow.classList.toggle('expanded');
                detailRows.forEach(dr => dr.classList.toggle('visible'));
            });
        }
    }

    // Runners table mirrors chart grouping and supports expandable "Others" rows.
    const runnersTbody = document.getElementById('runners-table');
    runnersTbody.innerHTML = '';
    if (runnersData.length === 0) {
        runnersTbody.innerHTML = '<tr><td colspan="4" class="no-data">No runners found</td></tr>';
    } else {
        const topRunners = runnersData.slice(0, topN);
        const otherRunners = runnersData.slice(topN);

        topRunners.forEach((runner, index) => {
            const percent = ((runner.playtime / totalPlaytime) * 100).toFixed(1);
            const row = document.createElement('tr');
            row.innerHTML = `
            <td>${index + 1}</td>
            <td>
            <span class="color-box" style="background: ${themeConfig.colors[index]}"></span>
            ${runner.name} <span class="service-badge">${runner.gameCount} games</span>
            </td>
            <td class="time">${formatTime(runner.playtime)}</td>
            <td class="percent">${percent}%</td>
            `;
            runnersTbody.appendChild(row);
        });

        if (otherRunners.length > 0) {
            const othersPlaytime = otherRunners.reduce((sum, r) => sum + r.playtime, 0);
            const othersPercent = ((othersPlaytime / totalPlaytime) * 100).toFixed(1);
            const othersIndex = topRunners.length;

            const othersRow = document.createElement('tr');
            othersRow.className = 'others-row';
            othersRow.innerHTML = `
            <td>${othersIndex + 1}</td>
            <td>
            <span class="color-box" style="background: ${themeConfig.colors[othersIndex]}"></span>
            Others (${otherRunners.length} runners)
            </td>
            <td class="time">${formatTime(othersPlaytime)}</td>
            <td class="percent">${othersPercent}%</td>
            `;
            runnersTbody.appendChild(othersRow);

            const detailRows = [];
            otherRunners.forEach((otherRunner, otherIndex) => {
                const otherPercent = ((otherRunner.playtime / totalPlaytime) * 100).toFixed(1);
                const detailRow = document.createElement('tr');
                detailRow.className = 'others-detail';
                detailRow.innerHTML = `
                <td>${othersIndex + 1}.${otherIndex + 1}</td>
                <td>
                ${otherRunner.name} <span class="service-badge">${otherRunner.gameCount} games</span>
                </td>
                <td class="time">${formatTime(otherRunner.playtime)}</td>
                <td class="percent">${otherPercent}%</td>
                `;
                runnersTbody.appendChild(detailRow);
                detailRows.push(detailRow);
            });

            othersRow.addEventListener('click', () => {
                othersRow.classList.toggle('expanded');
                detailRows.forEach(dr => dr.classList.toggle('visible'));
            });
        }
    }
}

// Re-render whenever any service checkbox state changes.
filtersDiv.addEventListener('change', updateDisplay);
// Initial render with all services selected by default.
updateDisplay();

// Tab switching
// Activates selected tab and matching panel while deactivating the rest.
document.querySelectorAll('.tab').forEach(tab => {
    tab.addEventListener('click', () => {
        const tabId = tab.dataset.tab;
        document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
        tab.classList.add('active');
        document.querySelectorAll('.tab-panel').forEach(p => p.classList.remove('active'));
        document.getElementById('tab-' + tabId).classList.add('active');
    });
});

// Scroll to top button
const scrollTopBtn = document.getElementById('scroll-top');

// Show the floating button only after user has scrolled past a threshold.
function updateScrollTopVisibility() {
    if (window.scrollY > 100) {
        scrollTopBtn.classList.add('visible');
    } else {
        scrollTopBtn.classList.remove('visible');
    }
}

window.addEventListener('scroll', updateScrollTopVisibility);
updateScrollTopVisibility();

// Smoothly jump to top for better UX on long reports.
scrollTopBtn.addEventListener('click', () => {
    window.scrollTo({
        top: 0,
        behavior: 'smooth'
    });
});