feat: implement core Screen trait architecture

Add foundational components for the new screen management system:

- Screen trait: Unified interface for all game screens with init, update,
  render, and event handling methods
- ScreenTransitionManager: Manages screen transitions and state changes
- GameData: Global game state management with thread-safe access
- SessionManager: Handles game session lifecycle and state
- StageRepository: Manages game stages and difficulty levels

These components provide the foundation for the refactored screen system
with better separation of concerns and unified rendering backends.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: unhappychoice

src/game/game_data.rs

@@ -0,0 +1,169 @@
+use crate::extractor::ExtractionOptions;
+use crate::models::{Challenge, GitRepository};
+use crate::Result;
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex, OnceLock};
+
+/// Global game data that persists across screens
+#[derive(Debug, Default)]
+pub struct GameData {
+    pub challenges: Option<Vec<Challenge>>,
+    pub git_repository: Option<GitRepository>,
+    pub loading_completed: bool,
+    pub loading_failed: bool,
+    pub error_message: Option<String>,
+    // Processing parameters
+    pub repo_spec: Option<String>,
+    pub repo_path: Option<PathBuf>,
+    pub extraction_options: Option<ExtractionOptions>,
+}
+
+static GLOBAL_GAME_DATA: OnceLock<Arc<Mutex<GameData>>> = OnceLock::new();
+
+impl GameData {
+    /// Initialize the global game data instance
+    pub fn initialize() -> Result<()> {
+        let game_data = Arc::new(Mutex::new(GameData::default()));
+        GLOBAL_GAME_DATA.set(game_data).map_err(|_| {
+            crate::GitTypeError::TerminalError("GameData already initialized".to_string())
+        })?;
+        Ok(())
+    }
+
+    /// Get a reference to the global game data instance
+    pub fn instance() -> Arc<Mutex<GameData>> {
+        GLOBAL_GAME_DATA
+            .get()
+            .expect("GameData not initialized")
+            .clone()
+    }
+
+    /// Reset the global game data
+    pub fn reset() -> Result<()> {
+        if let Some(game_data) = GLOBAL_GAME_DATA.get() {
+            let mut data = game_data.lock().unwrap();
+            *data = GameData::default();
+        }
+        Ok(())
+    }
+
+    /// Set processing parameters
+    pub fn set_processing_parameters(
+        repo_spec: Option<&str>,
+        repo_path: Option<&PathBuf>,
+        extraction_options: &ExtractionOptions,
+    ) -> Result<()> {
+        let game_data = Self::instance();
+        let mut data = game_data.lock().unwrap();
+        data.repo_spec = repo_spec.map(|s| s.to_string());
+        data.repo_path = repo_path.cloned();
+        data.extraction_options = Some(extraction_options.clone());
+        Ok(())
+    }
+
+    /// Get processing parameters
+    pub fn get_processing_parameters(
+    ) -> Option<(Option<String>, Option<PathBuf>, ExtractionOptions)> {
+        if let Some(game_data) = GLOBAL_GAME_DATA.get() {
+            let data = game_data.lock().unwrap();
+            data.extraction_options.as_ref().map(|options| {
+                (
+                    data.repo_spec.clone(),
+                    data.repo_path.clone(),
+                    options.clone(),
+                )
+            })
+        } else {
+            None
+        }
+    }
+
+    /// Set the processing results
+    pub fn set_results(
+        challenges: Vec<Challenge>,
+        git_repository: Option<GitRepository>,
+    ) -> Result<()> {
+        let game_data = Self::instance();
+        let mut data = game_data.lock().unwrap();
+        data.challenges = Some(challenges);
+        data.git_repository = git_repository;
+        data.loading_completed = true;
+
+        Ok(())
+    }
+
+    /// Set loading failure
+    pub fn set_loading_failed(error_message: String) -> Result<()> {
+        let game_data = Self::instance();
+        let mut data = game_data.lock().unwrap();
+        data.loading_failed = true;
+        data.error_message = Some(error_message);
+        Ok(())
+    }
+
+    /// Check if loading is completed
+    pub fn is_loading_completed() -> bool {
+        if let Some(game_data) = GLOBAL_GAME_DATA.get() {
+            let data = game_data.lock().unwrap();
+            data.loading_completed
+        } else {
+            false
+        }
+    }
+
+    /// Check if loading failed
+    pub fn is_loading_failed() -> bool {
+        if let Some(game_data) = GLOBAL_GAME_DATA.get() {
+            let data = game_data.lock().unwrap();
+            data.loading_failed
+        } else {
+            false
+        }
+    }
+
+    /// Get reference to challenges with callback (to avoid lifetime issues)
+    pub fn with_challenges<F, R>(f: F) -> Option<R>
+    where
+        F: FnOnce(&Vec<Challenge>) -> R,
+    {
+        if let Some(game_data) = GLOBAL_GAME_DATA.get() {
+            let data = game_data.lock().unwrap();
+            data.challenges.as_ref().map(f)
+        } else {
+            None
+        }
+    }
+
+    /// Take the challenges (move out of GameData)
+    pub fn take_challenges() -> Option<Vec<Challenge>> {
+        if let Some(game_data) = GLOBAL_GAME_DATA.get() {
+            let mut data = game_data.lock().unwrap();
+            data.challenges.take()
+        } else {
+            None
+        }
+    }
+
+    /// Get the git repository if available
+    pub fn get_git_repository() -> Option<GitRepository> {
+        if let Some(game_data) = GLOBAL_GAME_DATA.get() {
+            let data = game_data.lock().unwrap();
+            data.git_repository.clone()
+        } else {
+            None
+        }
+    }
+
+    /// Set git repository information directly
+    pub fn set_git_repository(git_repository: Option<GitRepository>) -> Result<()> {
+        if let Some(game_data) = GLOBAL_GAME_DATA.get() {
+            let mut data = game_data.lock().unwrap();
+            data.git_repository = git_repository;
+            Ok(())
+        } else {
+            Err(crate::GitTypeError::TerminalError(
+                "GameData not initialized".to_string(),
+            ))
+        }
+    }
+}

