use proc_macro::TokenStream;

use quote::quote;

use syn::Lit;

use syn::{Data, DeriveInput, Fields, ItemFn, Path, parse_macro_input};

#[proc_macro_attribute]

        #[sqlx::test(migrator = "server::db::MIGRATOR")]

        async fn #fn_name(pool: PgPool) -> Result<(), anyhow::Error> {

            setup().await;

            DB_POOL.set(Some(pool.clone()));

            #block

        Ok(())

        }

    };

/// Runs an async test body on ONE runtime shared by the whole test binary,

/// obtained from `crate::common::runtime()` (as [`local_db_sqlx_test`] expects

/// `setup()`).

///

/// `#[tokio::test]` builds a runtime per test and drops it when the test ends.

/// `server::db`'s production pool is a process-wide `OnceCell`, so connections

/// opened inside the first test's runtime are still pooled after that runtime is

/// gone, and a later acquire fails with "A Tokio 1.x context was found, but it

/// is being shutdown" — inside whatever test happened to run next, which is why

/// it reads as a bug in unrelated code.

#[proc_macro_attribute]

    // The return type is preserved and the value returned: erasing it would let

    // a test that returns `Err` pass with only an unused-`Result` warning.

        #[test]

        #(#attrs)*

        fn #fn_name() #output {

            crate::common::runtime().block_on(async #block)

        }

    })

#[proc_macro_derive(Builder, attributes(builder))]

    // Parse the input tokens into a syntax tree

    // Check for custom error_kind attribute

    // Parse attributes

    }

    // Set a default error kind if none is provided

    );

    // Define a custom error type based on the struct name, e.g., CommodityError for Commodity

        } else {

        }

    } else {

    };

    // Generate builder struct fields with the same generics (including lifetimes)

            #field_name: #builder_field_type

        }

    // Generate initialization in new()

            #field_name: None

        }

    // Generate setter methods

                // For Option<String>, accept &str

                    pub fn #field_name(&mut self, value: &str) -> &mut Self {

                        self.#field_name = Some(Some(value.to_string()));

                        self

                    }

                }

            } else {

                // For Option<T>, accept T directly

                    pub fn #field_name(&mut self, value: #inner_type) -> &mut Self {

                        self.#field_name = Some(Some(value));

                        self

                    }

                }

            }

            // For String, accept &str

                pub fn #field_name(&mut self, value: &str) -> &mut Self {

                    self.#field_name = Some(value.to_string());

                    self

                }

            }

        } else {

            // For non-Option<T> and non-String fields, accept T directly

                pub fn #field_name(&mut self, value: #field_type) -> &mut Self {

                    self.#field_name = Some(value);

                    self

                }

            }

        }

    // Generate code to check for missing required fields

                if self.#field_name.is_none() {

                    missing_fields.push(#field_name_str);

                }

            }

    // Generate build_fields

                #field_name: self.#field_name.clone().unwrap_or(None)

            }

        } else {

                #field_name: self.#field_name.clone().unwrap()

            }

        }

    // Extract the lifetime parameters from generics for use in the builder struct

        pub struct #builder_name #impl_generics #where_clause {

            #(#builder_fields),*

        }

        impl #impl_generics #builder_name #ty_generics #where_clause {

            pub fn new() -> Self {

                Self {

                    #(#builder_fields_init),*

                }

            }

            #(#setters)*

            pub fn build(&self) -> Result<#name #ty_generics, #error_kind> {

                let mut missing_fields = Vec::new();

                #(#check_required_fields)*

                if !missing_fields.is_empty() {

                    return Err(#error_kind::from(#custom_error_name::Build(format!(

                        "{} fields are missing: {}",

                        stringify!(#name),

                        missing_fields.join(", ")

                    ))));

                }

                Ok(#name {

                    #(#build_fields),*

                })

            }

        }

        impl #impl_generics #name #ty_generics #where_clause {

            pub fn builder() -> #builder_name #ty_generics {

                #builder_name::new()

            }

        }

    };

/// Helper function to determine if a type is an `Option<T>`

