unity_pack/

package.rs

//! Unity package (.unitypackage) creation
//!
//! Creates the tar.gz archive with the structure Unity expects.

use crate::{Asset, Error, Result};
use flate2::write::GzEncoder;
use flate2::Compression;
use std::collections::HashSet;
use std::fs::File;
use std::io::Write;
use std::path::Path;
use tar::{Builder, Header};

/// Builder for constructing Unity packages with configuration options
#[derive(Debug, Default)]
pub struct UnityPackageBuilder {
    assets: Vec<Asset>,
    deterministic_guids: bool,
}

impl UnityPackageBuilder {
    /// Create a new package builder
    pub fn new() -> Self {
        Self {
            assets: Vec::new(),
            deterministic_guids: true,
        }
    }

    /// Add an asset to the package
    pub fn asset(mut self, asset: Asset) -> Self {
        self.assets.push(asset);
        self
    }

    /// Add multiple assets at once
    pub fn assets(mut self, assets: impl IntoIterator<Item = Asset>) -> Self {
        self.assets.extend(assets);
        self
    }

    /// Use deterministic GUIDs based on paths (default: true)
    pub fn deterministic_guids(mut self, enabled: bool) -> Self {
        self.deterministic_guids = enabled;
        self
    }

    /// Build the package, validating all assets
    pub fn build(self) -> Result<UnityPackage> {
        let mut pkg = UnityPackage::new();

        for mut asset in self.assets {
            if !self.deterministic_guids {
                asset = asset.with_random_guid();
            }
            pkg.add(asset)?;
        }

        Ok(pkg)
    }
}

/// A Unity package container
#[derive(Debug, Default)]
pub struct UnityPackage {
    assets: Vec<Asset>,
    paths: HashSet<String>,
}

impl UnityPackage {
    /// Create a new empty package
    pub fn new() -> Self {
        Self::default()
    }

    /// Create a builder for constructing packages with configuration options
    pub fn builder() -> UnityPackageBuilder {
        UnityPackageBuilder::new()
    }

    /// Add an asset to the package
    pub fn add(&mut self, asset: Asset) -> Result<&mut Self> {
        // Validate path starts with Assets/
        if !asset.path.starts_with("Assets/") && !asset.path.starts_with("Assets\\") {
            return Err(Error::PathMustStartWithAssets(asset.path.clone()));
        }

        // Check for duplicates
        if self.paths.contains(&asset.path) {
            return Err(Error::DuplicatePath(asset.path.clone()));
        }

        self.paths.insert(asset.path.clone());
        self.assets.push(asset);
        Ok(self)
    }

    /// Add a binary asset (convenience method)
    pub fn add_binary(&mut self, path: impl Into<String>, data: Vec<u8>) -> Result<&mut Self> {
        self.add(Asset::binary(path, data))
    }

    /// Add a text asset (convenience method)
    pub fn add_text(
        &mut self,
        path: impl Into<String>,
        content: impl Into<String>,
    ) -> Result<&mut Self> {
        self.add(Asset::text(path, content))
    }

    /// Add a folder (convenience method)
    pub fn add_folder(&mut self, path: impl Into<String>) -> Result<&mut Self> {
        self.add(Asset::folder(path))
    }

    /// Get all assets in the package
    pub fn assets(&self) -> &[Asset] {
        &self.assets
    }

    /// Number of assets in the package
    pub fn len(&self) -> usize {
        self.assets.len()
    }

    /// Check if package is empty
    pub fn is_empty(&self) -> bool {
        self.assets.is_empty()
    }

    /// Save the package to a file
    pub fn save(&self, path: impl AsRef<Path>) -> Result<()> {
        let file = File::create(path)?;
        self.write_to(file)
    }

    /// Write the package to any writer
    pub fn write_to<W: Write>(&self, writer: W) -> Result<()> {
        // Create gzip-compressed tar
        let encoder = GzEncoder::new(writer, Compression::default());
        let mut tar = Builder::new(encoder);

        // Collect all parent folders that need to be created
        let mut folders_to_create: HashSet<String> = HashSet::new();
        for asset in &self.assets {
            let path = &asset.path;
            let mut current = String::new();
            for component in path.split('/').take(path.split('/').count() - 1) {
                if current.is_empty() {
                    current = component.to_string();
                } else {
                    current = format!("{}/{}", current, component);
                }
                if current.starts_with("Assets") && !self.paths.contains(&current) {
                    folders_to_create.insert(current.clone());
                }
            }
        }

        // Create folder assets for parent directories
        let folder_assets: Vec<Asset> = folders_to_create.into_iter().map(Asset::folder).collect();

        // Combine with explicit assets
        let all_assets: Vec<&Asset> = folder_assets.iter().chain(self.assets.iter()).collect();

        // Write each asset
        for asset in all_assets {
            self.write_asset(&mut tar, asset)?;
        }

        // Finish the archive
        let encoder = tar.into_inner()?;
        encoder.finish()?;

        Ok(())
    }

