midenup 0.3.0

use std::{
    borrow::Cow,
    collections::{BTreeMap, HashMap},
    ffi::OsString,
    fmt::{self, Display},
    hash::Hash,
    path::{Path, PathBuf},
};

use anyhow::{Context, bail};
use colored::Colorize;
use serde::{Deserialize, Serialize};
use sha2::Digest;

use crate::{
    artifact::{Artifacts, TargetTriple},
    config::Config,
    profile::Profile,
    toolchain::{Toolchain, ToolchainJustification},
    utils,
    version::{Authority, GitTarget},
};

/// Hash created to distinguish one installed channel from the another.
pub struct ChannelHash(String);

impl Display for ChannelHash {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(&self.0)
    }
}

#[derive(Serialize, Deserialize, Debug, Clone, Hash)]
#[serde(untagged)]
pub enum MigrationStrategy {
    NameChange { old_channel: semver::Version },
}

/// Tags used to identify special qualities of a specific channel.
#[derive(Serialize, Deserialize, Debug, Clone, Hash)]
#[serde(rename_all = "snake_case")]
pub enum Tags {
    /// The channel is partially installed, i.e. only a subset of components
    /// have been installed.
    Partial,
    /// The channel has been moved to a new channel or potentially even removed.
    Migration {
        #[serde(flatten)]
        migration: MigrationStrategy,
    },
}

/// Represents a specific release channel for a toolchain.
///
/// Different channels have different stability guarantees. See the specific details for the
/// channel you are interested in to learn more.
#[derive(Serialize, Deserialize, Debug, Clone, Hash)]
pub struct Channel {
    /// Channels are identified by their name. The name corresponds to the channel's version.
    /// The version can contain suffixes such as "-custom", "-beta".
    pub name: semver::Version,
    /// This is used to tag special channels. Most notably, the current "stable" channel is marked
    /// with the [`ChannelAlias::Stable`] alias.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alias: Option<ChannelAlias>,
    /// Set of tags used to denote a special characteristic about the channel.
    ///
    /// Mainly used for locally installed channels.
    #[serde(default)]
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub tags: Vec<Tags>,
    /// The set of toolchain components available in this channel
    pub components: Vec<Component>,
}

enum InstallationMotive {
    ExplicitelySelected,
    Dependency { comp_name: String },
}

impl Display for InstallationMotive {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            InstallationMotive::Dependency { comp_name } => {
                write!(f, "is a depency of component {comp_name}")
            },
            InstallationMotive::ExplicitelySelected => {
                write!(f, "was explictely selected for installation")
            },
        }
    }
}

#[derive(Debug, Clone)]
pub enum UpstreamMatch {
    /// The remote Channel is this Channel's upstream equivalent.
    UpstreamCounterpart,
    /// The remote Channel is this Channel's equivalent and got migrated.
    Migrated(MigrationStrategy),
}

#[derive(Debug, Clone)]
pub struct UpstreamChannel {
    pub channel: Channel,
    pub upstream_match: UpstreamMatch,
}

impl UpstreamChannel {
    pub fn new(channel: Channel, upstream_match: UpstreamMatch, config: &Config) -> Self {
        let mut synced_channel = channel.clone();
        synced_channel.sync(config);
        UpstreamChannel { channel: synced_channel, upstream_match }
    }
}

impl Channel {
    pub fn new(
        name: semver::Version,
        alias: Option<ChannelAlias>,
        components: Vec<Component>,
        tags: Vec<Tags>,
    ) -> Self {
        Self { name, alias, components, tags }
    }

    pub fn get_component(&self, name: impl AsRef<str>) -> Option<&Component> {
        let name = name.as_ref();
        self.components.iter().find(|c| c.name == name)
    }

    pub fn get_component_mut(&mut self, name: impl AsRef<str>) -> Option<&mut Component> {
        let name = name.as_ref();
        self.components.iter_mut().find(|c| c.name == name)
    }

    /// Is this channel a stable release? Does not imply that it has the `stable` alias.
    ///
    /// To find out the latest stable [Channel], use [crate::manifest::Manifest::get_latest_stable].
    pub fn is_stable(&self) -> bool {
        self.alias.as_ref().is_none_or(|alias| matches!(alias, ChannelAlias::Stable))
    }

