Organizr/api/homepage/userWatchStats.php

<?php

/**
 * User Watch Statistics Homepage Plugin
 * Provides comprehensive user watching statistics from Plex/Emby/Jellyfin
 */

trait HomepageUserWatchStats
{
    public function userWatchStatsSettingsArray($infoOnly = false)
    {
        $homepageInformation = [
            'name' => 'User Watch Statistics',
            'enabled' => strpos('personal', $this->config['license']) !== false,
            'image' => 'plugins/images/homepage/userWatchStats.png',
            'category' => 'Media Server',
            'settingsArray' => __FUNCTION__
        ];
        if ($infoOnly) {
            return $homepageInformation;
        }
        $homepageSettings = [
            'debug' => true,
            'settings' => [
                'Enable' => [
                    $this->settingsOption('enable', 'homepageUserWatchStatsEnabled'),
                    $this->settingsOption('auth', 'homepageUserWatchStatsAuth'),
                ],
                'Connection' => array_merge(
                    [
                        $this->settingsOption('select', 'homepageUserWatchStatsService', ['label' => 'Media Server', 'options' => [
                            ['name' => 'Plex (via Tautulli)', 'value' => 'plex'],
                            ['name' => 'Emby', 'value' => 'emby'],
                            ['name' => 'Jellyfin', 'value' => 'jellyfin']
                        ]])
                    ],
                    $this->getUserWatchStatsConnectionFields()
                ),
                'Display Options' => [
                    $this->settingsOption('number', 'homepageUserWatchStatsRefresh', ['label' => 'Auto-refresh Interval (minutes)', 'min' => 1, 'max' => 60]),
                    $this->settingsOption('number', 'homepageUserWatchStatsDays', ['label' => 'Statistics Period (days)', 'min' => 1, 'max' => 365]),
                    $this->settingsOption('switch', 'homepageUserWatchStatsCompactView', ['label' => 'Use Compact View']),
                    $this->settingsOption('switch', 'homepageUserWatchStatsShowTopUsers', ['label' => 'Show Top Users']),
                    $this->settingsOption('switch', 'homepageUserWatchStatsShowMostWatched', ['label' => 'Show Most Watched']),
                    $this->settingsOption('switch', 'homepageUserWatchStatsShowRecentActivity', ['label' => 'Show Recent Activity']),
                    $this->settingsOption('number', 'homepageUserWatchStatsMaxItems', ['label' => 'Maximum Items to Display', 'min' => 5, 'max' => 50]),
                ],
                'Test Connection' => [
                    $this->settingsOption('blank', null, ['label' => 'Please Save before Testing']),
                    $this->settingsOption('test', 'userWatchStats'),
                ]
            ]
        ];
        return array_merge($homepageInformation, $homepageSettings);
    }

    private function getUserWatchStatsConnectionFields()
    {
        $mediaServer = $this->config['homepageUserWatchStatsService'] ?? 'plex';
        
        switch (strtolower($mediaServer)) {
            case 'plex':
                return [
                    $this->settingsOption('url', 'plexURL', ['label' => 'Tautulli URL']),
                    $this->settingsOption('token', 'plexToken', ['label' => 'Tautulli API Key']),
                    $this->settingsOption('disable-cert-check', 'plexDisableCertCheck'),
                    $this->settingsOption('use-custom-certificate', 'plexUseCustomCertificate'),
                ];
            case 'emby':
                return [
                    $this->settingsOption('url', 'embyURL', ['label' => 'Emby Server URL']),
                    $this->settingsOption('token', 'embyToken', ['label' => 'Emby API Key']),
                    $this->settingsOption('disable-cert-check', 'embyDisableCertCheck'),
                    $this->settingsOption('use-custom-certificate', 'embyUseCustomCertificate'),
                ];
            case 'jellyfin':
                return [
                    $this->settingsOption('url', 'jellyfinURL', ['label' => 'Jellyfin Server URL']),
                    $this->settingsOption('token', 'jellyfinToken', ['label' => 'Jellyfin API Key']),
                    $this->settingsOption('disable-cert-check', 'jellyfinDisableCertCheck'),
                    $this->settingsOption('use-custom-certificate', 'jellyfinUseCustomCertificate'),
                ];
            default:
                return [
                    $this->settingsOption('url', 'plexURL', ['label' => 'Tautulli URL']),
                    $this->settingsOption('token', 'plexToken', ['label' => 'Tautulli API Key']),
                    $this->settingsOption('disable-cert-check', 'plexDisableCertCheck'),
                    $this->settingsOption('use-custom-certificate', 'plexUseCustomCertificate'),
                ];
        }
    }

