launcher/

news.rs

use crate::constants::{CODEBERG_API_BASE_URL, CODEBERG_REPO};
use crate::launcher_config::LauncherConfig;
use base64::Engine;
use chrono::Utc;
use serde::{Deserialize, Serialize};
use std::path::{Path, PathBuf};
use std::sync::mpsc::{self, Receiver};

// ---------------------------------------------------------------------------
// Forgejo API shapes
// ---------------------------------------------------------------------------

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WikiCommitAuthor {
    pub name: String,
    pub email: String,
    pub date: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WikiCommit {
    pub sha: String,
    pub author: WikiCommitAuthor,
    pub message: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WikiPageHeader {
    pub title: String,
    pub html_url: String,
    pub sub_url: String,
    pub last_commit: WikiCommit,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WikiPageDetail {
    pub title: String,
    pub html_url: String,
    pub sub_url: String,
    pub last_commit: WikiCommit,
    pub content_base64: String,
}

// ---------------------------------------------------------------------------
// Cached article
// ---------------------------------------------------------------------------

/// A news article stored in the local cache.
///
/// The `slug` field (`YYYY-MM-DD_article-name`) is derived from the wiki page
/// title (`news/YYYY-MM-DD_article-name`) and is the canonical, stable
/// identifier. It does **not** change when the article is edited, so it is
/// safe to compare against `last_read_news`.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CachedArticle {
    /// `YYYY-MM-DD_slug`, canonical article identifier, stable across edits.
    pub slug: String,
    /// `YYYY-MM-DD`, publication date, derived from the slug, used for display.
    pub date: String,
    pub title: String,
    pub html_url: String,
    pub sub_url: String,
    /// Current commit SHA; compared against the API to detect content updates.
    pub sha: String,
    pub author_name: String,
    pub content: String,
}

// ---------------------------------------------------------------------------
// Channel message
// ---------------------------------------------------------------------------

pub enum NewsStatus {
    Checking,
    Success {
        articles: Vec<CachedArticle>,
        badge_count: usize,
        /// RFC 3339 timestamp to persist as `last_news_check`.
        last_news_check: String,
    },
    Error(String),
}

// ---------------------------------------------------------------------------
// NewsManager
// ---------------------------------------------------------------------------

pub struct NewsManager {
    receiver: Option<Receiver<NewsStatus>>,
    is_checking: bool,
    articles: Vec<CachedArticle>,
    badge_count: usize,
}

impl NewsManager {
    /// Create a new `NewsManager`, loading whatever articles are already
    /// cached in the user-profile cache directory.
    #[must_use]
    pub fn new(game_path: &std::path::Path, config: &LauncherConfig) -> Self {
        // One-time migration from the old in-game cache location.
        let old_cache_dir = game_path.join("Saved_Data/news_cache");
        let new_cache_dir = news_cache_dir();
        // Still the shipped behavior; the allow comes off with the deprecated fn.
        #[allow(deprecated)]
        migrate_cache(&old_cache_dir, &new_cache_dir);

        let articles = load_cached_articles(&new_cache_dir);
        let badge_count = count_new_articles(&articles, config.news.last_read.as_deref());

        Self {
            receiver: None,
            is_checking: false,
            articles,
            badge_count,
        }
    }

    #[must_use]
    pub fn articles(&self) -> &[CachedArticle] {
        &self.articles
    }

    #[must_use]
    pub fn badge_count(&self) -> usize {
        self.badge_count
    }

    #[must_use]
    pub fn is_checking(&self) -> bool {
        self.is_checking
    }

    /// Mark all articles as read and persist the change to the Launcher Config.
    pub fn clear_badge(&mut self, config: &mut LauncherConfig) {
        if self.badge_count > 0 {
            self.badge_count = 0;
            if let Some(newest) = self.articles.first() {
                config.news.last_read = Some(newest.slug.clone());
                if let Err(e) = config.save() {
                    eprintln!("Failed to save launcher config after clearing badge: {e}");
                }
            }
        }
    }

    /// Returns `true` if a news check is due (no check in the last 24h).
    #[must_use]
    pub fn is_check_due(&self, config: &LauncherConfig) -> bool {
        if let Some(ref ts) = config.news.last_check
            && let Ok(dt) = ts.parse::<chrono::DateTime<Utc>>()
        {
            Utc::now().signed_duration_since(dt).num_hours() >= 24
        } else {
            true
        }
    }

    /// Poll the background thread. Returns the latest status if one arrived.
    ///
    /// The caller is responsible for acting on `NewsStatus::Success` to update
    /// `LauncherConfig.news.last_check` and save.
    pub fn poll(&mut self) -> Option<NewsStatus> {
        let mut last_status = None;
        if let Some(rx) = &self.receiver {
            while let Ok(status) = rx.try_recv() {
                last_status = Some(status);
            }
        }

        if let Some(ref status) = last_status {
            match status {
                NewsStatus::Checking => {
                    self.is_checking = true;
                }
                NewsStatus::Success {
                    articles,
                    badge_count,
                    ..
                } => {
                    self.articles = articles.clone();
                    self.badge_count = *badge_count;
                    self.is_checking = false;
                    self.receiver = None;
                }
                NewsStatus::Error(_) => {
                    self.is_checking = false;
                    self.receiver = None;
                }
            }
        }
        last_status
    }

    /// Spawn a background thread to check for new articles.
    pub fn start_check(&mut self, last_read_slug: &Option<String>) {
        let (tx, rx) = mpsc::channel();
        self.receiver = Some(rx);
        self.is_checking = true;

        let tx_thread = tx.clone();
        let _ = tx.send(NewsStatus::Checking);

        let cache_dir = news_cache_dir();
        let last_read_slug = last_read_slug.clone();
        std::thread::spawn(move || match do_news_check(cache_dir, &last_read_slug) {
            Ok((articles, badge_count, last_news_check)) => {
                let _ = tx_thread.send(NewsStatus::Success {
                    articles,
                    badge_count,
                    last_news_check,
                });
            }
            Err(e) => {
                let _ = tx_thread.send(NewsStatus::Error(e.to_string()));
            }
        });
    }
}

// ---------------------------------------------------------------------------
// Cache directory
// ---------------------------------------------------------------------------

/// Returns the shared news cache directory in the user's profile.
///
/// `%APPDATA%\Supreme-Snowboarding-Community-Launcher\news_cache` on Windows,
/// `~/Library/Application Support/Supreme-Snowboarding-Community-Launcher/news_cache`
/// on macOS, `$XDG_DATA_HOME/Supreme-Snowboarding-Community-Launcher/news_cache` on Linux.
///
/// Falls back to `./news_cache` if the OS provides no data directory.
#[must_use]
fn news_cache_dir() -> PathBuf {
    dirs::data_dir()
        .unwrap_or_else(|| PathBuf::from("."))
        .join("Supreme-Snowboarding-Community-Launcher")
        .join("news_cache")
}

// ---------------------------------------------------------------------------
// Migration
// ---------------------------------------------------------------------------

/// One-time migration: move cached article files from the old in-game location
/// to the new user-profile location, then remove the old directory if empty.
///
#[deprecated(
    since = "1.7.0",
    note = "Old cache location will be removed anytime after 2026-08"
)]
fn migrate_cache(old_dir: &std::path::Path, new_dir: &std::path::Path) {
    if !old_dir.exists() {
        return;
    }

    // Ensure the target exists before trying to move files into it.
    if std::fs::create_dir_all(new_dir).is_err() {
        return;
    }

    if let Ok(entries) = std::fs::read_dir(old_dir) {
        for entry in entries.flatten() {
            let src = entry.path();
            if src.extension().is_some_and(|e| e == "json")
                && let Some(filename) = src.file_name()
            {
                let dst = new_dir.join(filename);
                // Only copy if the destination doesn't already exist.
                if !dst.exists()
                    && let Err(e) = std::fs::copy(&src, &dst)
                {
                    eprintln!(
                        "Failed to migrate cached article {} to {}: {e}",
                        src.display(),
                        dst.display()
                    );
                };
                // Unconditionnaly remove the source, as losing the file contents
                // is acceptable.
                if let Err(e) = std::fs::remove_file(&src) {
                    eprintln!("Failed to remove old cache file {}: {e}", src.display());
                }
            }
        }
    }

    // Remove the old directory with all its contents, even if it should be
    // empty. There is no expected data of value in it.
    if let Err(e) = std::fs::remove_dir_all(old_dir) {
        eprintln!(
            "Failed to remove old cache firectory {}: {e}",
            old_dir.display()
        );
    }
}

