import time import logging import sys from typing import Dict, Any, List # Configure logging logging.basicConfig( level=logging.INFO, format='%(asctime)s.%(msecs)03d - %(levelname)s:%(name)s:%(message)s', datefmt='%H:%M:%S', stream=sys.stdout ) from src.clock import Clock from src.weather_manager import WeatherManager from src.display_manager import DisplayManager from src.config_manager import ConfigManager from src.stock_manager import StockManager from src.stock_news_manager import StockNewsManager from src.nhl_managers import NHLLiveManager, NHLRecentManager, NHLUpcomingManager from src.nba_managers import NBALiveManager, NBARecentManager, NBAUpcomingManager from src.mlb_manager import MLBLiveManager, MLBRecentManager, MLBUpcomingManager from src.soccer_managers import SoccerLiveManager, SoccerRecentManager, SoccerUpcomingManager from src.nfl_managers import NFLLiveManager, NFLRecentManager, NFLUpcomingManager from src.ncaa_fb_managers import NCAAFBLiveManager, NCAAFBRecentManager, NCAAFBUpcomingManager from src.youtube_display import YouTubeDisplay from src.calendar_manager import CalendarManager from src.text_display import TextDisplay from src.music_manager import MusicManager # Get logger without configuring logger = logging.getLogger(__name__) class DisplayController: def __init__(self): start_time = time.time() logger.info("Starting DisplayController initialization") self.config_manager = ConfigManager() self.config = self.config_manager.load_config() logger.info("Config loaded in %.3f seconds", time.time() - start_time) config_time = time.time() self.display_manager = DisplayManager(self.config) logger.info("DisplayManager initialized in %.3f seconds", time.time() - config_time) # Initialize display modes init_time = time.time() self.clock = Clock(self.display_manager) if self.config.get('clock', {}).get('enabled', True) else None self.weather = WeatherManager(self.config, self.display_manager) if self.config.get('weather', {}).get('enabled', False) else None self.stocks = StockManager(self.config, self.display_manager) if self.config.get('stocks', {}).get('enabled', False) else None self.news = StockNewsManager(self.config, self.display_manager) if self.config.get('stock_news', {}).get('enabled', False) else None self.calendar = CalendarManager(self.display_manager, self.config) if self.config.get('calendar', {}).get('enabled', False) else None self.youtube = YouTubeDisplay(self.display_manager, self.config) if self.config.get('youtube', {}).get('enabled', False) else None self.text_display = TextDisplay(self.display_manager, self.config) if self.config.get('text_display', {}).get('enabled', False) else None logger.info(f"Calendar Manager initialized: {'Object' if self.calendar else 'None'}") logger.info(f"Text Display initialized: {'Object' if self.text_display else 'None'}") logger.info("Display modes initialized in %.3f seconds", time.time() - init_time) # Initialize Music Manager music_init_time = time.time() self.music_manager = None if hasattr(self, 'config'): music_config_main = self.config.get('music', {}) if music_config_main.get('enabled', False): try: # Pass display_manager and config. The callback is now optional for MusicManager. # DisplayController might not need a specific music update callback anymore if MusicManager handles all display. self.music_manager = MusicManager(display_manager=self.display_manager, config=self.config, update_callback=self._handle_music_update) if self.music_manager.enabled: logger.info("MusicManager initialized successfully.") self.music_manager.start_polling() else: logger.info("MusicManager initialized but is internally disabled or failed to load its own config.") self.music_manager = None except Exception as e: logger.error(f"Failed to initialize MusicManager: {e}", exc_info=True) self.music_manager = None else: logger.info("Music module is disabled in main configuration (config.json).") else: logger.error("Config not loaded before MusicManager initialization attempt.") logger.info("MusicManager initialized in %.3f seconds", time.time() - music_init_time) # Initialize NHL managers if enabled nhl_time = time.time() nhl_enabled = self.config.get('nhl_scoreboard', {}).get('enabled', False) nhl_display_modes = self.config.get('nhl_scoreboard', {}).get('display_modes', {}) if nhl_enabled: self.nhl_live = NHLLiveManager(self.config, self.display_manager) if nhl_display_modes.get('nhl_live', True) else None self.nhl_recent = NHLRecentManager(self.config, self.display_manager) if nhl_display_modes.get('nhl_recent', True) else None self.nhl_upcoming = NHLUpcomingManager(self.config, self.display_manager) if nhl_display_modes.get('nhl_upcoming', True) else None else: self.nhl_live = None self.nhl_recent = None self.nhl_upcoming = None logger.info("NHL managers initialized in %.3f seconds", time.time() - nhl_time) # Initialize NBA managers if enabled nba_time = time.time() nba_enabled = self.config.get('nba_scoreboard', {}).get('enabled', False) nba_display_modes = self.config.get('nba_scoreboard', {}).get('display_modes', {}) if nba_enabled: self.nba_live = NBALiveManager(self.config, self.display_manager) if nba_display_modes.get('nba_live', True) else None self.nba_recent = NBARecentManager(self.config, self.display_manager) if nba_display_modes.get('nba_recent', True) else None self.nba_upcoming = NBAUpcomingManager(self.config, self.display_manager) if nba_display_modes.get('nba_upcoming', True) else None else: self.nba_live = None self.nba_recent = None self.nba_upcoming = None logger.info("NBA managers initialized in %.3f seconds", time.time() - nba_time) # Initialize MLB managers if enabled mlb_time = time.time() mlb_enabled = self.config.get('mlb', {}).get('enabled', False) mlb_display_modes = self.config.get('mlb', {}).get('display_modes', {}) if mlb_enabled: self.mlb_live = MLBLiveManager(self.config, self.display_manager) if mlb_display_modes.get('mlb_live', True) else None self.mlb_recent = MLBRecentManager(self.config, self.display_manager) if mlb_display_modes.get('mlb_recent', True) else None self.mlb_upcoming = MLBUpcomingManager(self.config, self.display_manager) if mlb_display_modes.get('mlb_upcoming', True) else None else: self.mlb_live = None self.mlb_recent = None self.mlb_upcoming = None logger.info("MLB managers initialized in %.3f seconds", time.time() - mlb_time) # Initialize Soccer managers if enabled soccer_time = time.time() soccer_enabled = self.config.get('soccer_scoreboard', {}).get('enabled', False) soccer_display_modes = self.config.get('soccer_scoreboard', {}).get('display_modes', {}) if soccer_enabled: self.soccer_live = SoccerLiveManager(self.config, self.display_manager) if soccer_display_modes.get('soccer_live', True) else None self.soccer_recent = SoccerRecentManager(self.config, self.display_manager) if soccer_display_modes.get('soccer_recent', True) else None self.soccer_upcoming = SoccerUpcomingManager(self.config, self.display_manager) if soccer_display_modes.get('soccer_upcoming', True) else None else: self.soccer_live = None self.soccer_recent = None self.soccer_upcoming = None logger.info("Soccer managers initialized in %.3f seconds", time.time() - soccer_time) # Initialize NFL managers if enabled nfl_time = time.time() nfl_enabled = self.config.get('nfl_scoreboard', {}).get('enabled', False) nfl_display_modes = self.config.get('nfl_scoreboard', {}).get('display_modes', {}) if nfl_enabled: self.nfl_live = NFLLiveManager(self.config, self.display_manager) if nfl_display_modes.get('nfl_live', True) else None self.nfl_recent = NFLRecentManager(self.config, self.display_manager) if nfl_display_modes.get('nfl_recent', True) else None self.nfl_upcoming = NFLUpcomingManager(self.config, self.display_manager) if nfl_display_modes.get('nfl_upcoming', True) else None else: self.nfl_live = None self.nfl_recent = None self.nfl_upcoming = None logger.info("NFL managers initialized in %.3f seconds", time.time() - nfl_time) # Initialize NCAA FB managers if enabled ncaa_fb_time = time.time() ncaa_fb_enabled = self.config.get('ncaa_fb_scoreboard', {}).get('enabled', False) ncaa_fb_display_modes = self.config.get('ncaa_fb_scoreboard', {}).get('display_modes', {}) if ncaa_fb_enabled: self.ncaa_fb_live = NCAAFBLiveManager(self.config, self.display_manager) if ncaa_fb_display_modes.get('ncaa_fb_live', True) else None self.ncaa_fb_recent = NCAAFBRecentManager(self.config, self.display_manager) if ncaa_fb_display_modes.get('ncaa_fb_recent', True) else None self.ncaa_fb_upcoming = NCAAFBUpcomingManager(self.config, self.display_manager) if ncaa_fb_display_modes.get('ncaa_fb_upcoming', True) else None else: self.ncaa_fb_live = None self.ncaa_fb_recent = None self.ncaa_fb_upcoming = None logger.info("NCAA FB managers initialized in %.3f seconds", time.time() - ncaa_fb_time) # Track MLB rotation state self.mlb_current_team_index = 0 self.mlb_showing_recent = True self.mlb_favorite_teams = self.config.get('mlb', {}).get('favorite_teams', []) self.in_mlb_rotation = False # List of available display modes (adjust order as desired) self.available_modes = [] if self.clock: self.available_modes.append('clock') if self.weather: self.available_modes.extend(['weather_current', 'weather_hourly', 'weather_daily']) if self.stocks: self.available_modes.append('stocks') if self.news: self.available_modes.append('stock_news') if self.calendar: self.available_modes.append('calendar') if self.youtube: self.available_modes.append('youtube') if self.text_display: self.available_modes.append('text_display') # Add Music display mode if enabled if self.music_manager: # Will be non-None only if successfully initialized and enabled self.available_modes.append('music') # Add NHL display modes if enabled if nhl_enabled: if self.nhl_recent: self.available_modes.append('nhl_recent') if self.nhl_upcoming: self.available_modes.append('nhl_upcoming') # nhl_live is handled separately when live games are available # Add NBA display modes if enabled if nba_enabled: if self.nba_recent: self.available_modes.append('nba_recent') if self.nba_upcoming: self.available_modes.append('nba_upcoming') # nba_live is handled separately when live games are available # Add MLB display modes if enabled if mlb_enabled: if self.mlb_recent: self.available_modes.append('mlb_recent') # Use recent if mode enabled if self.mlb_upcoming: self.available_modes.append('mlb_upcoming') # Use upcoming if mode enabled # mlb_live is handled separately when live games are available # Add Soccer display modes if enabled if soccer_enabled: if self.soccer_recent: self.available_modes.append('soccer_recent') if self.soccer_upcoming: self.available_modes.append('soccer_upcoming') # soccer_live is handled separately when live games are available # Add NFL display modes if enabled if nfl_enabled: if self.nfl_recent: self.available_modes.append('nfl_recent') if self.nfl_upcoming: self.available_modes.append('nfl_upcoming') # nfl_live is handled separately # Add NCAA FB display modes if enabled if ncaa_fb_enabled: if self.ncaa_fb_recent: self.available_modes.append('ncaa_fb_recent') if self.ncaa_fb_upcoming: self.available_modes.append('ncaa_fb_upcoming') # ncaa_fb_live is handled separately # Set initial display to first available mode (clock) self.current_mode_index = 0 self.current_display_mode = self.available_modes[0] if self.available_modes else 'none' self.last_switch = time.time() self.force_clear = True self.update_interval = 0.01 # Reduced from 0.1 to 0.01 for smoother scrolling # Track team-based rotation states (Add Soccer) self.nhl_current_team_index = 0 self.nhl_showing_recent = True self.nhl_favorite_teams = self.config.get('nhl_scoreboard', {}).get('favorite_teams', []) self.in_nhl_rotation = False self.nba_current_team_index = 0 self.nba_showing_recent = True self.nba_favorite_teams = self.config.get('nba_scoreboard', {}).get('favorite_teams', []) self.in_nba_rotation = False self.soccer_current_team_index = 0 # Soccer rotation state self.soccer_showing_recent = True self.soccer_favorite_teams = self.config.get('soccer_scoreboard', {}).get('favorite_teams', []) self.in_soccer_rotation = False # Add NFL rotation state self.nfl_current_team_index = 0 self.nfl_showing_recent = True self.nfl_favorite_teams = self.config.get('nfl_scoreboard', {}).get('favorite_teams', []) self.in_nfl_rotation = False # Add NCAA FB rotation state self.ncaa_fb_current_team_index = 0 self.ncaa_fb_showing_recent = True self.ncaa_fb_favorite_teams = self.config.get('ncaa_fb_scoreboard', {}).get('favorite_teams', []) self.in_ncaa_fb_rotation = False # Update display durations to include all modes self.display_durations = self.config['display'].get('display_durations', {}) # Add defaults for soccer if missing default_durations = { 'clock': 15, 'weather_current': 15, 'weather_hourly': 15, 'weather_daily': 15, 'stocks': 45, 'stock_news': 30, 'calendar': 30, 'youtube': 30, 'nhl_live': 30, 'nhl_recent': 20, 'nhl_upcoming': 20, 'nba_live': 30, 'nba_recent': 20, 'nba_upcoming': 20, 'mlb_live': 30, 'mlb_recent': 20, 'mlb_upcoming': 20, 'soccer_live': 30, # Soccer durations 'soccer_recent': 20, 'soccer_upcoming': 20, 'nfl_live': 30, # Added NFL durations 'nfl_recent': 30, 'nfl_upcoming': 30, 'ncaa_fb_live': 30, # Added NCAA FB durations 'ncaa_fb_recent': 15, 'ncaa_fb_upcoming': 15, 'music': 20 # Default duration for music, will be overridden by config if present } # Merge loaded durations with defaults for key, value in default_durations.items(): if key not in self.display_durations: self.display_durations[key] = value logger.info("DisplayController initialized with display_manager: %s", id(self.display_manager)) logger.info(f"Available display modes: {self.available_modes}") logger.info(f"NHL Favorite teams: {self.nhl_favorite_teams}") logger.info(f"NBA Favorite teams: {self.nba_favorite_teams}") logger.info(f"MLB Favorite teams: {self.mlb_favorite_teams}") logger.info(f"Soccer Favorite teams: {self.soccer_favorite_teams}") # Log Soccer teams logger.info(f"NFL Favorite teams: {self.nfl_favorite_teams}") # Log NFL teams logger.info(f"NCAA FB Favorite teams: {self.ncaa_fb_favorite_teams}") # Log NCAA FB teams # Removed redundant NHL/MLB init time logs def _handle_music_update(self, track_info: Dict[str, Any]): """Callback for when music track info changes. (Simplified)""" # MusicManager now handles its own display state (album art, etc.) # This callback might still be useful if DisplayController needs to react to music changes # for reasons other than directly re-drawing the music screen (e.g., logging, global state). # For now, we'll keep it simple. If the music screen is active, it will redraw on its own. if track_info: logger.debug(f"DisplayController received music update (via callback): Title - {track_info.get('title')}, Playing - {track_info.get('is_playing')}") else: logger.debug("DisplayController received music update (via callback): Track is None or not playing.") # If the current display mode is music, the MusicManager's display method will be called # in the main loop and will use its own updated internal state. No explicit action needed here # to force a redraw of the music screen itself, unless DisplayController wants to switch TO music mode. # Example: if self.current_display_mode == 'music': self.force_clear = True (but MusicManager.display handles this) def get_current_duration(self) -> int: """Get the duration for the current display mode.""" mode_key = self.current_display_mode # Simplify weather key handling if mode_key.startswith('weather_'): return self.display_durations.get(mode_key, 15) # duration_key = mode_key.split('_', 1)[1] # if duration_key == 'current': duration_key = 'weather_current' # Keep specific keys # elif duration_key == 'hourly': duration_key = 'weather_hourly' # elif duration_key == 'daily': duration_key = 'weather_daily' # else: duration_key = 'weather_current' # Default to current # return self.display_durations.get(duration_key, 15) return self.display_durations.get(mode_key, 15) def _update_modules(self): """Call update methods on active managers.""" if self.weather: self.weather.get_weather() if self.stocks: self.stocks.update_stock_data() if self.news: self.news.update_news_data() if self.calendar: self.calendar.update(time.time()) if self.youtube: self.youtube.update() if self.text_display: self.text_display.update() # Update NHL managers if self.nhl_live: self.nhl_live.update() if self.nhl_recent: self.nhl_recent.update() if self.nhl_upcoming: self.nhl_upcoming.update() # Update NBA managers if self.nba_live: self.nba_live.update() if self.nba_recent: self.nba_recent.update() if self.nba_upcoming: self.nba_upcoming.update() # Update MLB managers if self.mlb_live: self.mlb_live.update() if self.mlb_recent: self.mlb_recent.update() if self.mlb_upcoming: self.mlb_upcoming.update() # Update Soccer managers if self.soccer_live: self.soccer_live.update() if self.soccer_recent: self.soccer_recent.update() if self.soccer_upcoming: self.soccer_upcoming.update() # Update NFL managers if self.nfl_live: self.nfl_live.update() if self.nfl_recent: self.nfl_recent.update() if self.nfl_upcoming: self.nfl_upcoming.update() # Update NCAA FB managers if self.ncaa_fb_live: self.ncaa_fb_live.update() if self.ncaa_fb_recent: self.ncaa_fb_recent.update() if self.ncaa_fb_upcoming: self.ncaa_fb_upcoming.update() def _check_live_games(self) -> tuple[bool, str]: """ Check if there are any live games available. Returns: tuple[bool, str]: (has_live_games, sport_type) sport_type will be 'nhl', 'nba', 'mlb', 'soccer' or None """ # Prioritize sports (e.g., Soccer > NHL > NBA > MLB) if self.soccer_live and self.soccer_live.live_games: return True, 'soccer' if self.nfl_live and self.nfl_live.live_games: logger.debug("NFL live games available") return True, 'nfl' if self.nhl_live and self.nhl_live.live_games: return True, 'nhl' if self.nba_live and self.nba_live.live_games: return True, 'nba' if self.mlb_live and self.mlb_live.live_games: return True, 'mlb' if 'ncaa_fb_scoreboard' in self.config and self.config['ncaa_fb_scoreboard'].get('enabled', False): if self.ncaa_fb_live and self.ncaa_fb_live.live_games: logger.debug("NCAA FB live games available") return True, 'ncaa_fb' # Add more sports checks here (e.g., MLB, Soccer) if 'mlb' in self.config and self.config['mlb'].get('enabled', False): if self.mlb_live and self.mlb_live.live_games: return True, 'mlb' return False, None def _get_team_games(self, team: str, sport: str = 'nhl', is_recent: bool = True) -> bool: """ Get games for a specific team and update the current game. Args: team: Team abbreviation sport: 'nhl', 'nba', 'mlb', or 'soccer' is_recent: Whether to look for recent or upcoming games Returns: bool: True if games were found and set """ manager_recent = None manager_upcoming = None games_list_attr = 'games_list' # Default for NHL/NBA abbr_key_home = 'home_abbr' abbr_key_away = 'away_abbr' if sport == 'nhl': manager_recent = self.nhl_recent manager_upcoming = self.nhl_upcoming elif sport == 'nba': manager_recent = self.nba_recent manager_upcoming = self.nba_upcoming elif sport == 'mlb': manager_recent = self.mlb_recent manager_upcoming = self.mlb_upcoming games_list_attr = 'recent_games' if is_recent else 'upcoming_games' abbr_key_home = 'home_team' # MLB uses different keys abbr_key_away = 'away_team' elif sport == 'soccer': manager_recent = self.soccer_recent manager_upcoming = self.soccer_upcoming games_list_attr = 'games_list' if is_recent else 'upcoming_games' # Soccer uses games_list/upcoming_games elif sport == 'nfl': manager_recent = self.nfl_recent manager_upcoming = self.nfl_upcoming elif sport == 'ncaa_fb': # Add NCAA FB case manager_recent = self.ncaa_fb_recent manager_upcoming = self.ncaa_fb_upcoming else: logger.warning(f"Unsupported sport '{sport}' for team game check") return False manager = manager_recent if is_recent else manager_upcoming if manager and hasattr(manager, games_list_attr): game_list = getattr(manager, games_list_attr, []) for game in game_list: # Need to handle potential missing keys gracefully home_team_abbr = game.get(abbr_key_home) away_team_abbr = game.get(abbr_key_away) if home_team_abbr == team or away_team_abbr == team: manager.current_game = game return True return False def _has_team_games(self, sport: str = 'nhl') -> bool: """Check if there are any games for favorite teams.""" favorite_teams = [] manager_recent = None manager_upcoming = None if sport == 'nhl': favorite_teams = self.nhl_favorite_teams manager_recent = self.nhl_recent manager_upcoming = self.nhl_upcoming elif sport == 'nba': favorite_teams = self.nba_favorite_teams manager_recent = self.nba_recent manager_upcoming = self.nba_upcoming elif sport == 'mlb': favorite_teams = self.mlb_favorite_teams manager_recent = self.mlb_recent manager_upcoming = self.mlb_upcoming elif sport == 'soccer': favorite_teams = self.soccer_favorite_teams manager_recent = self.soccer_recent manager_upcoming = self.soccer_upcoming elif sport == 'nfl': favorite_teams = self.nfl_favorite_teams manager_recent = self.nfl_recent manager_upcoming = self.nfl_upcoming elif sport == 'ncaa_fb': # Add NCAA FB case favorite_teams = self.ncaa_fb_favorite_teams manager_recent = self.ncaa_fb_recent manager_upcoming = self.ncaa_fb_upcoming return bool(favorite_teams and (manager_recent or manager_upcoming)) def _rotate_team_games(self, sport: str = 'nhl') -> None: """Rotate through games for favorite teams. (No longer used directly in loop)""" # This logic is now mostly handled within each manager's display/update # Keeping the structure in case direct rotation is needed later. if not self._has_team_games(sport): return if sport == 'nhl': if not self.nhl_favorite_teams: return current_team = self.nhl_favorite_teams[self.nhl_current_team_index] # ... (rest of NHL rotation logic - now less relevant) elif sport == 'nba': if not self.nba_favorite_teams: return current_team = self.nba_favorite_teams[self.nba_current_team_index] # ... (rest of NBA rotation logic) elif sport == 'mlb': if not self.mlb_favorite_teams: return current_team = self.mlb_favorite_teams[self.mlb_current_team_index] # ... (rest of MLB rotation logic) elif sport == 'soccer': if not self.soccer_favorite_teams: return current_team = self.soccer_favorite_teams[self.soccer_current_team_index] # Try to find games for current team (recent first) found_games = self._get_team_games(current_team, 'soccer', self.soccer_showing_recent) if not found_games: # Try opposite type (upcoming/recent) self.soccer_showing_recent = not self.soccer_showing_recent found_games = self._get_team_games(current_team, 'soccer', self.soccer_showing_recent) if not found_games: # Move to next team if no games found for current one self.soccer_current_team_index = (self.soccer_current_team_index + 1) % len(self.soccer_favorite_teams) self.soccer_showing_recent = True # Reset to recent for the new team # Maybe try finding game for the *new* team immediately? Optional. elif sport == 'nfl': if not self.nfl_favorite_teams: return current_team = self.nfl_favorite_teams[self.nfl_current_team_index] # Try to find games for current team (recent first) found_games = self._get_team_games(current_team, 'nfl', self.nfl_showing_recent) if not found_games: # Try opposite type (upcoming/recent) self.nfl_showing_recent = not self.nfl_showing_recent found_games = self._get_team_games(current_team, 'nfl', self.nfl_showing_recent) if not found_games: # Move to next team if no games found for current one self.nfl_current_team_index = (self.nfl_current_team_index + 1) % len(self.nfl_favorite_teams) self.nfl_showing_recent = True # Reset to recent for the new team elif sport == 'ncaa_fb': # Add NCAA FB case if not self.ncaa_fb_favorite_teams: return current_team = self.ncaa_fb_favorite_teams[self.ncaa_fb_current_team_index] # Try to find games for current team (recent first) found_games = self._get_team_games(current_team, 'ncaa_fb', self.ncaa_fb_showing_recent) if not found_games: # Try opposite type (upcoming/recent) self.ncaa_fb_showing_recent = not self.ncaa_fb_showing_recent found_games = self._get_team_games(current_team, 'ncaa_fb', self.ncaa_fb_showing_recent) if not found_games: # Move to next team if no games found for current one self.ncaa_fb_current_team_index = (self.ncaa_fb_current_team_index + 1) % len(self.ncaa_fb_favorite_teams) self.ncaa_fb_showing_recent = True # Reset to recent for the new team def run(self): """Run the display controller, switching between displays.""" if not self.available_modes: logger.warning("No display modes are enabled. Exiting.") self.display_manager.cleanup() return try: while True: current_time = time.time() # Update data for all modules first self._update_modules() # Check for live games has_live_games, live_sport_type = self._check_live_games() is_currently_live = self.current_display_mode.endswith('_live') manager_to_display = None # Manager instance for the current frame # --- State Machine for Display Logic --- if is_currently_live: # --- Currently in a Live Game Mode --- if has_live_games: # Still live games available, check timer for rotation or continuation if current_time - self.last_switch >= self.get_current_duration(): # Timer expired for the current live game, decide next step logger.debug(f"Timer expired for live mode {self.current_display_mode}. Checking for rotation.") active_live_sports = [] # Use the same priority order as _check_live_games priority_order = ['soccer', 'nfl', 'nhl', 'nba', 'mlb', 'ncaa_fb'] for sport in priority_order: live_attr = f"{sport}_live" if hasattr(self, live_attr) and getattr(self, live_attr) and getattr(self, live_attr).live_games: active_live_sports.append(sport) logger.debug(f"Active live sports found: {active_live_sports}") if not active_live_sports: # Should not happen if has_live_games is True, but handle defensively logger.warning("In live mode, timer expired, but no active sports found. Falling back.") # Fallback: Exit live mode logic will handle this below implicitly is_currently_live = False # Force exit from live block has_live_games = False # Ensure we enter regular rotation block elif len(active_live_sports) == 1: # Only one sport is live, stay on it (or switch if mode mismatch) new_mode = f"{active_live_sports[0]}_live" if self.current_display_mode != new_mode: logger.info(f"Switching to only active live sport: {new_mode} from {self.current_display_mode}") self.current_display_mode = new_mode self.force_clear = True else: logger.debug(f"Staying on single active live sport: {self.current_display_mode}") self.force_clear = False # Just resetting timer, no need to clear self.last_switch = current_time manager_to_display = getattr(self, f"{active_live_sports[0]}_live", None) else: # Multiple sports live, rotate try: current_sport = self.current_display_mode.replace('_live', '') current_index = active_live_sports.index(current_sport) next_index = (current_index + 1) % len(active_live_sports) next_sport = active_live_sports[next_index] next_mode = f"{next_sport}_live" logger.info(f"Rotating live sports: {self.current_display_mode} -> {next_mode}") self.current_display_mode = next_mode self.force_clear = True self.last_switch = current_time manager_to_display = getattr(self, f"{next_sport}_live", None) except ValueError: # Current sport is no longer active, switch to highest priority active one logger.warning(f"Current live sport {current_sport} not found in active list {active_live_sports}. Switching to highest priority.") next_sport = active_live_sports[0] next_mode = f"{next_sport}_live" self.current_display_mode = next_mode self.force_clear = True self.last_switch = current_time manager_to_display = getattr(self, f"{next_sport}_live", None) else: # Timer not expired, continue showing current live game logger.debug(f"Continuing live mode {self.current_display_mode}. Timer not expired.") self.force_clear = False current_sport_type = self.current_display_mode.replace('_live', '') manager_to_display = getattr(self, f"{current_sport_type}_live", None) else: # Was in live mode, but no live games detected *now*. Switch OUT. logger.info(f"Exiting live mode {self.current_display_mode} as no live games detected.") # Fall through to the 'not is_currently_live' block below is_currently_live = False # Update state for the next block # Let the regular mode selection logic handle the transition if not is_currently_live: # --- Currently in a Regular Mode (or just exited Live) --- if has_live_games: # Not currently live, but live games ARE available. Switch IN. # (This check ensures we only switch *in* if we weren't already live) new_mode = f"{live_sport_type}_live" # live_sport_type has the highest priority if self.current_display_mode != new_mode: # Avoid unnecessary resets if somehow already correct logger.info(f"Switching into LIVE mode: {new_mode} from {self.current_display_mode}") self.current_display_mode = new_mode self.force_clear = True self.last_switch = current_time manager_to_display = getattr(self, f"{live_sport_type}_live", None) else: # Should technically not happen based on is_currently_live flag, but safety first self.force_clear = False self.last_switch = current_time # Reset timer anyway manager_to_display = getattr(self, f"{live_sport_type}_live", None) else: # No live games detected, and not in live mode. Regular rotation. needs_switch = False if self.current_display_mode.endswith('_live'): # This case handles the explicit transition OUT of live mode # initiated in the block above. logger.info(f"Transitioning from live mode to regular rotation.") needs_switch = True # Find the next *regular* mode index cleanly try: # Find where we *would* be if we weren't live # This assumes self.current_mode_index tracks the regular rotation position self.current_mode_index = (self.current_mode_index + 1) % len(self.available_modes) except Exception: # Catch potential issues if available_modes changed etc. logger.warning("Error advancing regular mode index after live mode exit. Resetting.") self.current_mode_index = 0 if not self.available_modes: # Safety check logger.error("No available regular modes to switch to!") self.current_display_mode = 'none' # Or handle error appropriately # Consider exiting or sleeping else: self.current_display_mode = self.available_modes[self.current_mode_index] elif current_time - self.last_switch >= self.get_current_duration(): # Regular timer expired, advance to next mode logger.debug(f"Timer expired for regular mode {self.current_display_mode}. Switching.") # Advance calendar event *before* potentially switching away if self.current_display_mode == 'calendar' and self.calendar: self.calendar.advance_event() needs_switch = True self.current_mode_index = (self.current_mode_index + 1) % len(self.available_modes) self.current_display_mode = self.available_modes[self.current_mode_index] if needs_switch: logger.info(f"Switching to regular mode: {self.current_display_mode}") self.force_clear = True self.last_switch = current_time else: # Timer not expired for current regular mode self.force_clear = False # Select the manager for the current regular mode # (This code block is largely the same as before) if self.current_display_mode == 'clock' and self.clock: manager_to_display = self.clock elif self.current_display_mode == 'weather_current' and self.weather: manager_to_display = self.weather elif self.current_display_mode == 'weather_hourly' and self.weather: manager_to_display = self.weather elif self.current_display_mode == 'weather_daily' and self.weather: manager_to_display = self.weather elif self.current_display_mode == 'stocks' and self.stocks: manager_to_display = self.stocks elif self.current_display_mode == 'stock_news' and self.news: manager_to_display = self.news elif self.current_display_mode == 'calendar' and self.calendar: manager_to_display = self.calendar elif self.current_display_mode == 'youtube' and self.youtube: manager_to_display = self.youtube elif self.current_display_mode == 'text_display' and self.text_display: manager_to_display = self.text_display # Add other regular managers (NHL recent/upcoming, NBA, MLB, Soccer, NFL, NCAA FB) elif self.current_display_mode == 'nhl_recent' and self.nhl_recent: manager_to_display = self.nhl_recent elif self.current_display_mode == 'nhl_upcoming' and self.nhl_upcoming: manager_to_display = self.nhl_upcoming elif self.current_display_mode == 'nba_recent' and self.nba_recent: manager_to_display = self.nba_recent elif self.current_display_mode == 'nba_upcoming' and self.nba_upcoming: manager_to_display = self.nba_upcoming elif self.current_display_mode == 'mlb_recent' and self.mlb_recent: manager_to_display = self.mlb_recent elif self.current_display_mode == 'mlb_upcoming' and self.mlb_upcoming: manager_to_display = self.mlb_upcoming elif self.current_display_mode == 'soccer_recent' and self.soccer_recent: manager_to_display = self.soccer_recent elif self.current_display_mode == 'soccer_upcoming' and self.soccer_upcoming: manager_to_display = self.soccer_upcoming elif self.current_display_mode == 'nfl_recent' and self.nfl_recent: manager_to_display = self.nfl_recent elif self.current_display_mode == 'nfl_upcoming' and self.nfl_upcoming: manager_to_display = self.nfl_upcoming elif self.current_display_mode == 'ncaa_fb_recent' and self.ncaa_fb_recent: manager_to_display = self.ncaa_fb_recent elif self.current_display_mode == 'ncaa_fb_upcoming' and self.ncaa_fb_upcoming: manager_to_display = self.ncaa_fb_upcoming # --- Perform Display Update --- try: if self.current_display_mode == 'music' and self.music_manager: # Call MusicManager's display method self.music_manager.display(force_clear=self.force_clear) # Reset force_clear if it was true for this mode if self.force_clear: self.force_clear = False elif manager_to_display: logger.debug(f"Attempting to display mode: {self.current_display_mode} using manager {type(manager_to_display).__name__} with force_clear={self.force_clear}") # Call the appropriate display method based on mode/manager type # Note: Some managers have different display methods or handle clearing internally if self.current_display_mode == 'clock': manager_to_display.display_time(force_clear=self.force_clear) elif self.current_display_mode == 'weather_current': manager_to_display.display_weather(force_clear=self.force_clear) elif self.current_display_mode == 'weather_hourly': manager_to_display.display_hourly_forecast(force_clear=self.force_clear) elif self.current_display_mode == 'weather_daily': manager_to_display.display_daily_forecast(force_clear=self.force_clear) elif self.current_display_mode == 'stocks': manager_to_display.display_stocks(force_clear=self.force_clear) elif self.current_display_mode == 'stock_news': manager_to_display.display_news() # Assumes internal clearing elif self.current_display_mode == 'calendar': manager_to_display.display(force_clear=self.force_clear) elif self.current_display_mode == 'youtube': manager_to_display.display(force_clear=self.force_clear) elif self.current_display_mode == 'text_display': manager_to_display.display() # Assumes internal clearing elif hasattr(manager_to_display, 'display'): # General case for most managers manager_to_display.display(force_clear=self.force_clear) else: logger.warning(f"Manager {type(manager_to_display).__name__} for mode {self.current_display_mode} does not have a standard 'display' method.") # Reset force_clear *after* a successful display call that used it # Important: Only reset if the display method *might* have used it. # Internal clearing methods (news, text) don't necessitate resetting it here. if self.force_clear and self.current_display_mode not in ['stock_news', 'text_display']: self.force_clear = False elif self.current_display_mode != 'none': logger.warning(f"No manager found or selected for display mode: {self.current_display_mode}") except Exception as e: logger.error(f"Error during display update for mode {self.current_display_mode}: {e}", exc_info=True) # Force clear on the next iteration after an error to be safe self.force_clear = True # Small sleep removed - updates/drawing should manage timing # time.sleep(self.update_interval) except KeyboardInterrupt: logger.info("Display controller stopped by user") except Exception as e: logger.error(f"Critical error in display controller run loop: {e}", exc_info=True) finally: logger.info("Cleaning up display manager...") self.display_manager.cleanup() if self.music_manager: # Check if music_manager object exists logger.info("Stopping music polling...") self.music_manager.stop_polling() logger.info("Cleanup complete.") def main(): controller = DisplayController() controller.run() if __name__ == "__main__": main()