src/game/models/screen.rs

@@ -0,0 +1,105 @@
+use crate::Result;
+use crossterm::event::KeyEvent;
+use std::io::Stdout;
+use std::time::Duration;
+
+/// Screen type identifiers for different application screens
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum ScreenType {
+    Title,
+    Loading,
+    Typing,
+    StageSummary,
+    SessionSummary,
+    TotalSummary,
+    TotalSummaryShare,
+    SessionFailure,
+    History,
+    Analytics,
+    SessionDetail,
+    SessionSharing,
+    Animation,
+    VersionCheck,
+    InfoDialog,
+    DetailsDialog,
+}
+
+/// Update strategy defines how and when a screen should be updated and re-rendered
+#[derive(Debug, Clone)]
+pub enum UpdateStrategy {
+    /// Screen only updates when user provides input
+    InputOnly,
+    /// Screen updates at regular time intervals
+    TimeBased(Duration),
+    /// Screen combines both input and time-based updates
+    Hybrid {
+        /// Time interval for automatic updates
+        interval: Duration,
+        /// Whether input events should trigger immediate updates
+        input_priority: bool,
+    },
+}
+
+/// Screen transition actions that can be returned from input handling
+#[derive(Debug, Clone)]
+pub enum ScreenTransition {
+    /// No transition - stay on current screen
+    None,
+    /// Push new screen onto the stack
+    Push(ScreenType),
+    /// Pop current screen from stack
+    Pop,
+    /// Replace current screen with new screen
+    Replace(ScreenType),
+    /// Pop screens until reaching the specified screen type
+    PopTo(ScreenType),
+    /// Exit the application
+    Exit,
+}
+
+/// The Screen trait defines the interface that all screens must implement
+pub trait Screen: Send {
+    /// Initialize the screen - called when screen becomes active
+    fn init(&mut self) -> Result<()> {
+        Ok(())
+    }
+
+    /// Handle keyboard input events and return appropriate screen transition
+    fn handle_key_event(&mut self, key_event: KeyEvent) -> Result<ScreenTransition>;
+
+    /// Render the screen with access to shared data
+    fn render_crossterm_with_data(
+        &mut self,
+        stdout: &mut Stdout,
+        session_result: Option<&crate::models::SessionResult>,
+        total_result: Option<&crate::scoring::TotalResult>,
+    ) -> Result<()>;
+
+    /// Render the screen using ratatui backend (optional)
+    fn render_ratatui(&mut self, _frame: &mut ratatui::Frame) -> Result<()> {
+        // Default implementation for backward compatibility
+        // Individual screens can override this when ratatui support is needed
+        Ok(())
+    }
+
+    /// Clean up screen resources - called when screen becomes inactive
+    fn cleanup(&mut self) -> Result<()> {
+        Ok(())
+    }
+
+    /// Get the update strategy for this screen
+    fn get_update_strategy(&self) -> UpdateStrategy {
+        UpdateStrategy::InputOnly
+    }
+
+    /// Update screen state and return whether a re-render is needed
+    fn update(&mut self) -> Result<bool> {
+        Ok(false)
+    }
+
+    /// Downcast to Any for type-specific access (read-only)
+    fn as_any(&self) -> &dyn std::any::Any;
+
+    /// Downcast to Any for type-specific access (mutable)
+    fn as_any_mut(&mut self) -> &mut dyn std::any::Any;
+}