    pub fn is_nightly(&self) -> bool {
        self.alias
            .as_ref()
            .is_some_and(|alias| matches!(alias, ChannelAlias::Nightly(_)))
    }

    /// Determines if the current toolchain was installed "partially", i.e., containing only a
    /// subset of all the available components. This can be the case with `miden-toolchain.toml`.
    pub fn is_partially_installed(&self) -> bool {
        self.tags.iter().any(|tag| matches!(tag, Tags::Partial))
    }

    pub fn is_latest_nightly(&self) -> bool {
        self.alias
            .as_ref()
            .is_some_and(|alias| matches!(alias, ChannelAlias::Nightly(None)))
    }

    pub fn get_channel_dir(&self, config: &Config) -> PathBuf {
        let installed_toolchains_dir = config.midenup_home.join("toolchains");
        installed_toolchains_dir.join(format!("{}", self.name))
    }

    pub fn content_hash(&self) -> ChannelHash {
        use core::fmt::Write;

        struct Sha256Hasher(sha2::Sha256);
        impl core::hash::Hasher for Sha256Hasher {
            fn finish(&self) -> u64 {
                panic!("finish is intended to be left unused")
            }

            fn write(&mut self, bytes: &[u8]) {
                self.0.update(bytes);
            }
        }
        let mut h = Sha256Hasher(sha2::Sha256::new());
        self.hash(&mut h);
        let out = h.0.finalize();
        let mut hex = String::with_capacity(64);
        for byte in out {
            write!(&mut hex, "{byte:02x}").expect("failed to write channel hash");
        }
        ChannelHash(hex)
    }

    /// Get all the aliases that the Channel is aware of
    pub fn get_aliases(&self) -> HashMap<Alias, CliCommands> {
        self.components.iter().fold(HashMap::new(), |mut acc, component| {
            acc.extend(component.aliases.clone());
            acc
        })
    }

    /// Creates a "partial channel" from the original channel, given a toolchain "Partial" in this
    /// context refers to the fact that the channel will not install all the available components,
    /// but rather a subset.
    pub fn create_subset(
        &self,
        current_toolchain: &Toolchain,
        toolchain_justification: &ToolchainJustification,
    ) -> Option<Channel> {
        let profile = current_toolchain.profile.unwrap_or_default();
        let mut requested_components = Vec::new();
        let mut components_to_install: Vec<Component> = Vec::new();
        let mut components_not_found: HashMap<String, Vec<InstallationMotive>> = HashMap::new();

        match profile {
            Profile::Minimal => {
                // Select components that are not marked "optional" from the manifest
                requested_components.extend(
                    self.components
                        .iter()
                        .filter_map(|c| if c.optional { None } else { Some(c.name.as_ref()) }),
                );
                for extra_component in current_toolchain.components.iter() {
                    if !requested_components.contains(&extra_component.as_str()) {
                        requested_components.push(extra_component.as_str());
                    }
                }
            },
            Profile::Complete => {
                // Select all components from the manifest
                requested_components.extend(self.components.iter().map(|c| c.name.as_ref()));
                // We add any non-duplicate extra components here so that we can catch invalid
                // components below
                for extra_component in current_toolchain.components.iter() {
                    if !requested_components.contains(&extra_component.as_str()) {
                        requested_components.push(extra_component.as_str());
                    }
                }
            },
        }

        for component_name in requested_components {
            let Some(component) = self.get_component(component_name) else {
                // NOTE: In order to provide more helpful error messages, we collect all the missing
                // components and return a single error message at the end.
                components_not_found
                    .entry(component_name.to_string())
                    .or_default()
                    .push(InstallationMotive::ExplicitelySelected);

                continue;
            };
            components_to_install.push(component.clone());

            for depenency_name in &component.requires {
                let Some(dependency) = self.get_component(depenency_name) else {
                    components_not_found.entry(depenency_name.to_string()).or_default().push(
                        InstallationMotive::Dependency { comp_name: component_name.to_string() },
                    );
                    continue;
                };

                components_to_install.push(dependency.clone());
            }
        }
        if !components_not_found.is_empty() {
            println!(
                "{}: Some elements present in the current Toolchain are not present in the \
                 upstream channel: {}",
                "WARNING".yellow().bold(),
                self.name
            );
            println!();

            for (missing_component_name, motive) in components_not_found {
                let motives = motive
                    .iter()
                    .map(|motive| motive.to_string())
                    .collect::<Vec<String>>()
                    .join(" and ");

                println!(
                    "- {missing_component_name}, which {motives}, is missing in upstream channel"
                );
            }

            println!();
            println!("These components will be ignored for the current install.");
            println!();
            // TODO: Add messages for the other justifications
            #[allow(clippy::single_match)]
            match toolchain_justification {
                ToolchainJustification::MidenToolchainFile { path } => println!(
                    "Check the `miden_toolchain.toml` file in {} to see if any component is \
                     misspelled or got removed from upstream",
                    path.display()
                ),
                _ => (),
            }
        }

        let partial_channel = Channel {
            name: self.name.clone(),
            alias: self.alias.clone(),
            tags: vec![Tags::Partial],
            components: components_to_install,
        };

        Some(partial_channel)
    }

