record-daemon: refactor client.rs, dropping metadata

record-daemon/src/lqp/client.rs

@@ -12,14 +12,13 @@ use tracing::{debug, error, info, trace, warn};
 
 use super::api_types::{
     ActivePlayerResponse, ChampionSelectResponse, EndOfGameStatsResponse, GameflowSessionResponse,
-    PlayerListResponse, RunePageResponse, SummonerResponse,
+    PlayerListResponse, PreGameData, RunePageResponse, SummonerResponse,
 };
 use super::auth::LockfileCredentials;
 use super::endpoints;
 use super::events::{GameEvent, ItemBuild};
 use super::items::{parse_items_from_game_stats, parse_items_from_live_client};
 use super::mappings::{champion_id_to_name, spell_id_to_name};
-use super::metadata::{GameEndMetadata, PreGameMetadata};
 use super::state::{ClientState, GameflowPhase};
 use super::tls::create_insecure_tls_config;
 use super::websocket::parse_websocket_message;
@@ -478,69 +477,47 @@ impl LqpClient {
     // Metadata Fetching Methods
     // =========================================================================
 
-    /// Fetch pre-game metadata (champion, skin, runes, queue info).
-    pub async fn fetch_pregame_metadata(&self) -> Result<PreGameMetadata> {
-        let mut metadata = PreGameMetadata::default();
+    /// Fetch pre-game data (stores raw API responses directly).
+    pub async fn fetch_pregame_data(&self) -> Result<PreGameData> {
+        let mut data = PreGameData::default();
 
-        // Get session info for queue type and game mode
-        if let Ok(session) = self.get_session_typed().await {
-            metadata.map_name = session.map;
-            metadata.game_mode = session.game_mode;
-            metadata.queue_id = session.queue_id.map(|id| id as u32);
+        // Fetch all API responses in parallel where possible
+        let (session, summoner, champ_select, rune_page) = tokio::join!(
+            self.get_session_typed(),
+            self.get_summoner_typed(),
+            self.get_champion_select_typed(),
+            self.get_rune_page_typed()
+        );
+
+        // Store session data
+        if let Ok(session) = session {
+            data.session = Some(session);
         }
 
-        // Get summoner info (including puuid)
-        if let Ok(summoner) = self.get_summoner_typed().await {
-            metadata.summoner_name = summoner.display_name;
-            if let Some(puuid) = &summoner.puuid {
+        // Store summoner data and update state
+        if let Ok(summoner) = summoner {
+            if let Some(ref puuid) = summoner.puuid {
                 self.state.write().await.local_puuid = Some(puuid.clone());
             }
-            metadata.local_puuid = summoner.puuid;
+            data.summoner = Some(summoner);
         }
 
-        // Get champion select info
-        if let Ok(champ_select) = self.get_champion_select_typed().await {
-            if let Some(player) = champ_select.get_local_player_selection() {
-                metadata.champion_id = player.champion_id.map(|id| id as u32);
-                metadata.team = player.team.map(|id| id as u32);
-                metadata.skin_id = player.skin_id.map(|id| id as u32);
-            }
+        // Store champion select data
+        if let Ok(champ_select) = champ_select {
+            data.champion_select = Some(champ_select);
         }
 
-        // Get rune page
-        if let Ok(rune_page) = self.get_rune_page_typed().await {
-            metadata.rune_page_name = rune_page.name;
+        // Store rune page data
+        if let Ok(rune_page) = rune_page {
+            data.rune_page = Some(rune_page);
         }
 
-        Ok(metadata)
+        Ok(data)
     }
 
-    /// Fetch end-of-game stats.
-    pub async fn fetch_game_end_stats(&self) -> Result<GameEndMetadata> {
-        let mut metadata = GameEndMetadata::default();
-
-        if let Ok(stats) = self.get_game_stats_typed().await {
-            metadata.victory = Some(stats.is_victory());
-            metadata.game_duration = stats.game_length.unwrap_or(0.0);
-            metadata.match_id = stats.match_id.map(|id| id.to_string());
-
-            // Extract player stats
-            if let Some(player) = stats.get_local_player() {
-                if let Some(player_stats) = &player.stats {
-                    metadata.kills = player_stats.champions_killed.unwrap_or(0) as u32;
-                    metadata.deaths = player_stats.num_deaths.unwrap_or(0) as u32;
-                    metadata.assists = player_stats.assists.unwrap_or(0) as u32;
-                    metadata.creep_score = player_stats.minions_killed.unwrap_or(0) as u32;
-                    metadata.gold_earned = player_stats.gold_earned.unwrap_or(0) as u32;
-                    metadata.damage_dealt =
-                        player_stats.total_damage_dealt_to_champions.unwrap_or(0);
-                    metadata.damage_taken = player_stats.total_damage_taken.unwrap_or(0);
-                    metadata.vision_score = player_stats.vision_score.unwrap_or(0.0);
-                }
-            }
-        }
-
-        Ok(metadata)
+    /// Fetch end-of-game stats (returns raw API response).
+    pub async fn fetch_game_end_stats(&self) -> Result<EndOfGameStatsResponse> {
+        self.get_game_stats_typed().await
     }
 
     /// Fetch complete player game metadata including runes, summoner spells, and items.