use-go-mod 0.0.1

#![forbid(unsafe_code)]
#![doc = include_str!("../README.md")]

use core::{fmt, str::FromStr};
use std::error::Error;

use use_go_module::{GoModuleDependency, GoModulePath, GoModuleReplacement, GoModuleVersion};
use use_go_version::{GoCompatibilityVersion, GoToolchainVersion};

/// Error returned when parsing `go.mod` metadata labels fails.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum GoModError {
    EmptyLabel,
    UnknownLabel,
}

impl fmt::Display for GoModError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::EmptyLabel => formatter.write_str("go.mod metadata label cannot be empty"),
            Self::UnknownLabel => formatter.write_str("unknown go.mod metadata label"),
        }
    }
}

impl Error for GoModError {}

/// `go.mod` config file kind.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum GoModConfigFile {
    GoMod,
}

impl GoModConfigFile {
    /// Returns the config file name.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        "go.mod"
    }
}

impl fmt::Display for GoModConfigFile {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.as_str())
    }
}

impl FromStr for GoModConfigFile {
    type Err = GoModError;

    fn from_str(value: &str) -> Result<Self, Self::Err> {
        match normalized_label(value)?.as_str() {
            "go.mod" | "gomod" => Ok(Self::GoMod),
            _ => Err(GoModError::UnknownLabel),
        }
    }
}

/// Lightweight `go.mod` file metadata.
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct GoModFile {
    directives: Vec<GoModDirective>,
}

impl GoModFile {
    /// Creates empty `go.mod` metadata.
    #[must_use]
    pub const fn new() -> Self {
        Self {
            directives: Vec::new(),
        }
    }

    /// Adds a directive and returns the updated metadata.
    #[must_use]
    pub fn with_directive(mut self, directive: GoModDirective) -> Self {
        self.directives.push(directive);
        self
    }

    /// Returns the directives.
    #[must_use]
    pub fn directives(&self) -> &[GoModDirective] {
        &self.directives
    }
}

/// `go.mod` directive metadata.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum GoModDirective {
    Module(GoModModuleDirective),
    Go(GoModGoDirective),
    Toolchain(GoModToolchainDirective),
    Require(GoModRequireDirective),
    Replace(GoModReplaceDirective),
    Exclude(GoModExcludeDirective),
    Retract(GoModRetractDirective),
}

/// `module` directive metadata.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct GoModModuleDirective {
    path: GoModulePath,
}

impl GoModModuleDirective {
    /// Creates a `module` directive.
    #[must_use]
    pub const fn new(path: GoModulePath) -> Self {
        Self { path }
    }

    /// Returns the module path.
    #[must_use]
    pub const fn path(&self) -> &GoModulePath {
        &self.path
    }
}

/// `go` directive metadata.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct GoModGoDirective {
    version: GoCompatibilityVersion,
}

impl GoModGoDirective {
    /// Creates a `go` directive.
    #[must_use]
    pub const fn new(version: GoCompatibilityVersion) -> Self {
        Self { version }
    }

    /// Returns the compatibility version.
    #[must_use]
    pub const fn version(self) -> GoCompatibilityVersion {
        self.version
    }
}

/// `toolchain` directive metadata.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct GoModToolchainDirective {
    version: GoToolchainVersion,
}

impl GoModToolchainDirective {
    /// Creates a `toolchain` directive.
    #[must_use]
    pub const fn new(version: GoToolchainVersion) -> Self {
        Self { version }
    }

    /// Returns the toolchain version.
    #[must_use]
    pub const fn version(self) -> GoToolchainVersion {
        self.version
    }
}

/// `require` directive metadata.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct GoModRequireDirective {
    dependency: GoModuleDependency,
    indirect: bool,
}

impl GoModRequireDirective {
    /// Creates a `require` directive.
    #[must_use]
    pub const fn new(dependency: GoModuleDependency) -> Self {
        Self {
            dependency,
            indirect: false,
        }
    }

    /// Marks the requirement as indirect.
    #[must_use]
    pub const fn indirect(mut self) -> Self {
        self.indirect = true;
        self
    }

    /// Returns the dependency metadata.
    #[must_use]
    pub const fn dependency(&self) -> &GoModuleDependency {
        &self.dependency
    }

    /// Returns whether this directive is indirect.
    #[must_use]
    pub const fn is_indirect(&self) -> bool {
        self.indirect
    }
}

/// `replace` directive metadata.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct GoModReplaceDirective {
    replacement: GoModuleReplacement,
}

