// Rust language amplification derive library providing multiple generic trait
// implementations, type wrappers, derive macros and other language enhancements
//
// Written in 2019-2021 by
//     Dr. Maxim Orlovsky <orlovsky@pandoracore.com>
//
// To the extent possible under law, the author(s) have dedicated all
// copyright and related and neighboring rights to this software to
// the public domain worldwide. This software is distributed without
// any warranty.
//
// You should have received a copy of the MIT License
// along with this software.
// If not, see <https://opensource.org/licenses/MIT>.

#![allow(deprecated)] // We need this at mod level to support rustc 1.26.0

use std::fmt::{Display, Formatter, self};
use std::convert::Infallible;
use proc_macro2::Span;

/// Errors representing inconsistency in proc macro attribute structure
#[derive(Clone, Debug)]
pub enum Error {
    /// Parse error from a `syn` crate
    Parse(syn::Error),

    /// Names of two merged attributes must match each other
    NamesDontMatch(String, String),

    /// Singular argument (of form `#[attr = ...]`) has multiple occurrences
    /// each assigned value. This is meaningless.
    MultipleSingularValues(String),

    /// Multiple literal non-string values are given for a parametrized
    /// attribute in form of `#[attr(literal1, literal2)]`. This is
    /// meaningless.
    MultipleLiteralValues(String),

    /// Attribute contains unsupported literal argument
    UnsupportedLiteral(String),

    /// Attribute must be in a singular form (`#[attr]` or `#[attr = ...]`)
    SingularAttrRequired(String),

    /// Attribute must be in a parametrized form (`#[attr(...)]`)
    ParametrizedAttrRequired(String),

    /// Attribute has an unknown argument
    AttributeUnknownArgument {
        /// Attribute name
        attr: String,
        /// Argument name
        arg: String,
    },

    /// Attribute is not allowed to have argument of type `arg`
    ArgTypeProhibited {
        /// Attribute name
        attr: String,
        /// Argument name
        arg: String,
    },

    /// Number of `arg` arguments in attribute `attr` exceeds maximum
    ArgNumberExceedsMax {
        /// Attribute name
        attr: String,
        /// Argument type name
        type_name: String,
        /// Number of arguments
        no: usize,
        /// Maximum allowed number of arguments
        max_no: u8,
    },

    /// Attribute argument `arg` must not have a value
    ArgMustNotHaveValue {
        /// Attribute name
        attr: String,
        /// Argument name
        arg: String,
    },

    /// Attribute must has an `arg` argument
    ArgRequired {
        /// Attribute name
        attr: String,
        /// Argument name
        arg: String,
    },

    /// Attribute or attribute argument name (in form of `#[attr(arg = ...)]`)
    /// must be an identifier (like `arg`) and not a path (like `std::io`)
    ArgNameMustBeIdent,

    /// The same argument name is used multiple times within parametrized
    /// attribute (like in `#[attr(name1 = value1, name1 = value2)]`)
    ArgNameMustBeUnique {
        /// Attribute name
        attr: String,
        /// Argument name
        arg: String,
    },

    /// Attribute or attribute argument must has a value:
    /// `#[attr(arg = value)]`
    ArgValueRequired {
        /// Attribute name
        attr: String,
        /// Argument name
        arg: String,
    },

    /// Attribute value type mismatch
    ArgValueTypeMismatch {
        /// Attribute name
        attr: String,
        /// Argument name
        arg: String,
    },

    /// Parametrized attribute argument must have a literal value (string,
    /// integer etc): `#[attr(arg = "value")]` or `#[arg = 4]`
    ArgValueMustBeLiteral,

    /// Parametrized attribute argument must be a valid type name:
    /// `#[attr(arg = u8)]` or `#[arg = String]`
    ArgValueMustBeType,

    /// Parametrized attribute (in form of `#[attr(...)]`) does not
    /// have a single value
    ParametrizedAttrHasNoValue(String),

    /// Lists nested within attribute arguments, like `#[attr(arg(...))]`
    /// are not supported
    #[deprecated(
        since = "1.1.0",
        note = "This error variant is not used anymore after the introduction of custom attribute parser"
    )]
    NestedListsNotSupported(String),
}

impl From<Infallible> for Error {
    fn from(_: Infallible) -> Self {
        unreachable!()
    }
}

impl From<syn::Error> for Error {
    fn from(err: syn::Error) -> Self {
        Error::Parse(err)
    }
}

