//! Convenient assertion macros that print the failed expressions and their evaluated values.
#![no_std]
#![no_implicit_prelude]

/// Create assertion macros for boolean binary operators.
#[macro_export]
macro_rules! operator_assertion_macros {
    (
        $(#![$shared_attr:meta])*
        in $module:path;
        use $assert:path;
        $(#[$attr_simple:meta])* simple = $name_simple:ident;
        $(#[$attr_expr:meta])* expr = $name_expr:ident;
    ) => {
        $(#[$shared_attr])*
        $(#[$attr_expr])*
        macro_rules! $name_expr {
            ($left:expr, $op:tt, $right:expr) => {
                match ($left, $right) {
                    (left, right) => {
                        $assert!(
                            left $op right,
                            "{left_expr} {op} {right_expr} ⇒ {left_value:?} {op} {right_value:?} ⇒ false",
                            op = stringify!($op),
                            left_expr = stringify!($left),
                            right_expr = stringify!($right),
                            left_value = left,
                            right_value = right,
                        )
                    }
                }
            };
        }

        $(#[$shared_attr])*
        $(#[$attr_simple])*
        macro_rules! $name_simple {
            ($left:ident $op:tt $right:ident) => {
                $module::$name_expr!($left, $op, $right)
            };
            ($left:ident $op:tt $right:literal) => {
                $module::$name_expr!($left, $op, $right)
            };
            ($left:literal $op:tt $right:ident) => {
                $module::$name_expr!($left, $op, $right)
            };
            ($left:literal $op:tt $right:literal) => {
                $module::$name_expr!($left, $op, $right)
            };
        }
    };
}

/// Create an assertion macro for boolean function calls.
#[macro_export]
macro_rules! function_assertion_macro {
    (
        $(#![$shared_attr:meta])*
        use $assert:path;
        $(#[$attr:meta])* $name:ident;
    ) => {
        $(#[$shared_attr])*
        $(#[$attr])*
        macro_rules! $name {
            ($function:ident($left:expr, $right:expr)) => {
                match ($left, $right) {
                    (left, right) => {
                        $assert!(
                            $function($left, $right),
                            "{func}({left_expr}, {right_expr}) ⇒ {func}({left_value:?}, {right_value:?}) ⇒ false",
                            func = stringify!($function),
                            left_expr = stringify!($left),
                            right_expr = stringify!($right),
                            left_value = left,
                            right_value = right,
                        )
                    }
                }
            };

            (not $function:ident($left:expr, $right:expr)) => {
                match ($left, $right) {
                    (left, right) => {
                        $assert!(
                            !$function($left, $right),
                            "{func}({left_expr}, {right_expr}) ⇒ {func}({left_value}, {right_value}) ⇒ true",
                            func = stringify!($function),
                            left_expr = stringify!($left),
                            right_expr = stringify!($right),
                            left_value = left,
                            right_value = right,
                        )
                    }
                }
            };
        }
    };
}

operator_assertion_macros! {
    #![macro_export]
    in ::assert_cmp;
    use ::core::assert;

    /// Assert that a binary expression of 2 identifiers/literals returns `true`.
    ///
    /// **Syntax:**
    ///
    /// ```ignore
    /// assert_op!($left $op $right)
    /// ```
    ///
    /// * `$left` and `$right` are either identifiers or literals or both.
    /// * `$op` is a binary operator (e.g. `>`, `<`, `>=`, `<=`, `==`, `!=`).
    ///
    /// **Example:** An assertion that passes
    ///
    /// ```
    /// # use assert_cmp::assert_op;
    /// assert_op!(123 < 456);
    /// ```
    ///
    /// **Example:** An assertion that fails
    ///
    /// ```should_panic
    /// # use assert_cmp::assert_op;
    /// assert_op!(123 > 456); // panic: 123 > 456 ⇒ 123 > 456 ⇒ false
    /// ```
    simple = assert_op;

    /// Assert that a binary expression of 2 expressions returns `true`.
    ///
    /// **Syntax:**
    ///
    /// ```ignore
    /// assert_op_expr!($left, $op, $right)
    /// ```
    ///
    /// * `$left` and `$right` are expressions.
    /// * `$op` is a binary operator (e.g. `>`, `<`, `>=`, `<=`, `==`, `!=`).
    ///
    /// **Example:** An assertion that passes
    ///
    /// ```
    /// # use assert_cmp::assert_op_expr;
    /// assert_op_expr!(12 + 34, ==, 34 + 12);
    /// ```
    ///
    /// **Example:** An assertion that fails
    ///
    /// ```should_panic
    /// # use assert_cmp::assert_op_expr;
    /// assert_op_expr!(12 + 34, ==, 43 + 21); // panic: 12 + 34 == 43 + 21 ⇒ 46 == 64 ⇒ false
    /// ```
    expr = assert_op_expr;
}

operator_assertion_macros! {
    #![macro_export]
    in ::assert_cmp;
    use ::core::debug_assert;

    /// Assert that a binary expression of 2 identifiers/literals returns `true`.
    ///
    /// This macro is the debug-only version of [`assert_op`].
    /// It acts like `assert_op` in debug mode, but does nothing in release mode.
    simple = debug_assert_op;

    /// Assert that a binary expression of 2 expressions returns `true`.
    ///
    /// This macro is the debug-only version of [`assert_op`].
    /// It acts like `assert_op_expr` in debug mode, but does nothing in release mode.
    expr = debug_assert_op_expr;
}

function_assertion_macro! {
    #![macro_export]
    use ::core::assert;

    /// Assert that a binary function call of 2 expressions returns `true`.
    ///
    /// **Syntax:**
    ///
    /// ```ignore
    /// assert_fn!($function($left, $right))
    /// ```
    ///
    /// ```ignore
    /// assert_fn!(not $function($left, $right))
    /// ```
    ///
    /// * `$function` is an identifier of a binary function.
    /// * `$left` and `$right` are expressions.
    /// * `not`'s appearance means expecting the function call to returns `false` instead of `true`.
    ///
    /// **Example:** An assertion that passes
    ///
    /// ```
    /// # use assert_cmp::assert_fn;
    /// fn func<A, B>(_: A, _: B) -> bool {
    ///   true
    /// }
    /// assert_fn!(func(123, 456));
    /// ```
    ///
    /// **Example:** An assertion that fails
    ///
    /// ```should_panic
    /// # use assert_cmp::assert_fn;
    /// fn func<A, B>(_: A, _: B) -> bool {
    ///   false
    /// }
    /// assert_fn!(func(123, 456)); // panic: func(123, 456) ⇒ func(123, 456) ⇒ false
    /// ```
    ///
    /// **Example:** A negative assertion that passes
    ///
    /// ```
    /// # use assert_cmp::assert_fn;
    /// fn func<A, B>(_: A, _: B) -> bool {
    ///   false
    /// }
    /// assert_fn!(not func(123, 456));
    /// ```
    ///
    /// **Example:** A negative assertion that fails
    ///
    /// ```should_panic
    /// # use assert_cmp::assert_fn;
    /// fn func<A, B>(_: A, _: B) -> bool {
    ///   true
    /// }
    /// assert_fn!(not func(123, 456)); // panic: func(123, 456) ⇒ func(123, 456) ⇒ true
    /// ```
    assert_fn;
}

function_assertion_macro! {
    #![macro_export]
    use ::core::debug_assert;

    /// Assert that a binary function call of 2 expressions returns `true`.
    ///
    /// This macro is the debug-only version of [`assert_fn`].
    /// It acts like `assert_op_expr` in debug mode, but does nothing in release mode.
    debug_assert_fn;
}