harmony/harmony_assets/src/asset.rs

use crate::hash::ChecksumAlgo;
use std::path::PathBuf;
use url::Url;

#[derive(Debug, Clone)]
pub struct Asset {
    pub url: Url,
    pub checksum: String,
    pub checksum_algo: ChecksumAlgo,
    pub file_name: String,
    pub size: Option<u64>,
}

impl Asset {
    pub fn new(url: Url, checksum: String, checksum_algo: ChecksumAlgo, file_name: String) -> Self {
        Self {
            url,
            checksum,
            checksum_algo,
            file_name,
            size: None,
        }
    }

    pub fn with_size(mut self, size: u64) -> Self {
        self.size = Some(size);
        self
    }

    pub fn formatted_checksum(&self) -> String {
        crate::hash::format_checksum(&self.checksum, self.checksum_algo.clone())
    }
}

#[derive(Debug, Clone)]
pub struct LocalCache {
    pub base_dir: PathBuf,
}

impl LocalCache {
    pub fn new(base_dir: PathBuf) -> Self {
        Self { base_dir }
    }

    pub fn path_for(&self, asset: &Asset) -> PathBuf {
        let prefix = &asset.checksum[..16.min(asset.checksum.len())];
        self.base_dir.join(prefix).join(&asset.file_name)
    }

    pub fn cache_key_dir(&self, asset: &Asset) -> PathBuf {
        let prefix = &asset.checksum[..16.min(asset.checksum.len())];
        self.base_dir.join(prefix)
    }

    pub async fn ensure_dir(&self, asset: &Asset) -> Result<(), crate::errors::AssetError> {
        let dir = self.cache_key_dir(asset);
        tokio::fs::create_dir_all(&dir)
            .await
            .map_err(crate::errors::AssetError::IoError)?;
        Ok(())
    }
}

impl Default for LocalCache {
    fn default() -> Self {
        let base_dir = directories::ProjectDirs::from("io", "NationTech", "Harmony")
            .map(|dirs| dirs.cache_dir().join("assets"))
            .unwrap_or_else(|| PathBuf::from("/tmp/harmony_assets"));
        Self::new(base_dir)
    }
}

#[derive(Debug, Clone)]
pub struct StoredAsset {
    pub url: Url,
    pub checksum: String,
    pub checksum_algo: ChecksumAlgo,
    pub size: u64,
    pub key: String,
}

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

    fn test_asset(checksum: &str) -> Asset {
        Asset::new(
            Url::parse("https://example.com/test.iso").unwrap(),
            checksum.to_string(),
            ChecksumAlgo::BLAKE3,
            "test.iso".to_string(),
        )
    }

    #[test]
    fn asset_path_uses_checksum_prefix_and_filename() {
        let cache = LocalCache::new(PathBuf::from("/tmp/test_cache"));
        let asset = test_asset("abcdef1234567890abcdef1234567890");
        let path = cache.path_for(&asset);
        assert_eq!(
            path,
            PathBuf::from("/tmp/test_cache/abcdef1234567890/test.iso")
        );
    }

    #[test]
    fn asset_path_handles_short_checksum() {
        let cache = LocalCache::new(PathBuf::from("/tmp/test_cache"));
        let asset = test_asset("abc");
        let path = cache.path_for(&asset);
        assert_eq!(path, PathBuf::from("/tmp/test_cache/abc/test.iso"));
    }

    #[test]
    fn cache_key_dir_is_prefix_only() {
        let cache = LocalCache::new(PathBuf::from("/tmp/test_cache"));
        let asset = test_asset("abcdef1234567890abcdef1234567890");
        let dir = cache.cache_key_dir(&asset);
        assert_eq!(dir, PathBuf::from("/tmp/test_cache/abcdef1234567890"));
    }

    #[test]
    fn asset_with_size() {
        let asset = test_asset("abc").with_size(1024);
        assert_eq!(asset.size, Some(1024));
    }

    #[test]
    fn formatted_checksum_includes_algo_prefix() {
        let asset = test_asset("deadbeef");
        assert_eq!(asset.formatted_checksum(), "blake3:deadbeef");
    }
}