    /// Checks wheter the channel [other] is Self's upstream counterpart.
    /// Currently this can happen in two scenarios:
    /// - They share the same name (i.e. version).
    /// - The upstream version is tagged as having being migrated from self's .
    pub fn find_upstream_counterpart(&self, config: &Config) -> Option<UpstreamChannel> {
        let upstream_manifest = &config.manifest;
        let mut upstream_counterpart = None;

        for upstream_channel in upstream_manifest.get_channels() {
            // They share version
            let equal_name = self.name == upstream_channel.name;
            if equal_name {
                let upstream_match = UpstreamMatch::UpstreamCounterpart;
                upstream_counterpart =
                    Some(UpstreamChannel::new(upstream_channel.clone(), upstream_match, config));
                break;
            };

            let was_migrated = upstream_channel.tags.iter().find_map(|tag| match tag {
                Tags::Migration { migration } => match migration {
                    // A channel is only considered as "migrated" if it's
                    // current name matches the "old_channel" field of an
                    // upstream channel.
                    MigrationStrategy::NameChange { old_channel } => {
                        if old_channel == &self.name {
                            Some(migration)
                        } else {
                            None
                        }
                    },
                },
                _ => None,
            });

            if let Some(migration) = was_migrated {
                let upstream_match = UpstreamMatch::Migrated(migration.clone());
                upstream_counterpart =
                    Some(UpstreamChannel::new(upstream_channel.clone(), upstream_match, config));
                break;
            };
        }
        upstream_counterpart
    }

    // Syncs the channel to the latest changes
    fn sync(&mut self, config: &Config) {
        for comp in self.components.iter_mut() {
            comp.sync(config);
        }
    }
}

impl Display for Channel {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self.alias {
            Some(ChannelAlias::Stable) => write!(f, "stable ({})", self.name),
            Some(ChannelAlias::Tag(tag)) => write!(f, "{}-{}", self.name, tag.as_ref()),
            Some(ChannelAlias::Nightly(tag)) => {
                let nightly_suffix =
                    tag.as_ref().map(|suffix| format!("-{}", suffix)).unwrap_or(String::from(""));
                write!(f, "nightly-{}{}", self.name, nightly_suffix)
            },
            None => write!(f, "{}", self.name),
        }
    }
}

/// A special alias/tag that a channel can posses. For more information see [`Channel::alias`].
/// These are only used for locally installed [`Channel`]s.
#[derive(Serialize, Debug, PartialEq, Eq, Clone, Hash)]
#[serde(rename_all = "snake_case")]
pub enum ChannelAlias {
    /// Represents `stable`. Only one [Channel] can be marked as `stable` at a time.
    Stable,
    /// Represents either `nightly` or `nightly-$SUFFIX`
    Nightly(Option<Cow<'static, str>>),
    /// An ad-hoc named alias for a channel. This can be used to tag custom channels with names such
    /// as `0.15.0-stable`.
    #[serde(untagged)]
    Tag(Cow<'static, str>),
}

impl<'de> serde::de::Deserialize<'de> for ChannelAlias {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        use serde::de::Unexpected;
        use serde_untagged::UntaggedEnumVisitor;

        UntaggedEnumVisitor::new()
            .string(|s| {
                s.parse::<ChannelAlias>().map_err(|err| {
                    serde::de::Error::invalid_value(Unexpected::Str(s), &err.to_string().as_str())
                })
            })
            .deserialize(deserializer)
    }
}

impl core::str::FromStr for ChannelAlias {
    type Err = anyhow::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "stable" => Ok(Self::Stable),
            "nightly" => Ok(Self::Nightly(None)),
            tag => match tag.strip_prefix("nightly-") {
                Some(suffix) => Ok(Self::Nightly(Some(Cow::Owned(suffix.to_string())))),
                None => Ok(Self::Tag(Cow::Owned(tag.to_string()))),
            },
        }
    }
}

