// SPDX-FileCopyrightText: 2024 Simon Bruder <simon@sbruder.de>
//
// SPDX-License-Identifier: LGPL-2.1-or-later

use std::path::PathBuf;

use proc_macro2::TokenStream;
use quote::{quote, ToTokens, TokenStreamExt};
use spdx::{ExceptionId, LicenseId};

/// Error type.
#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("cargo metadata invocation failed: {0}")]
    CargoMetadata(#[from] cargo_metadata::Error),
    #[error("parsing SPDX expression failed: {0}")]
    SpdxParse(#[from] spdx::ParseError),
    #[error("IO Error: {0}")]
    Io(#[from] std::io::Error),

    /// The crate does not specify either `license` or `license-file` in its manifest.
    #[error("no license specified for crate {0}")]
    NoLicense(String),
    /// The crate’s `license` includes license identifiers which are not standard SPDX identifiers.
    #[error("non-SPDX license identifier specified for crate {0}")]
    NonSpdxLicense(String),
    /// The crate specifies no website.
    ///
    /// This means it does not set any of the following manifest keys:
    ///
    /// - [`homepage`](https://doc.rust-lang.org/cargo/reference/manifest.html#the-homepage-field)
    /// - [`repository`](https://doc.rust-lang.org/cargo/reference/manifest.html#the-repository-field)
    /// - [`documentation`](https://doc.rust-lang.org/cargo/reference/manifest.html#the-documentation-field)
    #[error("no website found for crate {0}")]
    NoWebsite(String),
}

type Result<T> = std::result::Result<T, Error>;

/// Licensing information returned by [`collect`].
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Licensing {
    /// All dependencies of the crate (including transitive dependencies and the crate itself).
    pub packages: Vec<Crate>,
    /// All SPDX licenses used by the crate and its dependencies.
    ///
    /// It does not include non-SPDX-licenses.
    /// Where such custom licenses are used,
    /// their text is only included as part of the corresponding [`Crate`].
    pub licenses: Vec<LicenseId>,
    /// All license exceptions used by the crate and its dependencies.
    pub exceptions: Vec<ExceptionId>,
}

impl Licensing {
    #[doc(hidden)]
    pub fn __macro_internal_new(
        packages: &[Crate],
        licenses: &[&str],
        exceptions: &[&str],
    ) -> Self {
        Self {
            packages: packages.to_vec(),
            licenses: licenses
                .iter()
                .map(|id| spdx::license_id(id))
                .map(Option::unwrap)
                .collect(),
            exceptions: exceptions
                .iter()
                .map(|id| spdx::exception_id(id))
                .map(Option::unwrap)
                .collect(),
        }
    }
}

impl ToTokens for Licensing {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let Self {
            packages,
            licenses,
            exceptions,
        } = self;

        let licenses = licenses.iter().map(|l| l.name.to_string());
        let exceptions = exceptions.iter().map(|e| e.name.to_string());

        tokens.append_all(quote! {
            ::embed_licensing::Licensing::__macro_internal_new(
                &[#(#packages),*],
                &[#(#licenses),*],
                &[#(#exceptions),*],
            )
        })
    }
}

/// Information about a crate.
///
/// The crate can be either the crate from which [`collect`] is called,
/// or one of its dependencies.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Crate {
    /// The name of the crate.
    pub name: String,
    /// The version of the crate.
    pub version: String,
    /// The authors of the crate.
    pub authors: Vec<String>,
    /// The licenses of the crate.
    ///
    /// If the
    /// [`license`](https://doc.rust-lang.org/cargo/reference/manifest.html#the-license-and-license-file-fields)
    /// attribute of the manifest is set,
    /// its content is be passed as an [`spdx::Expression`].
    /// Otherwise, if the
    /// [`license-file`](https://doc.rust-lang.org/cargo/reference/manifest.html#the-license-and-license-file-fields)
    /// is specified,
    /// its content is be included as a String.
    pub license: CrateLicense,
    pub website: String,
}

impl PartialOrd for Crate {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for Crate {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.name.cmp(&other.name)
    }
}

impl Crate {
    #[doc(hidden)]
    pub fn __macro_internal_new(
        name: &str,
        version: &str,
        authors: &[&str],
        license: CrateLicense,
        website: &str,
    ) -> Self {
        Self {
            name: name.to_string(),
            version: version.to_string(),
            authors: authors.iter().map(|s| s.to_string()).collect(),
            license,
            website: website.to_string(),
        }
    }
}

impl ToTokens for Crate {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let Self {
            name,
            version,
            authors,
            license,
            website,
        } = self;

        tokens.append_all(quote! {
            ::embed_licensing::Crate::__macro_internal_new(#name, #version, &[#(#authors),*], #license, #website)
        })
    }
}

/// Represents the license of a [`Crate`].
#[derive(Clone, Debug)]
#[allow(clippy::large_enum_variant)] // SpdxExpression is much more common than Other
pub enum CrateLicense {
    /// The [`Crate`]’s license is specified by a [`spdx::Expression`].
    SpdxExpression(spdx::Expression),
    /// The [`Crate`] has a custom license whose contents are included in the argument.
    Other(String),
}

impl PartialEq for CrateLicense {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::SpdxExpression(a), Self::SpdxExpression(b)) => a == b,
            (Self::Other(a), Self::Other(b)) => a == b,
            _ => false,
        }
    }
}