    /// Write a single asset to the tar archive
    fn write_asset<W: Write>(&self, tar: &mut Builder<W>, asset: &Asset) -> Result<()> {
        let guid_str = asset.guid.to_hex();

        // Write pathname file
        let pathname_path = format!("{}/pathname", guid_str);
        let pathname_content = format!("{}\n", asset.path);
        self.write_tar_file(tar, &pathname_path, pathname_content.as_bytes())?;

        // Write asset file (if not a folder)
        if let Some(content) = asset.content_bytes() {
            let asset_path = format!("{}/asset", guid_str);
            self.write_tar_file(tar, &asset_path, &content)?;
        }

        // Write asset.meta file
        let meta_path = format!("{}/asset.meta", guid_str);
        let meta_content = asset.meta_file().to_yaml();
        self.write_tar_file(tar, &meta_path, meta_content.as_bytes())?;

        Ok(())
    }

    /// Helper to write a file to the tar archive
    fn write_tar_file<W: Write>(
        &self,
        tar: &mut Builder<W>,
        path: &str,
        data: &[u8],
    ) -> Result<()> {
        let mut header = Header::new_gnu();
        header.set_size(data.len() as u64);
        header.set_mode(0o644);
        header.set_mtime(0); // Reproducible builds
        header.set_cksum();

        tar.append_data(&mut header, path, data)?;
        Ok(())
    }
}

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

    #[test]
    fn test_empty_package() {
        let pkg = UnityPackage::new();
        assert!(pkg.is_empty());
        assert_eq!(pkg.len(), 0);
    }

    #[test]
    fn test_add_assets() {
        let mut pkg = UnityPackage::new();
        pkg.add_binary("Assets/test.raw", vec![1, 2, 3]).unwrap();
        pkg.add_text("Assets/config.json", "{}").unwrap();

        assert_eq!(pkg.len(), 2);
    }

    #[test]
    fn test_path_validation() {
        let mut pkg = UnityPackage::new();

        // Valid path
        assert!(pkg.add_binary("Assets/test.raw", vec![]).is_ok());

        // Invalid path (doesn't start with Assets/)
        let result = pkg.add_binary("test.raw", vec![]);
        assert!(matches!(result, Err(Error::PathMustStartWithAssets(_))));
    }

    #[test]
    fn test_duplicate_path() {
        let mut pkg = UnityPackage::new();
        pkg.add_binary("Assets/test.raw", vec![1]).unwrap();

        let result = pkg.add_binary("Assets/test.raw", vec![2]);
        assert!(matches!(result, Err(Error::DuplicatePath(_))));
    }

    #[test]
    fn test_write_package() {
        let mut pkg = UnityPackage::new();
        pkg.add_binary("Assets/Terrain/heightmap.raw", vec![0, 1, 2, 3])
            .unwrap();
        pkg.add_text("Assets/Terrain/metadata.json", r#"{"width": 256}"#)
            .unwrap();

        let mut buffer = Vec::new();
        pkg.write_to(&mut buffer).unwrap();

        // Verify it's a valid gzip file
        assert!(buffer.len() > 0);
        assert_eq!(&buffer[0..2], &[0x1f, 0x8b]); // Gzip magic number
    }

    #[test]
    fn test_builder_basic() {
        let pkg = UnityPackage::builder()
            .asset(Asset::binary("Assets/test.raw", vec![1, 2, 3]))
            .asset(Asset::text("Assets/config.json", "{}"))
            .build()
            .unwrap();

        assert_eq!(pkg.len(), 2);
    }

    #[test]
    fn test_builder_deterministic_guids() {
        let pkg1 = UnityPackage::builder()
            .asset(Asset::binary("Assets/test.raw", vec![1]))
            .build()
            .unwrap();

        let pkg2 = UnityPackage::builder()
            .asset(Asset::binary("Assets/test.raw", vec![2]))
            .build()
            .unwrap();

        // Same path = same GUID when deterministic
        assert_eq!(pkg1.assets()[0].guid, pkg2.assets()[0].guid);
    }

    #[test]
    fn test_builder_random_guids() {
        let pkg1 = UnityPackage::builder()
            .asset(Asset::binary("Assets/test.raw", vec![1]))
            .deterministic_guids(false)
            .build()
            .unwrap();

        let pkg2 = UnityPackage::builder()
            .asset(Asset::binary("Assets/test.raw", vec![2]))
            .deterministic_guids(false)
            .build()
            .unwrap();

        // Random mode = different GUIDs even for same path
        assert_ne!(pkg1.assets()[0].guid, pkg2.assets()[0].guid);
    }
}