/// Represents the file that the [Component] will install in the system.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash)]
#[serde(rename_all = "snake_case")]
pub enum InstalledFile {
    /// The component installs an executable.
    #[serde(untagged)]
    Executable {
        #[serde(rename = "installed_executable")]
        binary_name: String,
        /// The component is executable (i.e. a CLI Binary) but it is *not* intended to be executed
        /// on its own, rather only under aliases.
        ///
        /// An example of this behavior is `cargo miden`, which is only intended to be executed
        /// under the `miden new` and `miden build` aliases.
        ///
        /// IMPORTANT: In order for alias_only to take effect, binary_name *must* also be specified
        /// in the manifest.
        #[serde(default)]
        alias_only: bool,
    },
    /// The component installs a MaspLibrary.
    #[serde(untagged)]
    Library {
        #[serde(rename = "installed_library")]
        library_name: String,
        /// This is the name of the struct which exposes the `Library::write_to_file()` function,
        /// that is used to generate the associated `.masp` file.
        library_struct: String,
    },
}

impl InstalledFile {
    pub fn get_library_struct(&self) -> Option<&str> {
        match &self {
            InstalledFile::Executable { .. } => None,
            InstalledFile::Library { library_struct, .. } => Some(library_struct),
        }
    }

    pub fn get_path_from(&self, toolchain_dir: &Path) -> PathBuf {
        match &self {
            exe @ InstalledFile::Executable { .. } => {
                toolchain_dir.join("bin").join(exe.to_string())
            },
            lib @ InstalledFile::Library { .. } => toolchain_dir.join("lib").join(lib.to_string()),
        }
    }
}

impl Display for InstalledFile {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self {
            InstalledFile::Executable {
                binary_name: executable_name,
                alias_only: _,
            } => f.write_str(executable_name),
            InstalledFile::Library { library_name, library_struct: _ } => f.write_str(library_name),
        }
    }
}

/// Represents each possible "word" variant that is passed to the command line.
///
/// These are used to resolve an [Alias] to its associated command.
#[derive(Serialize, Deserialize, Debug, Clone, Hash)]
#[serde(rename_all = "snake_case")]
pub enum CliCommand {
    /// Resolve the command to a [Component]'s corresponding executable.
    Executable,
    /// Resolve the command to a toolchain library directory (`<toolchain>/lib`)
    #[serde(rename = "lib_path")]
    LibPath,
    /// Resolve the command to a toolchain var directory (`<toolchain>/var`).
    ///
    /// Optionally, it can contain a file name, which represents a file in `<toolchain>/var/<file>`.
    // NOTE: Potentially in the future, we might want this to be an Optional field
    #[serde(rename = "var_path")]
    VarPath,
    /// An argument that is passed verbatim, as is.
    #[serde(untagged)]
    Verbatim(String),
}

impl fmt::Display for CliCommand {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self {
            CliCommand::Executable => write!(f, "executable"),
            CliCommand::LibPath => write!(f, "lib_path"),
            CliCommand::VarPath => write!(f, "var_path"),
            CliCommand::Verbatim(word) => write!(f, "verbatim: {word}"),
        }
    }
}