// ---------------------------------------------------------------------------
// Slug / date helpers
// ---------------------------------------------------------------------------

/// Extract `(slug, date)` from a wiki page title of the form
/// `news/YYYY-MM-DD_some-article-name`.
///
/// Returns `None` if the title does not match the expected pattern.
fn parse_slug_and_date(title: &str) -> Option<(String, String)> {
    let rest = title.strip_prefix("news/")?;
    // The date is the first 10 characters: YYYY-MM-DD
    if rest.len() < 10 {
        return None;
    }
    let (date_part, _) = rest.split_at(10);
    // Validate it looks like a date (digits and dashes only).
    if !date_part.chars().all(|c| c.is_ascii_digit() || c == '-') {
        return None;
    }
    Some((rest.to_string(), date_part.to_string()))
}

// ---------------------------------------------------------------------------
// Badge counting
// ---------------------------------------------------------------------------

/// Count articles whose slug is lexicographically greater than `last_read_slug`.
///
/// Because slugs start with `YYYY-MM-DD`, lexicographic order equals
/// chronological order, making this comparison safe and edit-stable.
fn count_new_articles(articles: &[CachedArticle], last_read_slug: Option<&str>) -> usize {
    match last_read_slug {
        None => articles.len(),
        Some(last) => articles.iter().filter(|a| a.slug.as_str() > last).count(),
    }
}