impl Eq for CrateLicense {}

impl CrateLicense {
    #[doc(hidden)]
    pub fn __macro_internal_new_spdx_expression(expr: &str) -> Self {
        Self::SpdxExpression(spdx::Expression::parse_mode(expr, spdx::ParseMode::LAX).unwrap())
    }
}

impl ToTokens for CrateLicense {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        tokens.append_all(match self {
            Self::SpdxExpression(expr) => {
                let expr_string = expr.to_string();
                quote!(
                    ::embed_licensing::CrateLicense::__macro_internal_new_spdx_expression(#expr_string)
                )
            }
            Self::Other(content) => {
                quote!(::embed_licensing::CrateLicense::Other(#content.to_string()))
            }
        })
    }
}

/// Collect licensing information at runtime.
///
/// It uses the defaults of `cargo metadata`,
/// which is to search for `Cargo.toml` in the current directory and its parent directories.
///
/// To specify a manifest path, please use [`collect_from_manifest`].
pub fn collect() -> Result<Licensing> {
    collect_internal(None::<PathBuf>)
}

/// Collect licensing information from given manifest path.
pub fn collect_from_manifest(manifest_path: impl Into<PathBuf>) -> Result<Licensing> {
    collect_internal(Some(manifest_path))
}

fn collect_internal(manifest_path: Option<impl Into<PathBuf>>) -> Result<Licensing> {
    let mut cmd = cargo_metadata::MetadataCommand::new();
    if let Some(manifest_path) = manifest_path {
        cmd.manifest_path(manifest_path);
    }
    let metadata = cmd.exec()?;

    let mut licensing = Licensing {
        packages: Vec::new(),
        licenses: Vec::new(),
        exceptions: Vec::new(),
    };

    for package in metadata.packages {
        let license = if let Some(license_expr) = package.license {
            let license = spdx::Expression::parse_mode(&license_expr, spdx::ParseMode::LAX)?;

            for node in license.iter() {
                if let spdx::expression::ExprNode::Req(req) = node {
                    licensing.licenses.push(
                        req.req
                            .license
                            .id()
                            .ok_or(Error::NonSpdxLicense(package.name.clone()))?,
                    );

                    if let Some(exception) = req.req.exception {
                        licensing.exceptions.push(exception);
                    }
                }
            }
            CrateLicense::SpdxExpression(license)
        } else if let Some(license_file) = package.license_file {
            CrateLicense::Other(std::fs::read_to_string(
                package
                    .manifest_path
                    .clone()
                    .parent()
                    .expect("the crate’s manifest path does not have a parent directory")
                    .join(license_file),
            )?)
        } else {
            return Err(Error::NoLicense(package.name));
        };

        licensing.packages.push(Crate {
            name: package.name.clone(),
            version: package.version.to_string(),
            authors: package.authors,
            license,
            website: package
                .homepage
                .or(package.repository)
                .or(package.documentation)
                .ok_or(Error::NoWebsite(package.name))?,
        })
    }

    licensing.packages.sort_unstable();

    licensing.licenses.sort_unstable();
    licensing.licenses.dedup();

    licensing.exceptions.sort_unstable();
    licensing.exceptions.dedup();

    Ok(licensing)
}