pub fn resolve_command(
    commands: &[CliCommand],
    channel: &Channel,
    component: &Component,
    config: &Config,
) -> anyhow::Result<Vec<OsString>> {
    let mut resolution = Vec::with_capacity(commands.len());
    let mut commands = commands.iter();

    while let Some(command) = commands.next() {
        match command {
            CliCommand::Executable => {
                let name = &component.name;
                let component = channel.get_component(name).with_context(|| {
                    format!(
                        "Component named {} is not present in toolchain version {}",
                        name, channel.name
                    )
                })?;

                resolution.push(OsString::from(component.get_cli_display()));
            },
            CliCommand::LibPath => {
                let channel_dir = channel.get_channel_dir(config);

                let toolchain_path = channel_dir.join("lib");

                resolution.push(toolchain_path.into_os_string())
            },
            // The VarPath must be followed by a file name.
            CliCommand::VarPath => {
                let channel_dir = channel.get_channel_dir(config);

                let toolchain_path = channel_dir.join("var");

                let next_command =
                    commands.next().context("var_path needs to be followed by a path name")?;

                let CliCommand::Verbatim(directory_name) = next_command else {
                    bail!(format!("After var_path a file is required. Got: {}", next_command))
                };

                let full_path = toolchain_path.join(directory_name);

                resolution.push(full_path.into_os_string())
            },
            CliCommand::Verbatim(name) => resolution.push(OsString::from(name)),
        }
    }

    Ok(resolution)
}

pub type Alias = String;
/// List of the commands that need to be run when [Alias] is called.
pub type CliCommands = Vec<CliCommand>;

/// An installable component of a toolchain
#[derive(Serialize, Deserialize, Debug, Clone, Hash)]
pub struct Component {
    /// The canonical name of this toolchain component.
    pub name: Cow<'static, str>,
    /// The versioning authority for this component.
    #[serde(flatten)]
    pub version: Authority,
    /// Indicates that this component is not required for a minimal toolchain
    #[serde(default)]
    #[serde(skip_serializing_if = "is_false")]
    pub optional: bool,
    /// Optional features to enable, if applicable, when installing this component.
    #[serde(default)]
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub features: Vec<String>,
    /// Other components that are required if this component is installed.
    #[serde(default)]
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub requires: Vec<String>,
    /// Commands used to call the [Component]'s associated executable.
    ///
    /// IMPORTANT: This requires the [`Component::installed_file`] field to be an
    /// [`InstalledFile::Executable`] either explicitly or implicitly.
    #[serde(default)]
    #[serde(skip_serializing_if = "Vec::is_empty")]
    call_format: Vec<CliCommand>,
    /// If not None, then this component requires a specific toolchain to compile.
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rustup_channel: Option<String>,
    /// This field is used for crates that install files whose name is different than that of the
    /// crate.
    ///
    /// For instance: `miden-vm`'s executable is stored as 'miden'. This field indicates which type
    /// of file the component will install.
    ///
    /// IMPORTANT: If this field is missing from the manifest, then it means that the component
    /// will install an executable that is named just like the crate. To access this value, use
    /// [`Component::get_installed_file`].
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(flatten)]
    installed_file: Option<InstalledFile>,
    /// A map that associates each alias to the corresponding command that needs to be executed.
    ///
    /// NOTE: The list of commands that is resolved can have an "arbitrary" ordering: the
    /// executable associated with this command is not forced to come in first.
    ///
    /// Here's an example aliases entry in a manifest.json:
    ///
    /// ```json
    /// {
    ///   "name": "component-name",
    ///   "package": "component-package",
    ///   "version": "X.Y.Z",
    ///   "installed_executable": "miden-component",
    ///   "aliases": {
    ///       "alias1": [{"resolve": "component-name"}, {"verbatim": "argument"}],
    ///       "alias2": [{"verbatim": "cargo"}, {"resolve": "component-name"}, {"verbatim": "build"}]
    ///     }
    /// },
    /// ```
    #[serde(default)]
    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
    pub aliases: BTreeMap<Alias, CliCommands>,
    /// The file used by midenup's 'miden' to call the components executable.
    ///
    /// If `None`, then the component's file will be saved as `miden <name>`. This distinction
    /// exists mainly for components like `cargo-miden`, which differ in how they are called.
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    symlink_name: Option<String>,
    #[serde(default)]
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub initialization: Vec<String>,
    /// Pre-built artifact.
    #[serde(flatten)]
    pub artifacts: Option<Artifacts>,
}

