void-cli 0.0.4

//! Tag command - manage lightweight tags for commits.
//!
//! Tags are human-readable references to specific commits. Unlike branches,
//! tags don't move when new commits are created.

use camino::Utf8PathBuf;
use serde::Serialize;
use std::path::Path;
use void_core::{cid, refs};

use crate::context::{find_void_dir, resolve_ref, void_err_to_cli};
use crate::output::{run_command, CliError, CliOptions};

/// Command-line arguments for tag.
#[derive(Debug)]
pub struct TagArgs {
    /// Tag name to create or delete (None for listing)
    pub name: Option<String>,
    /// List all tags
    pub list: bool,
    /// Target commit (defaults to HEAD)
    pub target: Option<String>,
    /// Delete the tag instead of creating it
    pub delete: bool,
    /// Overwrite existing tag
    pub force: bool,
}

/// JSON output for the tag command.
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TagOutput {
    /// Action performed: "list", "create", or "delete"
    pub action: String,
    /// List of all tags (for list action)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    /// Tag name (for create action)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Deleted tag name (for delete action)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deleted: Option<String>,
    /// Target commit CID (for create action)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub target: Option<String>,
}

/// Run the tag command.
///
/// # Operations
///
/// - **List tags** (`--list` or no name): Show all tags in the repository
/// - **Create tag** (`tag <name>` or `tag <name> --target <commit>`): Create a tag at HEAD or specified commit
/// - **Delete tag** (`tag -d <name>`): Delete a tag
///
/// # Arguments
///
/// * `cwd` - Current working directory
/// * `args` - Tag arguments
/// * `opts` - CLI options
///
/// # Errors
///
/// Returns an error if:
/// - Not in a void repository
/// - Tag already exists (for create, unless --force)
/// - Tag not found (for delete)
/// - Invalid tag name
pub fn run(cwd: &Path, args: TagArgs, opts: &CliOptions) -> Result<(), CliError> {
    run_command("tag", opts, |ctx| {
        let void_dir = find_void_dir(cwd)?;
        let void_dir_utf8 = Utf8PathBuf::try_from(void_dir.clone())
            .map_err(|e| CliError::internal(format!("invalid void_dir path: {}", e)))?;

        // Determine operation based on arguments
        // List tags: --list flag or no name provided (and not deleting)
        if args.list || (args.name.is_none() && !args.delete) {
            ctx.progress("Listing tags...");

            let tags = refs::list_tags(&void_dir_utf8).map_err(void_err_to_cli)?;

            // Human-readable output
            if !ctx.use_json() {
                if tags.is_empty() {
                    ctx.info("No tags found.");
                } else {
                    for tag in &tags {
                        ctx.info(tag.clone());
                    }
                }
            }

            return Ok(TagOutput {
                action: "list".to_string(),
                tags: Some(tags),
                name: None,
                deleted: None,
                target: None,
            });
        }

        // Delete tag: -d flag with name
        if args.delete {
            let name = args
                .name
                .as_ref()
                .ok_or_else(|| CliError::invalid_args("tag name required for delete"))?;

            ctx.progress(format!("Deleting tag '{}'...", name));

            // Check if tag exists
            let existing = refs::read_tag(&void_dir_utf8, name).map_err(void_err_to_cli)?;
            if existing.is_none() {
                return Err(CliError::not_found(format!("tag '{}' not found", name)));
            }

            refs::delete_tag(&void_dir_utf8, name).map_err(void_err_to_cli)?;

            // Human-readable output
            if !ctx.use_json() {
                ctx.info(format!("Deleted tag '{}'", name));
            }

            return Ok(TagOutput {
                action: "delete".to_string(),
                tags: None,
                name: None,
                deleted: Some(name.clone()),
                target: None,
            });
        }

        // Create tag: name provided without -d flag
        let name = args
            .name
            .as_ref()
            .ok_or_else(|| CliError::invalid_args("tag name required"))?;

        ctx.progress(format!("Creating tag '{}'...", name));

        // Check if tag already exists
        let existing = refs::read_tag(&void_dir_utf8, name).map_err(void_err_to_cli)?;
        if existing.is_some() && !args.force {
            return Err(CliError::conflict(format!(
                "tag '{}' already exists (use --force to overwrite)",
                name
            )));
        }

        // Resolve target to commit CID
        let target_ref = args.target.as_deref().unwrap_or("HEAD");
        let cid_bytes = resolve_ref(&void_dir, target_ref)?;

        // Convert CID bytes to string for output
        let cid_str = cid::from_bytes(cid_bytes.as_bytes())
            .map(|c| c.to_string())
            .unwrap_or_else(|_| hex::encode(cid_bytes.as_bytes()));

        refs::write_tag(&void_dir_utf8, name, &cid_bytes).map_err(void_err_to_cli)?;

        // Human-readable output
        if !ctx.use_json() {
            let short_cid = if cid_str.len() > 12 {
                &cid_str[..12]
            } else {
                &cid_str
            };
            ctx.info(format!("Created tag '{}' at {}", name, short_cid));
        }

        Ok(TagOutput {
            action: "create".to_string(),
            tags: None,
            name: Some(name.clone()),
            deleted: None,
            target: Some(cid_str),
        })
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::output::CliOptions;
    use std::fs;
    use tempfile::tempdir;
    use void_core::crypto;

    fn default_opts() -> CliOptions {
        CliOptions {
            human: true,
            ..Default::default()
        }
    }

    fn setup_test_repo() -> (tempfile::TempDir, std::path::PathBuf, tempfile::TempDir, crate::context::VoidHomeGuard) {
        let dir = tempdir().unwrap();
        let void_dir = dir.path().join(".void");
        fs::create_dir_all(void_dir.join("objects")).unwrap();
        fs::create_dir_all(void_dir.join("refs/tags")).unwrap();
        fs::create_dir_all(void_dir.join("refs/heads")).unwrap();

        // Create key and manifest
        let key = crypto::generate_key();
        let home = tempdir().unwrap();
        let guard = crate::context::setup_test_manifest(&void_dir, &key, home.path());

        // Create config file with repoSecret
        let repo_secret = hex::encode(crypto::generate_key());
        fs::write(
            void_dir.join("config.json"),
            format!(r#"{{"repoSecret": "{}"}}"#, repo_secret),
        )
        .unwrap();

        (dir, void_dir, home, guard)
    }

    #[test]
    fn test_list_tags_empty() {
        let (dir, _void_dir, _home, _guard) = setup_test_repo();

        let args = TagArgs {
            name: None,
            list: false,
            target: None,
            delete: false,
            force: false,
        };

        let result = run(dir.path(), args, &default_opts());
        assert!(result.is_ok());
    }

    #[test]
    fn test_list_tags_with_tags() {
        let (dir, void_dir, _home, _guard) = setup_test_repo();

        // Create some tag files manually
        let tags_dir = void_dir.join("refs/tags");
        // Use a valid CID format (bafk... is a valid CIDv1 prefix)
        fs::write(
            tags_dir.join("v1.0.0"),
            "bafkreihdwdcefgh4dqkjv67uzcmw7ojee6xedzdetojuzjevtenxquvyku\n",
        )
        .unwrap();
        fs::write(
            tags_dir.join("v2.0.0"),
            "bafkreihdwdcefgh4dqkjv67uzcmw7ojee6xedzdetojuzjevtenxquvyku\n",
        )
        .unwrap();

        let args = TagArgs {
            name: None,
            list: false,
            target: None,
            delete: false,
            force: false,
        };

        let result = run(dir.path(), args, &default_opts());
        assert!(result.is_ok());
    }

    #[test]
    fn test_list_tags_with_explicit_flag() {
        let (dir, _void_dir, _home, _guard) = setup_test_repo();

        // Even with a name, --list should list tags
        let args = TagArgs {
            name: Some("v1.0.0".to_string()),
            list: true,
            target: None,
            delete: false,
            force: false,
        };

        let result = run(dir.path(), args, &default_opts());
        assert!(result.is_ok());
    }

    #[test]
    fn test_delete_nonexistent_tag() {
        let (dir, _void_dir, _home, _guard) = setup_test_repo();

        let args = TagArgs {
            name: Some("nonexistent".to_string()),
            list: false,
            target: None,
            delete: true,
            force: false,
        };

        let result = run(dir.path(), args, &default_opts());
        assert!(result.is_err());
    }

    #[test]
    fn test_delete_requires_name() {
        let (dir, _void_dir, _home, _guard) = setup_test_repo();

        let args = TagArgs {
            name: None,
            list: false,
            target: None,
            delete: true,
            force: false,
        };

        let result = run(dir.path(), args, &default_opts());
        assert!(result.is_err());
    }

    #[test]
    fn test_create_tag_without_head_fails() {
        let (dir, _void_dir, _home, _guard) = setup_test_repo();

        // No HEAD set, so creating a tag at HEAD should fail
        let args = TagArgs {
            name: Some("v1.0.0".to_string()),
            list: false,
            target: None,
            delete: false,
            force: false,
        };

        let result = run(dir.path(), args, &default_opts());
        assert!(result.is_err());
    }

    #[test]
    fn test_tag_not_initialized() {
        let dir = tempdir().unwrap();
        // Don't create .void directory

        let args = TagArgs {
            name: None,
            list: false,
            target: None,
            delete: false,
            force: false,
        };

        let result = run(dir.path(), args, &default_opts());
        assert!(result.is_err());
    }

    #[test]
    fn test_tag_output_serialization() {
        let output = TagOutput {
            action: "list".to_string(),
            tags: Some(vec!["v1.0.0".to_string(), "v2.0.0".to_string()]),
            name: None,
            deleted: None,
            target: None,
        };

        let json = serde_json::to_string(&output).unwrap();
        assert!(json.contains("\"action\":\"list\""));
        assert!(json.contains("\"tags\":[\"v1.0.0\",\"v2.0.0\"]"));
        // name, deleted, and target should be omitted due to skip_serializing_if
        assert!(!json.contains("\"name\""));
        assert!(!json.contains("\"deleted\""));
        assert!(!json.contains("\"target\""));
    }

    #[test]
    fn test_tag_output_create_serialization() {
        let output = TagOutput {
            action: "create".to_string(),
            tags: None,
            name: Some("v1.0.0".to_string()),
            deleted: None,
            target: Some("bafytest123".to_string()),
        };

        let json = serde_json::to_string(&output).unwrap();
        assert!(json.contains("\"action\":\"create\""));
        assert!(json.contains("\"name\":\"v1.0.0\""));
        assert!(json.contains("\"target\":\"bafytest123\""));
        // tags and deleted should be omitted
        assert!(!json.contains("\"tags\""));
        assert!(!json.contains("\"deleted\""));
    }

    #[test]
    fn test_tag_output_delete_serialization() {
        let output = TagOutput {
            action: "delete".to_string(),
            tags: None,
            name: None,
            deleted: Some("v1.0.0".to_string()),
            target: None,
        };

        let json = serde_json::to_string(&output).unwrap();
        assert!(json.contains("\"action\":\"delete\""));
        assert!(json.contains("\"deleted\":\"v1.0.0\""));
        // tags, name, and target should be omitted
        assert!(!json.contains("\"tags\""));
        assert!(!json.contains("\"name\""));
        assert!(!json.contains("\"target\""));
    }
}