#[command] 与 generate_handler!

use std::sync::atomic::{AtomicU32, Ordering};

#[derive(Default)]
struct Counter(AtomicU32);

#[tauri::command]
fn greet(name: &str) -> String {
  format!("hello, {name}")
}

#[tauri::command]
async fn word_count(text: String) -> usize {
  text.split_whitespace().count()
}

#[tauri::command]
fn bump<R: tauri::Runtime>(counter: tauri::State<'_, Counter>, app: tauri::AppHandle<R>) -> u32 {
  let _ = app.package_info();
  counter.0.fetch_add(1, Ordering::SeqCst) + 1
}

#[tauri::command(rename_all = "snake_case")]
fn snake(user_name: String) -> String {
  user_name
}

#[tauri::command(rename = "greetUser")]
fn greet_user(user_name: String) -> String {
  user_name
}

#[tauri::command]
async fn borrow_ok(name: &str) -> Result<String, String> {
  Ok(name.to_uppercase())
}

#[tauri::command]
async fn peek(counter: tauri::State<'_, Counter>) -> Result<u32, String> {
  Ok(counter.0.load(Ordering::SeqCst))
}

fn handlers<R: tauri::Runtime>(builder: tauri::Builder<R>) -> tauri::Builder<R> {
  builder.invoke_handler(tauri::generate_handler![greet, word_count, bump, snake, greet_user, borrow_ok, peek])
}

  quote!(
    #async_command_check

    #maybe_allow_unused
    #function

    // Command name macro used by the handler for pattern matching.
    // This macro returns the command name string literal (renamed or original).
    #maybe_allow_unused
    #maybe_macro_export
    #[doc(hidden)]
    macro_rules! #command_name_macro_ident {
      () => {
        #command_name_value
      };
    }

    #maybe_allow_unused
    #maybe_macro_export
    #[doc(hidden)]
    macro_rules! #wrapper {
      // double braces because the item is expected to be a block expression
      ($path:path, $invoke:ident) => {
        // The IIFE here is for preventing stack overflow on Windows,
        // see https://github.com/tauri-apps/tauri/issues/12488
        {
          move || {
            #[allow(unused_imports)]
            use #root::ipc::private::*;
            // prevent warnings when the body is a `compile_error!` or if the command has no arguments
            #[allow(unused_variables)]
            let #root::ipc::Invoke { message: #message, resolver: #resolver, acl: #acl } = $invoke;

            #maybe_span

            #body
          }
        }()
      };
    }

    // allow the macro to be resolved with the same path as the command function
    #[allow(unused_imports)]
    #visibility use {#wrapper, #command_name_macro_ident};
  )