const fn is_false(value: &bool) -> bool {
    !*value
}

impl Component {
    pub fn new(name: impl Into<Cow<'static, str>>, version: Authority) -> Self {
        Self {
            name: name.into(),
            version,
            optional: false,
            features: vec![],
            requires: vec![],
            call_format: vec![],
            rustup_channel: None,
            installed_file: None,
            aliases: BTreeMap::new(),
            symlink_name: None,
            initialization: Vec::new(),
            artifacts: None,
        }
    }

    /// This method is used to check if the current [Component] is up to date with its  upstream
    /// equivalent.
    ///
    /// This is used to check if they different in fields _besides_ the name. The [`Component::eq`]
    /// implementation only tests name equality and is only used to check for components that got
    /// added/removed.
    ///
    /// WARNING: The idea behind this function is to early return when a
    /// difference is found, and fallback to "UpToDate" if none are
    /// found. Therefore, there should be *no* early returns that return
    /// `UpToDate`, since they might skip a field that differes later on.
    pub fn is_up_to_date(&self, upstream: &Self) -> bool {
        match (&self.version, &upstream.version) {
            (
                Authority::Git {
                    repository_url: repository_url_a,
                    crate_name: crate_a,
                    target:
                        GitTarget::Branch {
                            name: name_a,
                            latest_revision: local_revision,
                        },
                },
                Authority::Git {
                    repository_url: repository_url_b,
                    crate_name: crate_b,
                    target:
                        GitTarget::Branch {
                            name: name_b,
                            latest_revision: upstream_revision,
                        },
                },
            ) => {
                if repository_url_a != repository_url_b {
                    return false;
                }

                if crate_a != crate_b {
                    return false;
                }

                if repository_url_a != repository_url_b {
                    return false;
                }

                if name_a != name_b {
                    return false;
                }

                match (local_revision, upstream_revision) {
                    (Some(local_revision), Some(upstream_revision)) => {
                        if *local_revision != *upstream_revision {
                            return false;
                        }
                    },
                    // If either is missing, trigger an update regardless.
                    _ => {
                        return false;
                    },
                };
            },
            (
                Authority::Path {
                    path: path_a,
                    crate_name: crate_name_a,
                    last_modification: last_modification_a,
                },
                Authority::Path {
                    path: path_b,
                    crate_name: crate_name_b,
                    last_modification: last_modification_b,
                },
            ) => {
                if *path_a != *path_b {
                    return false;
                }
                if *crate_name_a != *crate_name_b {
                    return false;
                }

                match (last_modification_a, last_modification_b) {
                    (Some(local_latest), Some(new_latest)) => {
                        if new_latest > local_latest {
                            return false;
                        }
                    },
                    // If anything failed, we simply mark the component as needing an update.
                    // The idea being that components installed from a path are skipped during
                    // updates by default and are only updated if the user explicitly passes the
                    // necessary flags.
                    _ => return false,
                }
            },
            (
                Authority::Cargo { package: package_a, version: version_a },
                Authority::Cargo { package: package_b, version: version_b },
            ) => {
                if package_a != package_b {
                    return false;
                }

                if version_a != version_b {
                    return false;
                }
            },
            _ => {
                // This case includes all the cases where the Authorities differ,
                // which are never considered "up to date".
                return false;
            },
        };

        if self.features != upstream.features {
            return false;
        }

        if self.requires != upstream.requires {
            return false;
        }

        if self.rustup_channel != upstream.rustup_channel {
            return false;
        }

        if self.installed_file != upstream.installed_file {
            return false;
        }

        true
    }

    /// Returns the name of the executable corresponding to this component.
    ///
    /// If the component does not specify the installed file name, that means that it installs and
    /// executable named exactly like the crate.
    pub fn get_installed_file(&self) -> InstalledFile {
        if let Some(installed_file) = &self.installed_file {
            installed_file.clone()
        } else {
            InstalledFile::Executable {
                binary_name: self.name.to_string(),
                // If not specified, all executable components are *not* alias_only
                alias_only: false,
            }
        }
    }

    pub fn set_installed_file(&mut self, installed_file: Option<InstalledFile>) {
        self.installed_file = installed_file;
    }