    public function testConnectionUserWatchStats()
    {
        if (!$this->homepageItemPermissions($this->userWatchStatsHomepagePermissions('test'), true)) {
            return false;
        }
        
        $mediaServer = $this->config['homepageUserWatchStatsService'] ?? 'plex';
        
        // Get URL and token from global config based on selected media server
        switch (strtolower($mediaServer)) {
            case 'plex':
                $url = $this->config['plexURL'] ?? '';
                $token = $this->config['plexToken'] ?? '';
                $disableCert = $this->config['plexDisableCertCheck'] ?? false;
                $customCert = $this->config['plexUseCustomCertificate'] ?? false;
                break;
            case 'emby':
                $url = $this->config['embyURL'] ?? '';
                $token = $this->config['embyToken'] ?? '';
                $disableCert = $this->config['embyDisableCertCheck'] ?? false;
                $customCert = $this->config['embyUseCustomCertificate'] ?? false;
                break;
            case 'jellyfin':
                $url = $this->config['jellyfinURL'] ?? '';
                $token = $this->config['jellyfinToken'] ?? '';
                $disableCert = $this->config['jellyfinDisableCertCheck'] ?? false;
                $customCert = $this->config['jellyfinUseCustomCertificate'] ?? false;
                break;
            default:
                $url = $this->config['plexURL'] ?? '';
                $token = $this->config['plexToken'] ?? '';
                $disableCert = $this->config['plexDisableCertCheck'] ?? false;
                $customCert = $this->config['plexUseCustomCertificate'] ?? false;
                break;
        }
        
        if (empty($url) || empty($token)) {
            $serverName = ucfirst($mediaServer) . ($mediaServer === 'plex' ? ' (Tautulli)' : '');
            $this->setAPIResponse('error', $serverName . ' URL or API key not configured', 500);
            return false;
        }
        
        // Test the connection based on media server type
        try {
            $options = $this->requestOptions($url, null, $disableCert, $customCert);
            
            switch (strtolower($mediaServer)) {
                case 'plex':
                    // Test Tautulli connection
                    $testUrl = $this->qualifyURL($url) . '/api/v2?apikey=' . $token . '&cmd=get_server_info';
                    $response = Requests::get($testUrl, [], $options);
                    if ($response->success) {
                        $data = json_decode($response->body, true);
                        if (isset($data['response']['result']) && $data['response']['result'] === 'success') {
                            $this->setAPIResponse('success', 'Successfully connected to Tautulli', 200);
                            return true;
                        }
                    }
                    break;
                case 'emby':
                    // Test Emby connection
                    $testUrl = $this->qualifyURL($url) . '/emby/System/Info?api_key=' . $token;
                    $response = Requests::get($testUrl, [], $options);
                    if ($response->success) {
                        $data = json_decode($response->body, true);
                        if (isset($data['ServerName'])) {
                            $this->setAPIResponse('success', 'Successfully connected to Emby server: ' . $data['ServerName'], 200);
                            return true;
                        }
                    }
                    break;
                case 'jellyfin':
                    // Test Jellyfin connection
                    $testUrl = $this->qualifyURL($url) . '/System/Info?api_key=' . $token;
                    $response = Requests::get($testUrl, [], $options);
                    if ($response->success) {
                        $data = json_decode($response->body, true);
                        if (isset($data['ServerName'])) {
                            $this->setAPIResponse('success', 'Successfully connected to Jellyfin server: ' . $data['ServerName'], 200);
                            return true;
                        }
                    }
                    break;
            }
            
            $this->setAPIResponse('error', 'Connection test failed - invalid response from server', 500);
            return false;
            
        } catch (Exception $e) {
            $this->setAPIResponse('error', 'Connection test failed: ' . $e->getMessage(), 500);
            return false;
        }
    }
    public function userWatchStatsHomepagePermissions($key = null)
    {
        // Get the selected media server to determine which global config keys to check
        $mediaServer = $this->config['homepageUserWatchStatsService'] ?? 'plex';
        
        // Determine the appropriate global config keys based on selected media server
        $urlKey = '';
        $tokenKey = '';
        
        switch (strtolower($mediaServer)) {
            case 'plex':
                $urlKey = 'plexURL';
                $tokenKey = 'plexToken';
                break;
            case 'emby':
                $urlKey = 'embyURL';
                $tokenKey = 'embyToken';
                break;
            case 'jellyfin':
                $urlKey = 'jellyfinURL';
                $tokenKey = 'jellyfinToken';
                break;
            default:
                $urlKey = 'plexURL';
                $tokenKey = 'plexToken';
                break;
        }
        
        $permissions = [
            'test' => [
                'enabled' => [
                    'homepageUserWatchStatsEnabled',
                ],
                'auth' => [
                    'homepageUserWatchStatsAuth',
                ],
                'not_empty' => [
                    $urlKey,
                    $tokenKey
                ]
            ],
            'main' => [
                'enabled' => [
                    'homepageUserWatchStatsEnabled'
                ],
                'auth' => [
                    'homepageUserWatchStatsAuth'
                ],
                'not_empty' => [
                    $urlKey,
                    $tokenKey
                ]
            ]
        ];
        return $this->homepageCheckKeyPermissions($key, $permissions);
    }