/// Helper function to get the inner type of an `Option<T>`

    {

/// Helper function to check if the type is String

    {

/// A procedural macro for generating typed Command implementations with compile-time validation.

///

/// This macro provides pure value-based argument passing with compile-time type safety by generating:

/// - Typed Args structs with proper field types passed by value only

/// - Commands that accept Args structs directly (no `HashMap` usage)

/// - Individual typed variables available directly in command scope

/// - Compile-time validation of argument types and required/optional fields

/// - Zero runtime argument parsing or validation overhead

///

/// # Syntax

///

/// ```ignore

/// command! {

///     CommandName {

///         #[required]

///         arg_name: Type,

///         #[optional]

///         opt_name: Type,

///     } => {

///         // Command implementation body

///         // Individual typed variables are available in scope

///     }

/// }

/// ```

///

/// # Generated Code

///

/// The macro generates:

/// - A `CommandNameArgs` struct with typed fields (required fields as `Type`, optional as `Option<Type>`)

/// - A `CommandName` struct implementing `Command` trait with typed `run(args: CommandNameArgs)` method

/// - Individual typed variables extracted from the Args struct and available in the command body

/// - Pure compile-time type validation with no runtime overhead

///

/// # Examples

///

/// ## Simple command with no arguments

///

/// ```rust

/// # use supp_macro::command;

/// # use async_trait::async_trait;

/// #

/// # #[derive(Debug)]

/// # pub enum CmdError {

/// #     Args(String),

/// # }

/// #

/// # impl std::fmt::Display for CmdError {

/// #     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

/// #         match self {

/// #             CmdError::Args(msg) => write!(f, "Argument error: {}", msg),

/// #         }

/// #     }

/// # }

/// #

/// # impl std::error::Error for CmdError {}

/// #

/// # #[derive(Debug)]

/// # pub enum CmdResult {

/// #     String(String),

/// # }

/// #

/// # #[derive(Debug, Default)]

/// # pub struct CommandArgs {}

/// # impl CommandArgs { pub fn new() -> Self { Self::default() } }

/// #

/// # #[async_trait]

/// # pub trait Command: std::fmt::Debug {

/// #     type Args;

/// #     async fn run(&self, args: Self::Args) -> Result<Option<CmdResult>, CmdError>;

/// # }

///

/// command! {

///     GetVersion {

///     } => {

///         Ok(Some(CmdResult::String("1.0.0".to_string())))

///     }

/// }

///

/// # #[tokio::main]

/// # async fn main() {

/// let result = GetVersion::new().run().await.unwrap();

/// # }

/// ```

///

/// ## Command with required arguments (server-compatible types)

///

/// ```rust

/// # use supp_macro::command;

/// # use async_trait::async_trait;

/// # use uuid::Uuid;

/// # use num_rational::Rational64;

/// #

/// # #[derive(Debug, Clone)]

/// # pub enum Argument {

/// #     String(String),

/// #     Uuid(Uuid),

/// #     Rational(Rational64),

/// # }

/// #

/// # #[derive(Debug)]

/// # pub enum CmdError {

/// #     Args(String),

/// # }

/// #

/// # impl std::fmt::Display for CmdError {

/// #     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

/// #         match self {

/// #             CmdError::Args(msg) => write!(f, "Argument error: {}", msg),

/// #         }

/// #     }

/// # }

/// #

/// # impl std::error::Error for CmdError {}

/// #

/// # #[derive(Debug)]

/// # pub enum CmdResult {

/// #     String(String),

/// # }

/// #

/// # #[derive(Debug, Default)]

/// # pub struct CommandArgs {

/// #     pub symbol: Option<String>,

/// #     pub name: Option<String>,

/// #     pub user_id: Option<uuid::Uuid>,

/// # }

/// # impl CommandArgs {

/// #     pub fn new() -> Self { Self::default() }

/// #     pub fn symbol(mut self, v: String) -> Self { self.symbol = Some(v); self }

/// #     pub fn name(mut self, v: String) -> Self { self.name = Some(v); self }

/// #     pub fn user_id(mut self, v: uuid::Uuid) -> Self { self.user_id = Some(v); self }

/// # }

/// #

/// # #[async_trait]

/// # pub trait Command: std::fmt::Debug {

/// #     type Args;

/// #     async fn run(&self, args: Self::Args) -> Result<Option<CmdResult>, CmdError>;

/// # }

///

/// // This creates a commodity in the financial system

/// command! {

///     CreateCommodity {

///         #[required]

///         symbol: String,

///         #[required]

///         name: String,

///         #[required]

///         user_id: Uuid,

///     } => {

///         // Individual typed variables are automatically available

///         Ok(Some(CmdResult::String(format!(

///             "Created commodity {} ({}) for user {}",

///             name, symbol, user_id

///         ))))

///     }

/// }

///

/// # #[tokio::main]

/// # async fn main() {

/// let result = CreateCommodity::new()

///     .symbol("USD".to_string())

///     .name("US Dollar".to_string())

///     .user_id(uuid::Uuid::new_v4())

///     .run()

///     .await

///     .unwrap();

/// # }

/// ```

///

/// ## Command with optional arguments

///

/// ```rust

/// # use supp_macro::command;

/// # use async_trait::async_trait;

/// # use uuid::Uuid;

/// #

/// # #[derive(Debug, Clone)]

/// # pub enum Argument {

/// #     String(String),

/// #     Uuid(Uuid),

/// # }

/// #

/// # #[derive(Debug)]

/// # pub enum CmdError {

/// #     Args(String),

/// # }

/// #

/// # impl std::fmt::Display for CmdError {

/// #     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

/// #         match self {

/// #             CmdError::Args(msg) => write!(f, "Argument error: {}", msg),

/// #         }

/// #     }

/// # }

/// #

/// # impl std::error::Error for CmdError {}

/// #

/// # #[derive(Debug)]

/// # pub enum CmdResult {

/// #     String(String),

/// # }

/// #

/// # #[derive(Debug, Default)]

/// # pub struct CommandArgs {

/// #     pub user_id: Option<uuid::Uuid>,

/// #     pub account: Option<String>,

/// # }

/// # impl CommandArgs {

/// #     pub fn new() -> Self { Self::default() }

/// #     pub fn user_id(mut self, v: uuid::Uuid) -> Self { self.user_id = Some(v); self }

/// #     pub fn account(mut self, v: String) -> Self { self.account = Some(v); self }

/// # }

/// #

/// # #[async_trait]

/// # pub trait Command: std::fmt::Debug {

/// #     type Args;

/// #     async fn run(&self, args: Self::Args) -> Result<Option<CmdResult>, CmdError>;

/// # }

///

/// command! {

///     ListTransactions {

///         #[required]

///         user_id: Uuid,

///         #[optional]

///         account: String,

///     } => {

///         let filter = if let Some(account) = account {

///             format!(" for account {}", account)

///         } else {

///             String::new()

///         };

///         Ok(Some(CmdResult::String(format!("Listing transactions for user {}{}", user_id, filter))))

///     }

/// }

/// ```

///

/// ## Command with mixed required and optional arguments

///

/// ```rust

/// # use supp_macro::command;

/// # use async_trait::async_trait;

/// #

/// # #[derive(Debug, Clone)]

/// # pub enum Argument {

/// #     String(String),

/// #     Integer(i64),

/// #     Boolean(bool),

/// # }

/// #

/// # #[derive(Debug)]

/// # pub enum CmdError {

/// #     Args(String),

/// # }

/// #

/// # impl std::fmt::Display for CmdError {

/// #     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

/// #         match self {

/// #             CmdError::Args(msg) => write!(f, "Argument error: {}", msg),

/// #         }

/// #     }

/// # }

/// #

/// # impl std::error::Error for CmdError {}

/// #

/// # #[derive(Debug)]

/// # pub enum CmdResult {

/// #     Success(String),

/// # }

/// #

/// # impl TryFrom<Argument> for String {

/// #     type Error = CmdError;

/// #     fn try_from(arg: Argument) -> Result<Self, Self::Error> {

/// #         match arg {

/// #             Argument::String(s) => Ok(s),

/// #             _ => Err(CmdError::Args(format!("Cannot convert {:?} to String", arg))),

/// #         }

/// #     }

/// # }

/// #

/// # impl TryFrom<Argument> for i64 {

/// #     type Error = CmdError;

/// #     fn try_from(arg: Argument) -> Result<Self, Self::Error> {

/// #         match arg {

/// #             Argument::Integer(i) => Ok(i),

/// #             _ => Err(CmdError::Args(format!("Cannot convert {:?} to i64", arg))),

/// #         }

/// #     }

/// # }

/// #

/// # impl TryFrom<Argument> for bool {

/// #     type Error = CmdError;

/// #     fn try_from(arg: Argument) -> Result<Self, Self::Error> {

/// #         match arg {

/// #             Argument::Boolean(b) => Ok(b),

/// #             _ => Err(CmdError::Args(format!("Cannot convert {:?} to bool", arg))),

/// #         }

/// #     }

/// # }

/// #

/// # #[async_trait]

/// # pub trait TypedCommand {

/// #     type Args;

/// #     async fn run_typed(&self, args: Self::Args) -> Result<Option<CmdResult>, CmdError>;

/// # }

/// #

/// # #[derive(Debug, Default)]

/// # pub struct CommandArgs {

/// #     pub user_id: Option<i64>,

/// #     pub username: Option<String>,

/// #     pub email: Option<String>,

/// #     pub is_admin: Option<bool>,

/// # }

/// # impl CommandArgs {

/// #     pub fn new() -> Self { Self::default() }

/// #     pub fn user_id(mut self, v: i64) -> Self { self.user_id = Some(v); self }

/// #     pub fn username(mut self, v: String) -> Self { self.username = Some(v); self }

/// #     pub fn email(mut self, v: String) -> Self { self.email = Some(v); self }

/// #     pub fn is_admin(mut self, v: bool) -> Self { self.is_admin = Some(v); self }

/// # }

/// #

/// # #[async_trait]

/// # pub trait Command {

/// #     type Args;

/// #     async fn run(&self, args: Self::Args) -> Result<Option<CmdResult>, CmdError>;

/// # }

///

/// command! {

///     CreateUserCommand {

///         #[required]

///         user_id: i64,

///         #[required]

///         username: String,

///         #[optional]

///         email: String,

///         #[optional]

///         is_admin: bool,

///     } => {

///         let email_str = email.map_or_else(|| format!("{}@example.com", username), |s| s.to_string());

///         let admin_status = is_admin.unwrap_or(false);

///

///         let message = format!(

///             "Created user {} (ID: {}, Email: {}, Admin: {})",

///             username, user_id, email_str, admin_status

///         );

///         Ok(Some(CmdResult::Success(message)))

///     }

/// }

///

/// # #[tokio::main]

/// # async fn main() {

/// let result = CreateUserCommand::new()

///     .user_id(123)

///     .username("alice".to_string())

///     .is_admin(true)

///     .run()

///     .await

///     .unwrap();

/// # }

/// ```

///

/// ## Server-compatible Command implementation

///

/// ```rust

/// # use supp_macro::command;

/// # use async_trait::async_trait;

/// #

/// # #[derive(Debug, Clone)]

/// # pub enum Argument {

/// #     String(String),

/// #     Integer(i64),

/// #     Boolean(bool),

/// # }

/// #

/// # #[derive(Debug)]

/// # pub enum CmdError {

/// #     Args(String),

/// # }

/// #

/// # impl std::fmt::Display for CmdError {

/// #     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

/// #         match self {

/// #             CmdError::Args(msg) => write!(f, "Argument error: {}", msg),

/// #         }

/// #     }

/// # }

/// #

/// # impl std::error::Error for CmdError {}

/// #

/// # #[derive(Debug)]

/// # pub enum CmdResult {

/// #     Success(String),

/// # }

/// #

/// # #[derive(Debug, Default)]

/// # pub struct CommandArgs {

/// #     pub a: Option<i64>,

/// #     pub b: Option<i64>,

/// # }

/// # impl CommandArgs {

/// #     pub fn new() -> Self { Self::default() }

/// #     pub fn a(mut self, v: i64) -> Self { self.a = Some(v); self }

/// #     pub fn b(mut self, v: i64) -> Self { self.b = Some(v); self }

/// # }

/// #

/// # #[async_trait]

/// # pub trait Command {

/// #     type Args;

/// #     async fn run(&self, args: Self::Args) -> Result<Option<CmdResult>, CmdError>;

/// # }

///

/// command! {

///     CalculateCommand {

///         #[required]

///         a: i64,

///         #[required]

///         b: i64,

///     } => {

///         let result = a + b;

///         Ok(Some(CmdResult::Success(format!("{} + {} = {}", a, b, result))))

///     }

/// }

///

/// # #[tokio::main]

/// # async fn main() {

/// let result = CalculateCommand::new()

///     .a(10)

///     .b(20)

///     .run()

///     .await

///     .unwrap();

/// # }

/// ```

///

/// ## Migration from Manual Commands

///

/// The macro makes it easy to migrate from manual Command implementations:

///

/// ```rust,ignore

/// // BEFORE: Manual implementation

/// #[derive(Debug)]

/// pub struct GetConfig;

///

/// #[async_trait]

/// impl Command for GetConfig {

///     async fn run<'a>(&self, args: &'a HashMap<&'a str, &'a Argument>) -> Result<Option<CmdResult>, CmdError> {

///         if let Some(Argument::String(name)) = args.get("name") {

///             Ok(config(name).await?.map(|v| CmdResult::String(v)))

///         } else {

///             Err(CmdError::Args("No field name provided".to_string()))

///         }

///     }

/// }

///

/// // AFTER: Using the macro

/// command! {

///     GetConfig {

///         #[required]

///         name: String,

///     } => {

///         Ok(config(name).await?.map(|v| CmdResult::String(v)))

///     }

/// }

/// ```

///

/// # Error Handling

///

/// The new pure typed system provides compile-time error prevention:

///

/// - Missing required arguments are compile-time errors (cannot compile without them)

/// - Invalid argument types are compile-time errors (type checking at build time)

/// - Runtime errors only occur in the command body logic itself

/// - No argument validation overhead at runtime

///

/// # Supported Argument Types

///

/// The macro supports any Rust type for arguments:

/// - `String` - Text arguments

/// - `i64`, `u64`, etc. - Integer arguments

/// - `bool` - Boolean arguments

/// - `Rational64` - Rational number arguments (for financial precision)

/// - `Uuid` - UUID arguments

/// - `Vec<u8>` - Binary data arguments

/// - `DateTime<Utc>` - `DateTime` arguments

/// - Custom types - Any type can be used as an argument

/// - `Option<T>` - Automatically applied for optional arguments

#[proc_macro]

    // Generate progressive runner types for all combinations of required fields

    // Generate the main command struct

        #[derive(Debug)]

        pub struct #name;

    };

    // Generate the new() method that starts the builder chain

        #command_struct

        #runner_types

        #new_method

    };