// ---------------------------------------------------------------------------
// Cache I/O
// ---------------------------------------------------------------------------

fn load_cached_articles(cache_dir: &Path) -> Vec<CachedArticle> {
    let mut articles = Vec::new();
    if let Ok(entries) = std::fs::read_dir(cache_dir) {
        for entry in entries.flatten() {
            let path = entry.path();
            if path.extension().is_some_and(|ext| ext == "json")
                && let Ok(content) = std::fs::read_to_string(&path)
                && let Ok(article) = serde_json::from_str::<CachedArticle>(&content)
            {
                articles.push(article);
            }
        }
    }
    // Most-recent first (slug = YYYY-MM-DD_... sorts lexicographically).
    articles.sort_by(|a, b| b.slug.cmp(&a.slug));
    articles
}

fn save_cached_article(cache_dir: &Path, article: &CachedArticle) -> std::io::Result<()> {
    std::fs::create_dir_all(cache_dir)?;
    let filename = format!("{}.json", article.slug);
    let path = cache_dir.join(filename);
    let content = serde_json::to_string_pretty(article)?;
    std::fs::write(path, content)?;
    Ok(())
}

// ---------------------------------------------------------------------------
// Network check
// ---------------------------------------------------------------------------

fn do_news_check(
    cache_dir: PathBuf,
    last_read_slug: &Option<String>,
) -> Result<(Vec<CachedArticle>, usize, String), Box<dyn std::error::Error + Send + Sync>> {
    let list_url = if cfg!(feature = "local") {
        format!("{CODEBERG_API_BASE_URL}/mock_wiki_pages.php")
    } else {
        format!("{CODEBERG_API_BASE_URL}/repos/{CODEBERG_REPO}/wiki/pages")
    };

    let client = ureq::Agent::new_with_config(
        ureq::Agent::config_builder()
            .user_agent("SupremeSnowboardingLauncher")
            .timeout_connect(Some(std::time::Duration::from_secs(10)))
            .timeout_global(Some(std::time::Duration::from_secs(300)))
            .build(),
    );

    let response = client.get(&list_url).call()?;
    if !response.status().is_success() {
        return Err(format!("Failed to fetch wiki pages: status {}", response.status()).into());
    }

    let headers: Vec<WikiPageHeader> = response.into_body().read_json()?;

    // Keep only well-formed news pages, sorted most-recent first.
    let mut news_headers: Vec<(WikiPageHeader, String /*slug*/, String /*date*/)> = headers
        .into_iter()
        .filter_map(|h| parse_slug_and_date(&h.title).map(|(slug, date)| (h, slug, date)))
        .collect();
    news_headers.sort_by(|a, b| b.1.cmp(&a.1));

    // Only fetch/cache the most recent article automatically.
    news_headers.truncate(1);

    // Load the full cache so all previously downloaded articles can be returned.
    let mut articles = load_cached_articles(&cache_dir);

    for (header, slug, date) in news_headers {
        // Check if we already have this exact commit cached.
        let already_cached = articles
            .iter()
            .any(|a| a.slug == slug && a.sha == header.last_commit.sha);

        if !already_cached {
            let detail_url = if cfg!(feature = "local") {
                format!(
                    "{CODEBERG_API_BASE_URL}/mock_wiki_page.php?page={}",
                    header.sub_url
                )
            } else {
                format!(
                    "{CODEBERG_API_BASE_URL}/repos/{CODEBERG_REPO}/wiki/page/{}",
                    header.sub_url
                )
            };

            let detail_resp = client.get(&detail_url).call()?;
            if detail_resp.status().is_success() {
                let detail: WikiPageDetail = detail_resp.into_body().read_json()?;

                let clean_b64: String = detail
                    .content_base64
                    .chars()
                    .filter(|c| !c.is_whitespace())
                    .collect();
                let decoded_bytes = base64::prelude::BASE64_STANDARD.decode(&clean_b64)?;
                let content_str = String::from_utf8(decoded_bytes)?;

                let article = CachedArticle {
                    slug: slug.clone(),
                    date,
                    title: detail.title,
                    html_url: detail.html_url,
                    sub_url: detail.sub_url,
                    sha: detail.last_commit.sha,
                    author_name: detail.last_commit.author.name,
                    content: content_str,
                };

                if let Err(e) = save_cached_article(&cache_dir, &article) {
                    eprintln!("Failed to cache article {slug}: {e}");
                }

                // Replace any stale cached entry for this slug, or add new.
                if let Some(pos) = articles.iter().position(|a| a.slug == slug) {
                    articles[pos] = article;
                } else {
                    articles.push(article);
                }
            }
        }
    }

    articles.sort_by(|a, b| b.slug.cmp(&a.slug));

    let badge_count = count_new_articles(&articles, last_read_slug.as_deref());
    let last_news_check = Utc::now().to_rfc3339();

    Ok((articles, badge_count, last_news_check))
}

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

    #[test]
    fn test_is_check_due_when_none() {
        let manager = NewsManager {
            receiver: None,
            is_checking: false,
            articles: vec![],
            badge_count: 0,
        };
        let config = LauncherConfig::default();
        assert!(manager.is_check_due(&config));
    }

    #[test]
    fn test_is_check_due_recent() {
        let manager = NewsManager {
            receiver: None,
            is_checking: false,
            articles: vec![],
            badge_count: 0,
        };
        let mut config = LauncherConfig::default();
        let recent = Utc::now() - Duration::hours(1);
        config.news.last_check = Some(recent.to_rfc3339());
        assert!(!manager.is_check_due(&config));
    }

    #[test]
    fn test_is_check_due_expired() {
        let manager = NewsManager {
            receiver: None,
            is_checking: false,
            articles: vec![],
            badge_count: 0,
        };
        let mut config = LauncherConfig::default();
        let old = Utc::now() - Duration::hours(25);
        config.news.last_check = Some(old.to_rfc3339());
        assert!(manager.is_check_due(&config));
    }

    #[test]
    fn test_is_check_due_invalid_timestamp() {
        let manager = NewsManager {
            receiver: None,
            is_checking: false,
            articles: vec![],
            badge_count: 0,
        };
        let mut config = LauncherConfig::default();
        config.news.last_check = Some("invalid-timestamp".to_string());
        assert!(manager.is_check_due(&config));
    }
}