    public function homepageOrderUserWatchStats()
    {
        if ($this->homepageItemPermissions($this->userWatchStatsHomepagePermissions('main'))) {
            $refreshInterval = ($this->config['homepageUserWatchStatsRefresh'] ?? 5) * 60000; // Convert minutes to milliseconds
            $compactView = ($this->config['homepageUserWatchStatsCompactView'] ?? false) ? 'true' : 'false';
            $days = $this->config['homepageUserWatchStatsDays'] ?? 30;
            $maxItems = $this->config['homepageUserWatchStatsMaxItems'] ?? 10;
            $showTopUsers = ($this->config['homepageUserWatchStatsShowTopUsers'] ?? true) ? 'true' : 'false';
            $showMostWatched = ($this->config['homepageUserWatchStatsShowMostWatched'] ?? true) ? 'true' : 'false';
            $showRecentActivity = ($this->config['homepageUserWatchStatsShowRecentActivity'] ?? true) ? 'true' : 'false';

            return '
            <div id="' . __FUNCTION__ . '">
                <div class="white-box">
                    <div class="white-box-header">
                        <i class="fa fa-bar-chart"></i> User Watch Statistics
                        <span class="pull-right">
                            <small id="watchstats-last-update" class="text-muted"></small>
                            <button class="btn btn-xs btn-primary" onclick="refreshUserWatchStats()" title="Refresh Data">
                                <i class="fa fa-refresh" id="watchstats-refresh-icon"></i>
                            </button>
                        </span>
                    </div>
                    <div class="white-box-content">
                        <div class="row" id="watchstats-content">
                            <div class="col-lg-12 text-center">
                                <i class="fa fa-spinner fa-spin"></i> Loading statistics...
                            </div>
                        </div>
                    </div>
                </div>
            </div>

            <script>
            var watchStatsRefreshTimer;
            var watchStatsLastRefresh = 0;

            function refreshUserWatchStats() {
                var refreshIcon = $("#watchstats-refresh-icon");
                refreshIcon.addClass("fa-spin");

                // Show loading state
                $("#watchstats-content").html(\'<div class="col-lg-12 text-center"><i class="fa fa-spinner fa-spin"></i> Loading statistics...</div>\');

                // Load watch statistics
                getUserWatchStatsData()
                .always(function() {
                    refreshIcon.removeClass("fa-spin");
                    watchStatsLastRefresh = Date.now();
                    updateWatchStatsLastRefreshTime();
                });
            }

            function updateWatchStatsLastRefreshTime() {
                if (watchStatsLastRefresh > 0) {
                    var ago = Math.floor((Date.now() - watchStatsLastRefresh) / 1000);
                    var timeText = ago < 60 ? ago + "s ago" : Math.floor(ago / 60) + "m ago";
                    $("#watchstats-last-update").text("Updated " + timeText);
                }
            }

            function getUserWatchStatsData() {
                return organizrAPI2("GET", "api/v2/homepage/userWatchStats")
                .done(function(data) {
                    if (data && data.response && data.response.result === "success" && data.response.data) {
                        var stats = data.response.data;
                        var html = "";
                        
                        // Display statistics period
                        html += \'<div class="col-lg-12"><h4>Statistics for \' + (stats.period || "30 days") + \'</h4></div>\';
                        
                        // Show top users if enabled
                        if (' . $showTopUsers . ' && stats.top_users && stats.top_users.length > 0) {
                            html += \'<div class="col-lg-6"><h5>Top Users</h5><ul class="list-group">\';
                            stats.top_users.slice(0, 5).forEach(function(user) {
                                html += \'<li class="list-group-item">\' + (user.friendly_name || user.username || "Unknown User") + \' - \' + (user.play_count || 0) + \' plays</li>\';
                            });
                            html += \'</ul></div>\';
                        }
                        
                        // Show most watched if enabled
                        if (' . $showMostWatched . ' && stats.most_watched && stats.most_watched.length > 0) {
                            html += \'<div class="col-lg-6"><h5>Most Watched</h5><ul class="list-group">\';
                            stats.most_watched.slice(0, 5).forEach(function(item) {
                                html += \'<li class="list-group-item">\' + (item.title || "Unknown Title") + \' - \' + (item.total_plays || 0) + \' plays</li>\';
                            });
                            html += \'</ul></div>\';
                        }
                        
                        // Show recent activity if enabled
                        if (' . $showRecentActivity . ' && stats.recent_activity && stats.recent_activity.length > 0) {
                            html += \'<div class="col-lg-12"><h5>Recent Activity</h5><ul class="list-group">\';
                            stats.recent_activity.slice(0, 10).forEach(function(activity) {
                                html += \'<li class="list-group-item">\' + (activity.title || "Unknown Title") + \' - \' + (activity.added_at || "Unknown Date") + \'</li>\';
                            });
                            html += \'</ul></div>\';
                        }
                        
                        if (html === \'<div class="col-lg-12"><h4>Statistics for \' + (stats.period || "30 days") + \'</h4></div>\') {
                            html += \'<div class="col-lg-12 text-center text-muted">No statistics available</div>\';
                        }
                        
                        $("#watchstats-content").html(html);
                    } else {
                        $("#watchstats-content").html(\'<div class="col-lg-12 text-center text-danger">Failed to load statistics</div>\');
                    }
                })
                .fail(function(xhr, status, error) {
                    $("#watchstats-content").html(\'<div class="col-lg-12 text-center text-danger">Error loading statistics</div>\');
                });
            }

            // Auto-refresh setup
            var refreshInterval = ' . $refreshInterval . ';
            if (refreshInterval > 0) {
                watchStatsRefreshTimer = setInterval(function() {
                    refreshUserWatchStats();
                }, refreshInterval);
            }

            // Update time display every 30 seconds
            setInterval(updateWatchStatsLastRefreshTime, 30000);

            // Initial load
            $(document).ready(function() {
                refreshUserWatchStats();
            });

            // Cleanup timer when page unloads
            $(window).on("beforeunload", function() {
                if (watchStatsRefreshTimer) {
                    clearInterval(watchStatsRefreshTimer);
                }
            });
            </script>
            ';
        }
    }

    /**
     * Main function to get watch statistics
     */
    public function getUserWatchStats($options = null)
    {
        if (!$this->homepageItemPermissions($this->userWatchStatsHomepagePermissions('main'), true)) {
            return false;
        }

        try {
            $mediaServer = $this->config['homepageUserWatchStatsService'] ?? 'plex';
            $days = intval($this->config['homepageUserWatchStatsDays'] ?? 30);
            
            switch (strtolower($mediaServer)) {
                case 'plex':
                    $stats = $this->getPlexWatchStats($days);
                    break;
                case 'emby':
                    $stats = $this->getEmbyWatchStats($days);
                    break;
                case 'jellyfin':
                    $stats = $this->getJellyfinWatchStats($days);
                    break;
                default:
                    $stats = $this->getPlexWatchStats($days);
                    break;
            }
            
            if (isset($stats['error']) && $stats['error']) {
                $this->setAPIResponse('error', $stats['message'], 500);
                return false;
            }
            
            $this->setAPIResponse('success', 'Watch statistics retrieved successfully', 200, $stats);
            return true;
            
        } catch (Exception $e) {
            $this->writeLog('error', 'User Watch Stats Error: ' . $e->getMessage(), 'SYSTEM');
            $this->setAPIResponse('error', 'Failed to retrieve watch statistics: ' . $e->getMessage(), 500);
            return false;
        }
    }

    /**
     * Get Plex watch statistics via Tautulli API
     */
    private function getPlexWatchStats($days = 30)
    {
        $tautulliUrl = $this->config['plexURL'] ?? '';
        $tautulliToken = $this->config['plexToken'] ?? '';
        
        if (empty($tautulliUrl) || empty($tautulliToken)) {
            return ['error' => true, 'message' => 'Tautulli URL or API key not configured'];
        }

        $endDate = date('Y-m-d');
        $startDate = date('Y-m-d', strtotime("-{$days} days"));
        
        $stats = [
            'period' => "{$days} days",
            'start_date' => $startDate,
            'end_date' => $endDate,
            'most_watched' => $this->getTautulliMostWatched($tautulliUrl, $tautulliToken, $days),
            'least_watched' => $this->getTautulliLeastWatched($tautulliUrl, $tautulliToken, $days),
            'user_stats' => $this->getTautulliUserStats($tautulliUrl, $tautulliToken, $days),
            'recent_activity' => $this->getTautulliRecentActivity($tautulliUrl, $tautulliToken),
            'top_users' => $this->getTautulliTopUsers($tautulliUrl, $tautulliToken, $days)
        ];

        return $stats;
    }

    /**
     * Get most watched content from Tautulli
     */
    private function getTautulliMostWatched($url, $token, $days)
    {
        $endpoint = rtrim($url, '/') . '/api/v2';
        $params = [
            'apikey' => $token,
            'cmd' => 'get_home_stats',
            'time_range' => $days,
            'stats_type' => 'plays',
            'stats_count' => 10
        ];
        
        $response = $this->guzzle->request('GET', $endpoint, [
            'query' => $params,
            'timeout' => 15,
            'connect_timeout' => 15,
            'http_errors' => false
        ]);

        if ($response->getStatusCode() === 200) {
            $data = json_decode($response->getBody(), true);
            return $data['response']['data'] ?? [];
        }

        return [];
    }

    /**
     * Get user statistics from Tautulli
     */
    private function getTautulliUserStats($url, $token, $days)
    {
        $endpoint = rtrim($url, '/') . '/api/v2';
        $params = [
            'apikey' => $token,
            'cmd' => 'get_user_watch_time_stats',
            'time_range' => $days
        ];
        
        $response = $this->guzzle->request('GET', $endpoint, [
            'query' => $params,
            'timeout' => 15,
            'connect_timeout' => 15,
            'http_errors' => false
        ]);

        if ($response->getStatusCode() === 200) {
            $data = json_decode($response->getBody(), true);
            return $data['response']['data'] ?? [];
        }

        return [];
    }

    /**
     * Get top users from Tautulli
     */
    private function getTautulliTopUsers($url, $token, $days)
    {
        $endpoint = rtrim($url, '/') . '/api/v2';
        $params = [
            'apikey' => $token,
            'cmd' => 'get_users',
            'length' => 25
        ];
        
        $response = $this->guzzle->request('GET', $endpoint, [
            'query' => $params,
            'timeout' => 15,
            'connect_timeout' => 15,
            'http_errors' => false
        ]);

        if ($response->getStatusCode() === 200) {
            $data = json_decode($response->getBody(), true);
            $users = $data['response']['data']['data'] ?? [];
            
            // Sort by play count
            usort($users, function($a, $b) {
                return ($b['play_count'] ?? 0) - ($a['play_count'] ?? 0);
            });
            
            return array_slice($users, 0, 10);
        }

        return [];
    }

    /**
     * Get recent activity from Tautulli
     */
    private function getTautulliRecentActivity($url, $token)
    {
        $endpoint = rtrim($url, '/') . '/api/v2';
        $params = [
            'apikey' => $token,
            'cmd' => 'get_recently_added',
            'count' => 10
        ];
        
        $response = $this->guzzle->request('GET', $endpoint, [
            'query' => $params,
            'timeout' => 15,
            'connect_timeout' => 15,
            'http_errors' => false
        ]);

        if ($response->getStatusCode() === 200) {
            $data = json_decode($response->getBody(), true);
            return $data['response']['data']['recently_added'] ?? [];
        }

        return [];
    }

    /**
     * Get least watched content (inverse of most watched)
     */
    private function getTautulliLeastWatched($url, $token, $days)
    {
        $endpoint = rtrim($url, '/') . '/api/v2';
        $params = [
            'apikey' => $token,
            'cmd' => 'get_libraries',
        ];
        
        $response = $this->guzzle->request('GET', $endpoint, [
            'query' => $params,
            'timeout' => 15,
            'connect_timeout' => 15,
            'http_errors' => false
        ]);

        if ($response->getStatusCode() === 200) {
            $data = json_decode($response->getBody(), true);
            $libraries = $data['response']['data'] ?? [];
            
            $leastWatched = [];
            foreach ($libraries as $library) {
                $libraryStats = $this->getTautulliLibraryStats($url, $token, $library['section_id'], $days);
                if (!empty($libraryStats)) {
                    $leastWatched = array_merge($leastWatched, array_slice($libraryStats, -10));
                }
            }
            
            return $leastWatched;
        }

        return [];
    }

    /**
     * Get library statistics for least watched calculation
     */
    private function getTautulliLibraryStats($url, $token, $sectionId, $days)
    {
        $endpoint = rtrim($url, '/') . '/api/v2';
        $params = [
            'apikey' => $token,
            'cmd' => 'get_library_media_info',
            'section_id' => $sectionId,
            'length' => 50,
            'order_column' => 'play_count',
            'order_dir' => 'asc'
        ];
        
        $response = $this->guzzle->request('GET', $endpoint, [
            'query' => $params,
            'timeout' => 15,
            'connect_timeout' => 15,
            'http_errors' => false
        ]);

        if ($response->getStatusCode() === 200) {
            $data = json_decode($response->getBody(), true);
            return $data['response']['data']['data'] ?? [];
        }

        return [];
    }

    /**
     * Get Emby watch statistics
     */
    private function getEmbyWatchStats($days = 30)
    {
        $embyUrl = $this->config['embyURL'] ?? '';
        $embyToken = $this->config['embyToken'] ?? '';
        
        if (empty($embyUrl) || empty($embyToken)) {
            return ['error' => true, 'message' => 'Emby URL or API key not configured'];
        }

        // Implement Emby-specific statistics gathering
        return $this->getGenericMediaServerStats('emby', $embyUrl, $embyToken, $days);
    }

    /**
     * Get Jellyfin watch statistics
     */
    private function getJellyfinWatchStats($days = 30)
    {
        $jellyfinUrl = $this->config['jellyfinURL'] ?? '';
        $jellyfinToken = $this->config['jellyfinToken'] ?? '';
        
        if (empty($jellyfinUrl) || empty($jellyfinToken)) {
            return ['error' => true, 'message' => 'Jellyfin URL or API key not configured'];
        }

        // Implement Jellyfin-specific statistics gathering
        return $this->getGenericMediaServerStats('jellyfin', $jellyfinUrl, $jellyfinToken, $days);
    }

    /**
     * Generic media server stats for Emby/Jellyfin
     */
    private function getGenericMediaServerStats($type, $url, $token, $days)
    {
        // Basic structure for now - can be expanded based on Emby/Jellyfin APIs
        return [
            'period' => "{$days} days",
            'start_date' => date('Y-m-d', strtotime("-{$days} days")),
            'end_date' => date('Y-m-d'),
            'message' => ucfirst($type) . ' statistics coming soon',
            'most_watched' => [],
            'least_watched' => [],
            'user_stats' => [],
            'recent_activity' => [],
            'top_users' => []
        ];
    }

    /**
     * Format duration for display
     */
    private function formatDuration($seconds)
    {
        if ($seconds < 3600) {
            return gmdate('i:s', $seconds);
        } else {
            return gmdate('H:i:s', $seconds);
        }
    }

    /**
     * Get user avatar URL
     */
    private function getUserAvatar($userId, $mediaServer = 'plex')
    {
        switch ($mediaServer) {
            case 'plex':
                return $this->getPlexUserAvatar($userId);
            case 'emby':
                return $this->getEmbyUserAvatar($userId);
            case 'jellyfin':
                return $this->getJellyfinUserAvatar($userId);
            default:
                return '/plugins/images/organizr/user-bg.png';
        }
    }

    /**
     * Get Plex user avatar
     */
    private function getPlexUserAvatar($userId)
    {
        $tautulliUrl = $this->config['plexURL'] ?? '';
        $tautulliToken = $this->config['plexToken'] ?? '';
        
        if (empty($tautulliUrl) || empty($tautulliToken)) {
            return '/plugins/images/organizr/user-bg.png';
        }

        $endpoint = rtrim($tautulliUrl, '/') . "/api/v2";
        $params = [
            'apikey' => $tautulliToken,
            'cmd' => 'get_user_thumb',
            'user_id' => $userId
        ];

        try {
            $response = $this->guzzle->request('GET', $endpoint, [
                'query' => $params,
                'timeout' => 10,
                'connect_timeout' => 10,
                'http_errors' => false
            ]);

            if ($response->getStatusCode() === 200) {
                $data = json_decode($response->getBody(), true);
                return $data['response']['data']['thumb'] ?? '/plugins/images/organizr/user-bg.png';
            }
        } catch (Exception $e) {
            // Return default avatar on error
        }

        return '/plugins/images/organizr/user-bg.png';
    }

    /**
     * Get Emby user avatar
     */
    private function getEmbyUserAvatar($userId)
    {
        // Implement Emby avatar logic
        return '/plugins/images/organizr/user-bg.png';
    }

    /**
     * Get Jellyfin user avatar
     */
    private function getJellyfinUserAvatar($userId)
    {
        // Implement Jellyfin avatar logic
        return '/plugins/images/organizr/user-bg.png';
    }
}