impl From<Error> for syn::Error {
    fn from(err: Error) -> Self {
        syn::Error::new(Span::call_site(), err.to_string())
    }
}

impl Display for Error {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Error::Parse(err) => write!(f, "attribute parse error: {}", err),
            Error::NamesDontMatch(name1, name2) => write!(
                f,
                "Names of two merged attributes (`{}` and `{}`) must match",
                name1,
                name2
            ),
            Error::MultipleSingularValues(name) => write!(
                f,
                "Multiple values assigned to `{}` attribute",
                name
            ),
            Error::MultipleLiteralValues(name) => write!(
                f,
                "Multiple literal values provided for `{}` attribute",
                name
            ),
            Error::SingularAttrRequired(name) => write!(
                f,
                "Attribute `{}` must be in a singular form (`#[attr]` or `#[attr = ...]`)",
                name
            ),
            Error::ParametrizedAttrRequired(name) => write!(
                f,
                "Attribute `{}` must be in a parametrized form (`#[attr(...)]`)",
                name
            ),
            Error::ArgMustNotHaveValue { attr, arg } => write!(
                f,
                "Argument {arg} in `{attr}` attribute must not have a value",
                attr = attr, arg = arg
            ),
            Error::ArgTypeProhibited { attr, arg: type_name } => write!(
                f,
                "Attribute `{}` prohibits arguments of type `{}`",
                attr, type_name
            ),
            Error::ArgRequired { attr, arg } => write!(
                f,
                "Attribute `{}` requires argument `{}` to be explicitly specified",
                attr, arg,
            ),
            Error::ArgNameMustBeUnique { attr, arg } => write!(
                f,
                "Argument names must be unique, while attribute `{}` contains multiple arguments with name`{}`",
                attr, arg,
            ),
            Error::ArgNameMustBeIdent => write!(
                f,
                "Attribute arguments must be identifiers, not paths",
            ),
            Error::ArgValueRequired { attr, arg } => write!(
                f,
                "Attribute `{}` requires value for argument `{}`",
                attr, arg
            ),
            Error::ArgValueMustBeLiteral => f.write_str(
                "Attribute argument value must be a literal (string, int etc)",
            ),
            Error::ArgValueMustBeType => {
                f.write_str("Attribute value for must be a valid type name")
            }
            Error::ParametrizedAttrHasNoValue(name) => {
                write!(
                    f,
                    "Attribute `{name}` must be in a `#[{name} = ...]` form",
                    name = name
                )
            }
            Error::NestedListsNotSupported(name) => write!(
                f,
                "Attribute `{name}` must be in `{name} = ...` form and a nested list",
                name = name,
            ),
            Error::UnsupportedLiteral(attr) => write!(
                f,
                "Attribute `{}` has an unsupported type of literal as one of its arguments",
                attr
            ),
            Error::AttributeUnknownArgument { attr, arg } => write!(
                f,
                "Attribute `{}` has an unknown argument `{}`",
                attr, arg
            ),
            Error::ArgNumberExceedsMax { attr, type_name, no, max_no } => write!(
                f,
                "Attribute `{}` has excessive number of arguments of type `{}` ({} while only {} are allowed)",
                attr, type_name, no, max_no
            ),
            Error::ArgValueTypeMismatch { attr, arg } => write!(
                f,
                "Type mismatch in attribute `{}` argument `{}`",
                attr, arg
            ),
        }
    }
}

impl std::error::Error for Error {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            Error::Parse(err) => Some(err),
            Error::NamesDontMatch(_, _)
            | Error::MultipleSingularValues(_)
            | Error::MultipleLiteralValues(_)
            | Error::SingularAttrRequired(_)
            | Error::ArgMustNotHaveValue { .. }
            | Error::ArgTypeProhibited { .. }
            | Error::ArgRequired { .. }
            | Error::ParametrizedAttrRequired(_)
            | Error::ArgNameMustBeIdent
            | Error::ArgNameMustBeUnique { .. }
            | Error::ArgValueRequired { .. }
            | Error::ArgValueMustBeLiteral
            | Error::ArgValueMustBeType
            | Error::ParametrizedAttrHasNoValue(_)
            | Error::UnsupportedLiteral(_)
            | Error::AttributeUnknownArgument { .. }
            | Error::ArgNumberExceedsMax { .. }
            | Error::ArgValueTypeMismatch { .. } => None,
            Error::NestedListsNotSupported(_) => None,
        }
    }
}