fn greet(name: &str) -> String {
    ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("hello, {0}", name))
    })
}
#[allow(unused_imports)]
use {__cmd__greet, __tauri_command_name_greet};

  Ok(quote!(#root::ipc::CommandArg::from_command(
    #root::ipc::CommandItem {
      plugin: #plugin_name,
      name: #command_name,
      key: #key,
      message: &#message,
      acl: &#acl,
    }
  )))

                "bump" => {
                    ({
                        move || {
                            #[allow(unused_imports)]
                            use ::tauri::ipc::private::*;
                            #[allow(unused_variables)]
                            let ::tauri::ipc::Invoke {
                                message: __tauri_message__,
                                resolver: __tauri_resolver__,
                                acl: __tauri_acl__,
                            } = __tauri_invoke__;
                            let result = bump(
                                match ::tauri::ipc::CommandArg::from_command(::tauri::ipc::CommandItem {
                                    plugin: ::core::option::Option::None,
                                    name: "bump",
                                    key: "counter",
                                    message: &__tauri_message__,
                                    acl: &__tauri_acl__,
                                }) {
                                    Ok(arg) => arg,
                                    Err(err) => {
                                        __tauri_resolver__.invoke_error(err);
                                        return true;
                                    }
                                },
                                match ::tauri::ipc::CommandArg::from_command(::tauri::ipc::CommandItem {
                                    plugin: ::core::option::Option::None,
                                    name: "bump",
                                    key: "app",
                                    message: &__tauri_message__,
                                    acl: &__tauri_acl__,
                                }) {
                                    Ok(arg) => arg,
                                    Err(err) => {
                                        __tauri_resolver__.invoke_error(err);
                                        return true;
                                    }
                                },
                            );
                            let kind = (&result).blocking_kind();
                            kind.block(result, __tauri_resolver__);
                            return true;
                        }
                    })()
                }

                "word_count" => {
                    ({
                        move || {
                            #[allow(unused_imports)]
                            use ::tauri::ipc::private::*;
                            #[allow(unused_variables)]
                            let ::tauri::ipc::Invoke {
                                message: __tauri_message__,
                                resolver: __tauri_resolver__,
                                acl: __tauri_acl__,
                            } = __tauri_invoke__;
                            __tauri_resolver__
                                .respond_async_serialized(async move {
                                    let result = word_count(
                                        ::tauri::ipc::CommandArg::from_command(::tauri::ipc::CommandItem {
                                            plugin: ::core::option::Option::None,
                                            name: "word_count",
                                            key: "text",
                                            message: &__tauri_message__,
                                            acl: &__tauri_acl__,
                                        })?,
                                    );
                                    let kind = (&result).async_kind();
                                    kind.future(result).await
                                });
                            return true;
                        }
                    })()
                }

        if let Some(span) = ref_argument_span {
          if let syn::ReturnType::Type(_, return_type) = &function.sig.output {
            // To check if the return type is `Result` we require it to check a trait that is
            // only implemented by `Result`. That way we don't exclude renamed result types
            // which we wouldn't otherwise be able to detect purely from the token stream.
            // The "error message" displayed to the user is simply the trait name.
            let diagnostic = quote!(#[diagnostic::on_unimplemented(message = "async commands that contain references as inputs must return a `Result`")]);

            async_command_check = quote_spanned! {return_type.span() =>
              #[allow(unreachable_code, clippy::diverging_sub_expression, clippy::used_underscore_binding)]
              const _: () = if false {
                #diagnostic
                trait AsyncCommandMustReturnResult {}
                impl<A, B> AsyncCommandMustReturnResult for ::std::result::Result<A, B> {}
                let _check: #return_type = unreachable!();
                let _: &dyn AsyncCommandMustReturnResult = &_check;
              };
            };
          } else {
            return quote_spanned! {
              span => compile_error!("async commands that contain references as inputs must return a `Result`");
            }.into();
          }
        }

#[tauri::command]
async fn bad(name: &str) -> String {
  name.to_string()
}

fn main() {
  let _ = tauri::Builder::default().invoke_handler(tauri::generate_handler![bad]);
}

error[E0277]: async commands that contain references as inputs must return a `Result`
 --> src/bin/e1.rs:2:29
  |
2 | async fn bad(name: &str) -> String {
  |                             ^^^^^^ the trait `AsyncCommandMustReturnResult` is not implemented for `std::string::String`
  |
help: the trait `AsyncCommandMustReturnResult` is implemented for `Result<A, B>`
 --> src/bin/e1.rs:2:29
  |
2 | async fn bad(name: &str) -> String {
  |                             ^^^^^^
  = note: required for the cast from `&std::string::String` to `&dyn AsyncCommandMustReturnResult`

error[E0597]: `__tauri_message__` does not live long enough
   --> src/bin/e1.rs:1:1
    |
  1 | #[tauri::command]
    | ^^^^^^^^^^^^^^^^-
    | |               |
    | |               `__tauri_message__` dropped here while still borrowed
    | borrowed value does not live long enough
    | argument requires that `__tauri_message__` is borrowed for `'static`
...
  7 |   let _ = tauri::Builder::default().invoke_handler(tauri::generate_handler![bad]);
    |                                                    ----------------------------- in this macro invocation
    |
note: requirement that the value outlives `'static` introduced here
   --> ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tauri-2.12.5/src/ipc/command.rs:298:38
    |
298 |       F: Future<Output = T> + Send + 'static,
    |                                      ^^^^^^^
    = note: this error originates in the macro `__cmd__bad` which comes from the expansion of the macro `tauri::generate_handler` (in Nightly builds, run with -Z macro-backtrace for more info)

===== e2
error: async commands that contain references as inputs must return a `Result`
 --> src/bin/e2.rs:2:14
  |
2 | async fn bad(name: &str) {
  |              ^^^^

error: cannot find macro `__tauri_command_name_bad` in this scope
 --> src/bin/e2.rs:7:52
...
error: cannot find macro `__cmd__bad` in this scope
 --> src/bin/e2.rs:7:77
...
===== e3
error[E0277]: async commands that contain references as inputs must return a `Result`
 --> src/bin/e3.rs:2:43
  |
2 | async fn bad(n: tauri::State<'_, u32>) -> u32 {
  |                                           ^^^ the trait `AsyncCommandMustReturnResult` is not implemented for `u32`
...
error[E0597]: `__tauri_message__` does not live long enough
...
===== e4
error[E0726]: implicit elided lifetime not allowed here
 --> src/bin/e4.rs:2:20
  |
2 | async fn bad(name: std::borrow::Cow<str>) -> String {
  |                    ^^^^^^^^^^^^^^^^^^^^^ expected lifetime parameter

                "greetUser" => {
                    ({
                        move || {
                            // ...
                            let result = greet_user(
                                match ::tauri::ipc::CommandArg::from_command(::tauri::ipc::CommandItem {
                                    plugin: ::core::option::Option::None,
                                    name: "\"greetUser\"",
                                    key: "userName",
                                    message: &__tauri_message__,
                                    acl: &__tauri_acl__,
                                }) {

greet {"name":"rie"} => Ok(String("hello, rie"))
word_count {"text":"a b c"} => Ok(Number(3))
bump {} => Ok(Number(1))
snake {"user_name":"s"} => Ok(String("s"))
snake {"userName":"s"} => Err(String("invalid args `user_name` for command `snake`: command snake missing required key user_name"))
greetUser {"userName":"u"} => Ok(String("u"))
greet_user {"userName":"u"} => Err(String("Command greet_user not found"))
borrow_ok {"name":"rie"} => Ok(String("RIE"))
greet {"name":42} => Err(String("invalid args `name` for command `greet`: invalid type: integer `42`, expected a borrowed string"))
peek {} => Ok(Number(1))

    quote::quote!(move |#invoke| {
      let #cmd = #invoke.message.command();
      match #cmd {
        #(#(#attrs)* #command_name_macros => #wrappers!(#paths, #invoke),)*
        _ => {
          return false;
        },
      }
    })

        .invoke_handler(move |__tauri_invoke__| {
            let __tauri_cmd__ = __tauri_invoke__.message.command();
            match __tauri_cmd__ {
                "greet" => {
                    ({
                        move || {
                            // ...
                        }
                    })()
                }
                // "word_count"、"bump"、"snake"、"greetUser"、"borrow_ok"、"peek"
                _ => {
                    return false;
                }
            }
        })

greetUser {"user_name":"u"} => Err(String("invalid args `userName` for command `\"greetUser\"`: command \"greetUser\" missing required key userName"))