    /// Returns the string representation under which midenup calls a component.
    pub fn get_cli_display(&self) -> String {
        format!("miden {}", self.name)
    }

    /// Returns the name of symlink associated with a component.
    pub fn get_symlink_name(&self) -> String {
        if let Some(symlink_name) = &self.symlink_name {
            symlink_name.clone()
        } else {
            format!("miden {}", self.name)
        }
    }

    /// Returns the string representation under which midenup calls a component.
    pub fn get_call_format(&self) -> Vec<CliCommand> {
        if self.call_format.is_empty() {
            vec![CliCommand::Executable]
        } else {
            self.call_format.clone()
        }
    }

    /// Returns the URI for a given `target` (if available).
    pub fn get_artifact_uri(&self, target: &TargetTriple) -> Option<String> {
        self.artifacts.as_ref().and_then(|artifacts| artifacts.get_uri_for(target))
    }

    // Sync to the latest changes.
    pub fn sync(&mut self, config: &Config) {
        match &mut self.version {
            Authority::Path {
                path,
                crate_name: _crate_name,
                last_modification,
            } => {
                // If, for whatever reason, we fail to find the latest
                // registered modification, we simply leave it empty. That does
                // mean that an update will be triggered even if the component
                // does not need it.
                let path = if path.is_absolute() {
                    Cow::Borrowed(&*path)
                } else {
                    Cow::Owned(config.working_directory.join(&*path))
                };
                let latest_registered_modification =
                    utils::fs::latest_modification(&path).ok().map(|modification| modification.0);
                *last_modification = latest_registered_modification;
            },
            // NOTE: Components that are installed via git BRANCHES are a special case because we
            // need to check if new commits have been pushed since the component was installed.
            // When these components are installed, the lastest available commit hash is saved with
            // them in the local manifest. We use this to check if an update is in order. Do note
            // that the upstream manifest is not needed for these.
            Authority::Git {
                repository_url,
                crate_name: _crate_name,
                target,
            } => {
                match target {
                    GitTarget::Branch { name: branch_name, latest_revision } => {
                        // If, for whatever reason, we fail to find the latest hash, we
                        // simply leave it empty. That does mean that an update will be
                        // triggered even if the component does not need it.
                        let latest_upstream_revision =
                            utils::git::find_latest_hash(repository_url.as_str(), branch_name).ok();

                        *latest_revision = latest_upstream_revision;
                    },
                    GitTarget::Revision { hash: _hash } => {},
                    GitTarget::Tag { name: _name } => {},
                }
            },
            Authority::Cargo { package: _package, version: _version } => {},
        }
    }
}

/// User-facing channel reference.
///
/// The main difference with this and [Channel] is the definition of "stable". The definition of
/// "stable" 'under the hood' is the lastest available non-nightly channel. If the user passes
/// [`UserChannel::Stable`] as the target channel, we then handle the mapping from it to the
/// underlying [Channel] representation.
#[derive(Serialize, Default, Debug, Clone)]
#[serde(rename_all = "snake_case")]
pub enum UserChannel {
    #[default]
    Stable,
    Nightly,
    #[serde(untagged)]
    Version(semver::Version),
    #[serde(untagged)]
    Other(Cow<'static, str>),
}

impl Display for UserChannel {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Version(version) => write!(f, "{version}"),
            Self::Stable => f.write_str("stable"),
            Self::Nightly => f.write_str("nightly"),
            Self::Other(custom_name) => write!(f, "{custom_name}"),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for UserChannel {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        use serde::de::Unexpected;
        use serde_untagged::UntaggedEnumVisitor;

        UntaggedEnumVisitor::new()
            .string(|s| {
                s.parse::<UserChannel>().map_err(|err| {
                    serde::de::Error::invalid_value(Unexpected::Str(s), &err.to_string().as_str())
                })
            })
            .deserialize(deserializer)
    }
}

impl core::str::FromStr for UserChannel {
    type Err = anyhow::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        use anyhow::anyhow;

        match s {
            "stable" => Ok(Self::Stable),
            "nightly" => Ok(Self::Nightly),
            version => semver::Version::parse(version)
                .map(Self::Version)
                .map_err(|err| anyhow!("invalid channel version: {err}")),
        }
    }
}