/// Generate all possible runner type combinations for required fields

    // Generate a runner type for each possible combination of set required fields

        #(#runner_types)*

    }

/// Generate a single runner type for a specific combination of set fields

    // Create binary representation for the runner type name

    );

    // Determine which required fields are set in this combination

    }

    // Always include optional fields in all runner types

    // Generate the struct definition

            #[derive(Debug)]

            pub struct #runner_name;

        }

    } else {

            #[derive(Debug)]

            pub struct #runner_name {

                #(#struct_fields),*

            }

        }

    };

    // Generate transition methods for this runner type

    );

    // Generate run method if this is the complete state (all required fields set)

    } else {

    };

        #struct_def

        impl #runner_name {

            #transition_methods

            #run_method

        }

    }

/// Generate transition methods for a runner type (field setters)

    // Generate setter methods for required fields not yet set

    }

    // Generate setter methods for optional fields (available on all runner types)

        #(#methods)*

    }

/// Generate a setter method for a required field

    // Generate field assignments for the new state

    // Handle required fields

        // Fields not set in either state are omitted

    }

    // Handle optional fields (always present, move from self)

    // Generate the constructor call

    } else {

            #target_runner {

                #(#field_assignments),*

            }

        }

    };

        pub fn #field_name(self, value: #field_type) -> #target_runner {

            #constructor

        }

    }