impl GoModReplaceDirective {
    /// Creates a `replace` directive.
    #[must_use]
    pub const fn new(replacement: GoModuleReplacement) -> Self {
        Self { replacement }
    }

    /// Returns the replacement metadata.
    #[must_use]
    pub const fn replacement(&self) -> &GoModuleReplacement {
        &self.replacement
    }
}

/// `exclude` directive metadata.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct GoModExcludeDirective {
    path: GoModulePath,
    version: GoModuleVersion,
}

impl GoModExcludeDirective {
    /// Creates an `exclude` directive.
    #[must_use]
    pub const fn new(path: GoModulePath, version: GoModuleVersion) -> Self {
        Self { path, version }
    }

    /// Returns the module path.
    #[must_use]
    pub const fn path(&self) -> &GoModulePath {
        &self.path
    }

    /// Returns the module version.
    #[must_use]
    pub const fn version(&self) -> &GoModuleVersion {
        &self.version
    }
}

/// `retract` directive metadata.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct GoModRetractDirective {
    version: GoModuleVersion,
    rationale: Option<String>,
}

impl GoModRetractDirective {
    /// Creates a `retract` directive.
    #[must_use]
    pub const fn new(version: GoModuleVersion) -> Self {
        Self {
            version,
            rationale: None,
        }
    }

    /// Adds optional rationale text.
    #[must_use]
    pub fn with_rationale(mut self, rationale: impl AsRef<str>) -> Self {
        let trimmed = rationale.as_ref().trim();
        self.rationale = (!trimmed.is_empty()).then(|| trimmed.to_string());
        self
    }

    /// Returns the module version.
    #[must_use]
    pub const fn version(&self) -> &GoModuleVersion {
        &self.version
    }

    /// Returns optional rationale text.
    #[must_use]
    pub fn rationale(&self) -> Option<&str> {
        self.rationale.as_deref()
    }
}

fn normalized_label(value: &str) -> Result<String, GoModError> {
    let trimmed = value.trim();
    if trimmed.is_empty() {
        Err(GoModError::EmptyLabel)
    } else {
        Ok(trimmed.to_ascii_lowercase())
    }
}

#[cfg(test)]
mod tests {
    use super::{
        GoModConfigFile, GoModDirective, GoModExcludeDirective, GoModFile, GoModGoDirective,
        GoModModuleDirective, GoModReplaceDirective, GoModRequireDirective, GoModRetractDirective,
        GoModToolchainDirective,
    };
    use use_go_module::{GoModuleDependency, GoModulePath, GoModuleReplacement, GoModuleVersion};
    use use_go_version::{GoCompatibilityVersion, GoToolchainVersion, GoVersion};

    #[test]
    fn models_go_mod_directives() -> Result<(), Box<dyn std::error::Error>> {
        let module_path = GoModulePath::new("example.com/project")?;
        let module = GoModModuleDirective::new(module_path.clone());
        let go = GoModGoDirective::new(GoCompatibilityVersion::new("1.22".parse::<GoVersion>()?));
        let toolchain =
            GoModToolchainDirective::new(GoToolchainVersion::new("1.22.0".parse::<GoVersion>()?));
        let version = GoModuleVersion::new("v1.2.3")?;
        let dependency = GoModuleDependency::new(module_path.clone(), version.clone());
        let require = GoModRequireDirective::new(dependency).indirect();
        let replacement = GoModReplaceDirective::new(GoModuleReplacement::new(
            module_path.clone(),
            GoModulePath::new("../project")?,
        ));
        let exclude = GoModExcludeDirective::new(module_path.clone(), version.clone());
        let retract = GoModRetractDirective::new(version).with_rationale("bad release");
        let file = GoModFile::new()
            .with_directive(GoModDirective::Module(module))
            .with_directive(GoModDirective::Go(go))
            .with_directive(GoModDirective::Toolchain(toolchain))
            .with_directive(GoModDirective::Require(require))
            .with_directive(GoModDirective::Replace(replacement))
            .with_directive(GoModDirective::Exclude(exclude))
            .with_directive(GoModDirective::Retract(retract));

        assert_eq!(file.directives().len(), 7);
        Ok(())
    }

    #[test]
    fn parses_config_file_labels() -> Result<(), Box<dyn std::error::Error>> {
        assert_eq!("go.mod".parse::<GoModConfigFile>()?, GoModConfigFile::GoMod);
        assert_eq!(GoModConfigFile::GoMod.to_string(), "go.mod");
        Ok(())
    }
}