epik/stats/

mod.rs

// Statistics tracking for games
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fs;
use std::path::PathBuf;

use crate::config::Config;
use crate::Result;

// Playtime and launch statistics for a game
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GameStats {
    pub app_name: String,
    pub total_playtime_seconds: u64,
    pub launch_count: u32,
    pub last_played: Option<DateTime<Utc>>,
    pub first_played: Option<DateTime<Utc>>,
    // Per-session playtime records
    #[serde(default)]
    pub sessions: Vec<PlaySession>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PlaySession {
    pub started: DateTime<Utc>,
    pub ended: DateTime<Utc>,
    pub duration_seconds: u64,
}

impl GameStats {
    pub fn new(app_name: String) -> Self {
        Self {
            app_name,
            total_playtime_seconds: 0,
            launch_count: 0,
            last_played: None,
            first_played: None,
            sessions: Vec::new(),
        }
    }

    pub fn record_launch(&mut self) {
        self.launch_count += 1;
        let now = Utc::now();
        
        if self.first_played.is_none() {
            self.first_played = Some(now);
        }
    }

    pub fn record_session(&mut self, started: DateTime<Utc>, ended: DateTime<Utc>) {
        let duration = (ended - started).num_seconds().max(0) as u64;
        
        self.total_playtime_seconds += duration;
        self.last_played = Some(ended);
        
        self.sessions.push(PlaySession {
            started,
            ended,
            duration_seconds: duration,
        });
    }

    pub fn total_playtime_hours(&self) -> f64 {
        self.total_playtime_seconds as f64 / 3600.0
    }

    pub fn save(&self, config: &Config) -> Result<()> {
        let stats_dir = Self::stats_dir(config)?;
        fs::create_dir_all(&stats_dir)?;

        let stats_file = stats_dir.join(format!("{}.json", self.app_name));
        let contents = serde_json::to_string_pretty(self)?;
        fs::write(&stats_file, contents)?;

        Ok(())
    }

    pub fn load(config: &Config, app_name: &str) -> Result<Self> {
        let stats_dir = Self::stats_dir(config)?;
        let stats_file = stats_dir.join(format!("{}.json", app_name));

        if !stats_file.exists() {
            return Ok(Self::new(app_name.to_string()));
        }

        let contents = fs::read_to_string(&stats_file)?;
        Ok(serde_json::from_str(&contents)?)
    }

    fn stats_dir(_config: &Config) -> Result<PathBuf> {
        let data_dir = Config::data_dir()?;
        Ok(data_dir.join("stats"))
    }
}

// Achievement tracking (placeholder for future implementation)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Achievement {
    pub id: String,
    pub name: String,
    pub description: String,
    pub unlocked: bool,
    pub unlock_time: Option<DateTime<Utc>>,
    pub icon_url: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GameAchievements {
    pub app_name: String,
    pub achievements: Vec<Achievement>,
    pub total_achievements: usize,
    pub unlocked_count: usize,
}

impl GameAchievements {
    pub fn new(app_name: String) -> Self {
        Self {
            app_name,
            achievements: Vec::new(),
            total_achievements: 0,
            unlocked_count: 0,
        }
    }

    pub fn completion_percentage(&self) -> f32 {
        if self.total_achievements == 0 {
            return 0.0;
        }
        (self.unlocked_count as f32 / self.total_achievements as f32) * 100.0
    }
}

// Global statistics manager
pub struct StatsManager {
    config: Config,
    stats_cache: HashMap<String, GameStats>,
}

impl StatsManager {
    pub fn new(config: Config) -> Self {
        Self {
            config,
            stats_cache: HashMap::new(),
        }
    }

    pub fn get_stats(&mut self, app_name: &str) -> Result<&GameStats> {
        if !self.stats_cache.contains_key(app_name) {
            let stats = GameStats::load(&self.config, app_name)?;
            self.stats_cache.insert(app_name.to_string(), stats);
        }

        Ok(self.stats_cache.get(app_name).unwrap())
    }

    pub fn record_launch(&mut self, app_name: &str) -> Result<()> {
        let stats = self.stats_cache
            .entry(app_name.to_string())
            .or_insert_with(|| GameStats::new(app_name.to_string()));

        stats.record_launch();
        stats.save(&self.config)?;

        Ok(())
    }

    pub fn record_session(
        &mut self,
        app_name: &str,
        started: DateTime<Utc>,
        ended: DateTime<Utc>,
    ) -> Result<()> {
        let stats = self.stats_cache
            .entry(app_name.to_string())
            .or_insert_with(|| GameStats::new(app_name.to_string()));

        stats.record_session(started, ended);
        stats.save(&self.config)?;

        Ok(())
    }

    pub fn get_all_stats(&self) -> Vec<&GameStats> {
        self.stats_cache.values().collect()
    }

    pub fn total_playtime_hours(&self) -> f64 {
        self.stats_cache
            .values()
            .map(|s| s.total_playtime_hours())
            .sum()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_game_stats_creation() {
        let stats = GameStats::new("test_game".to_string());
        assert_eq!(stats.app_name, "test_game");
        assert_eq!(stats.total_playtime_seconds, 0);
        assert_eq!(stats.launch_count, 0);
    }

    #[test]
    fn test_record_launch() {
        let mut stats = GameStats::new("test_game".to_string());
        stats.record_launch();
        assert_eq!(stats.launch_count, 1);
        assert!(stats.first_played.is_some());
    }

    #[test]
    fn test_record_session() {
        let mut stats = GameStats::new("test_game".to_string());
        let start = Utc::now();
        let end = start + chrono::Duration::hours(2);
        
        stats.record_session(start, end);
        
        assert_eq!(stats.total_playtime_hours(), 2.0);
        assert_eq!(stats.sessions.len(), 1);
        assert!(stats.last_played.is_some());
    }
}