feat: add achievement cache and progress bar

Cargo.toml

@@ -23,3 +23,4 @@ thiserror = "2"
 anyhow = "1"
 steamworks = { version = "0.12", features = ["raw-bindings"] }
 libloading = "0.8"
+indicatif = "0.17"

src/cache.rs

@@ -0,0 +1,66 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::fs;
+use std::path::PathBuf;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CachedAchievement {
+    pub last_played: u64,
+    pub achieved: u32,
+    pub total: u32,
+    pub rarest_name: Option<String>,
+    pub rarest_percent: Option<f64>,
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct AchievementCache {
+    games: HashMap<u32, CachedAchievement>,
+}
+
+impl AchievementCache {
+    pub fn load() -> Self {
+        cache_path()
+            .and_then(|p| fs::read_to_string(p).ok())
+            .and_then(|s| serde_json::from_str(&s).ok())
+            .unwrap_or_default()
+    }
+
+    pub fn save(&self) {
+        if let Some(path) = cache_path() {
+            if let Some(parent) = path.parent() {
+                let _ = fs::create_dir_all(parent);
+            }
+            let _ = fs::write(path, serde_json::to_string(self).unwrap_or_default());
+        }
+    }
+
+    pub fn get(&self, appid: u32, last_played: u64) -> Option<&CachedAchievement> {
+        self.games
+            .get(&appid)
+            .filter(|c| c.last_played == last_played)
+    }
+
+    pub fn set(
+        &mut self,
+        appid: u32,
+        last_played: u64,
+        achieved: u32,
+        total: u32,
+        rarest: Option<(&str, f64)>,
+    ) {
+        self.games.insert(
+            appid,
+            CachedAchievement {
+                last_played,
+                achieved,
+                total,
+                rarest_name: rarest.map(|(n, _)| n.to_string()),
+                rarest_percent: rarest.map(|(_, p)| p),
+            },
+        );
+    }
+}
+
+fn cache_path() -> Option<PathBuf> {
+    dirs::cache_dir().map(|p| p.join("steamfetch").join("achievements.json"))
+}

src/main.rs

@@ -1,3 +1,4 @@
+mod cache;
 mod config;
 mod display;
 mod steam;

src/steam/client.rs

@@ -1,12 +1,13 @@
 use anyhow::{Context, Result};
-use futures::future::join_all;
+use indicatif::{ProgressBar, ProgressStyle};
 use reqwest::Client;
 use std::time::Duration;
 
 use super::models::{
     AchievementStats, AchievementsResponse, GameStat, GlobalAchievementsResponse,
     OwnedGamesResponse, PlayerSummaryResponse, RarestAchievement, SteamStats,
 };
+use crate::cache::AchievementCache;
 
 const BASE_URL: &str = "https://api.steampowered.com";
 
@@ -104,6 +105,9 @@ impl SteamClient {
                         .get(&appid)
                         .map_or(0, |g| g.playtime_forever),
                     playtime_2weeks: 0,
+                    rtime_last_played: games_with_playtime
+                        .get(&appid)
+                        .map_or(0, |g| g.rtime_last_played),
                 })
                 .collect(),
         };
@@ -307,32 +311,75 @@ impl SteamClient {
         &self,
         games: &super::models::OwnedGamesData,
     ) -> Option<AchievementStats> {
-        let all_games = self.get_all_games(games);
-        let results = join_all(
-            all_games
-                .iter()
-                .map(|(appid, name)| self.fetch_game_achievements(*appid, name.clone())),
-        )
-        .await;
+        let mut cache = AchievementCache::load();
+        let all_games: Vec<_> = games.games.iter().collect();
+
+        let pb = ProgressBar::new(all_games.len() as u64);
+        pb.set_style(
+            ProgressStyle::default_bar()
+                .template("{spinner:.green} [{bar:40.cyan/blue}] {pos}/{len} games")
+                .unwrap()
+                .progress_chars("#>-"),
+        );
 
         let mut total_achieved = 0u32;
         let mut total_possible = 0u32;
         let mut perfect_games = 0u32;
         let mut rarest_candidates: Vec<RarestAchievement> = Vec::new();
 
-        for result in results.into_iter().flatten() {
-            total_achieved += result.achieved;
-            total_possible += result.total;
-
-            if result.achieved == result.total && result.total > 0 {
-                perfect_games += 1;
+        for game in &all_games {
+            pb.inc(1);
+            let game_name = game
+                .name
+                .clone()
+                .unwrap_or_else(|| format!("App {}", game.appid));
+
+            // Check cache first
+            if let Some(cached) = cache.get(game.appid, game.rtime_last_played) {
+                total_achieved += cached.achieved;
+                total_possible += cached.total;
+                if cached.achieved == cached.total && cached.total > 0 {
+                    perfect_games += 1;
+                }
+                if let (Some(name), Some(percent)) = (&cached.rarest_name, cached.rarest_percent) {
+                    rarest_candidates.push(RarestAchievement {
+                        name: name.clone(),
+                        game: game_name,
+                        percent,
+                    });
+                }
+                continue;
             }
 
-            if let Some(r) = result.rarest {
-                rarest_candidates.push(r);
+            // Fetch from API
+            if let Some(result) = self
+                .fetch_game_achievements(game.appid, game_name.clone())
+                .await
+            {
+                total_achieved += result.achieved;
+                total_possible += result.total;
+                if result.achieved == result.total && result.total > 0 {
+                    perfect_games += 1;
+                }
+
+                let rarest_for_cache = result.rarest.as_ref().map(|r| (r.name.as_str(), r.percent));
+                cache.set(
+                    game.appid,
+                    game.rtime_last_played,
+                    result.achieved,
+                    result.total,
+                    rarest_for_cache,
+                );
+
+                if let Some(r) = result.rarest {
+                    rarest_candidates.push(r);
+                }
             }
         }
 
+        pb.finish_and_clear();
+        cache.save();
+
         // Sort by percent, then by game name, then by achievement name for deterministic results
         let rarest = rarest_candidates.into_iter().min_by(|a, b| {
             a.percent
@@ -440,19 +487,6 @@ impl SteamClient {
             })
             .collect()
     }
-
-    fn get_all_games(&self, games: &super::models::OwnedGamesData) -> Vec<(u32, String)> {
-        games
-            .games
-            .iter()
-            .map(|g| {
-                (
-                    g.appid,
-                    g.name.clone().unwrap_or_else(|| format!("App {}", g.appid)),
-                )
-            })
-            .collect()
-    }
 }
 
 struct GameAchievementResult {

src/steam/models.rs

@@ -20,6 +20,8 @@ pub struct Game {
     pub playtime_forever: u32,
     #[serde(default)]
     pub playtime_2weeks: u32,
+    #[serde(default)]
+    pub rtime_last_played: u64,
 }
 
 // Recently Played Games API