/// Generate a setter method for an optional field

    // Generate field assignments (same state, but update the optional field)

    // Handle required fields (move from self if set)

    }

    // Handle optional fields

    }

    } else {

            #current_runner {

                #(#field_assignments),*

            }

        }

    };

        pub fn #field_name(self, value: #field_type) -> #current_runner {

            #constructor

        }

    }

/// Generate the run method for the complete runner state

    // Extract field values directly (no unwrap needed!)

    // Required fields - direct field access

    // Optional fields - direct field access

        pub async fn run(self) -> Result<Option<CmdResult>, CmdError> {

            // Zero runtime checks - direct field access!

            #(#variable_assignments)*

            // Original command body

            #body

        }

    }

/// Generate the `new()` method for the command

    );

    // Initial state has no required fields set, but has optional fields as None

        // Unit struct (no fields at all in initial state)

    } else {

        // Struct with optional fields initialized to None

                #initial_runner {

                    #(#optional_field_inits),*

                }

            }

        } else {

        }

    };

        impl #command_name {

            pub fn new() -> #initial_runner {

                #constructor

            }

        }

    }

struct CommandInput {

    name: syn::Ident,

    required_args: Vec<(syn::Ident, syn::Type)>,

    optional_args: Vec<(syn::Ident, syn::Type)>,

    body: syn::Block,

}

impl syn::parse::Parse for CommandInput {

        let content;

            // Parse attributes

                let attr_content;

                }

            }

            // Parse the field

            // Determine if optional (default to required if no attribute specified)

            } else {

            };

        }

        // The '=>' is outside the braces

}