thru-core 0.2.20

//! CLI argument parsing and command definitions

use clap::{Parser, Subcommand, ValueEnum};
use std::path::PathBuf;

/// Parse and validate chunk size (1024-31000 bytes)
fn parse_chunk_size(s: &str) -> Result<usize, String> {
    let size: usize = s
        .parse()
        .map_err(|_| format!("'{}' is not a valid number", s))?;
    if size < 1024 {
        return Err(format!("chunk size {} is too small (minimum: 1024)", size));
    }
    if size > 31000 {
        return Err(format!("chunk size {} is too large (maximum: 31000)", size));
    }
    Ok(size)
}

/// Thru CLI - Command-line interface for the Thru blockchain
#[derive(Parser)]
#[command(name = "thru")]
#[command(about = "Command-line interface for the Thru blockchain")]
#[command(version = thru_base::get_version!())]
pub struct Cli {
    /// Output results in JSON format
    #[arg(long, global = true)]
    pub json: bool,

    /// Suppress non-essential output (disables version check notifications)
    #[arg(long, global = true)]
    pub quiet: bool,

    /// Override RPC URL for this invocation
    #[arg(long = "url", global = true)]
    pub url: Option<String>,

    /// Use a named network profile for this invocation
    #[arg(long = "network", global = true)]
    pub network: Option<String>,

    #[command(subcommand)]
    pub command: Commands,
}

/// Available CLI commands
#[derive(Subcommand)]
pub enum Commands {
    /// Get version information from the Thru node
    #[command(name = "getversion")]
    GetVersion,

    /// Get health status of the Thru node
    #[command(name = "gethealth")]
    GetHealth,

    /// Get the node's operational status (consensus, repair, heights)
    #[command(name = "getstatus")]
    GetStatus,

    /// Get cluster block heights
    #[command(name = "getheight")]
    GetHeight,

    /// Get account information for a specific account
    #[command(name = "getaccountinfo")]
    GetAccountInfo {
        /// Account identifier (key name from config or public key)
        /// If omitted, uses the 'default' key from config
        account: Option<String>,

        /// Starting offset in account data to display (in bytes)
        #[arg(long)]
        data_start: Option<usize>,

        /// Length of account data to display (in bytes)
        #[arg(long)]
        data_len: Option<usize>,
    },

    /// Get balance for a specific account
    #[command(name = "getbalance")]
    GetBalance {
        /// Account identifier (key name from config or public key)
        /// If omitted, uses the 'default' key from config
        account: Option<String>,
    },

    /// Get slot metrics (state counters, collected fees)
    #[command(name = "getslotmetrics")]
    GetSlotMetrics {
        /// Start slot number (required)
        slot: u64,

        /// End slot number (optional, if provided returns range of slots)
        end_slot: Option<u64>,
    },

    /// Transfer tokens between accounts
    #[command(name = "transfer")]
    Transfer {
        /// Source key name from configuration
        src: String,

        /// Destination (key name from config or public address in taXX format)
        dst: String,

        /// Amount to transfer
        value: u64,
    },

    /// Uploader account commands for arbitrary file payloads
    #[command(name = "uploader")]
    Uploader {
        #[command(subcommand)]
        subcommand: UploaderCommands,
    },

    /// ABI management commands
    #[command(name = "abi")]
    Abi {
        #[command(subcommand)]
        subcommand: AbiCommands,
    },

    /// Key management commands
    #[command(name = "keys")]
    Keys {
        #[command(subcommand)]
        subcommand: KeysCommands,
    },

    /// Account management commands
    #[command(name = "account")]
    Account {
        #[command(subcommand)]
        subcommand: AccountCommands,
    },

    /// Program management commands
    #[command(name = "program")]
    Program {
        #[command(subcommand)]
        subcommand: ProgramCommands,
    },

    /// Transaction signing and execution commands
    #[command(name = "txn")]
    Txn {
        #[command(subcommand)]
        subcommand: TxnCommands,
    },

    /// Utility commands for format conversion
    #[command(name = "util")]
    Util {
        #[command(subcommand)]
        subcommand: UtilCommands,
    },

    /// Token program commands
    #[command(name = "token")]
    Token {
        #[command(subcommand)]
        subcommand: TokenCommands,
    },

    /// Faucet program commands
    #[command(name = "faucet")]
    Faucet {
        #[command(subcommand)]
        subcommand: FaucetCommands,
    },

    /// Registrar program commands
    #[command(name = "registrar")]
    Registrar {
        #[command(subcommand)]
        subcommand: RegistrarCommands,
    },

    /// Name service program commands
    #[command(name = "nameservice")]
    NameService {
        #[command(subcommand)]
        subcommand: NameServiceCommands,
    },

    /// Wrapped Thru (WTHRU) program commands
    #[command(name = "wthru")]
    Wthru {
        #[command(subcommand)]
        subcommand: WthruCommands,
    },

    /// Validator program commands
    #[command(name = "validator")]
    Validator {
        #[command(subcommand)]
        subcommand: ValidatorCommands,
    },

    /// Developer tools for toolchain and project management
    #[command(name = "dev")]
    Dev {
        #[command(subcommand)]
        subcommand: DevCommands,
    },

    /// Network profile management commands
    #[command(name = "network")]
    Network {
        #[command(subcommand)]
        subcommand: Option<NetworkCommands>,
    },

    /// Debug commands for transaction analysis
    #[command(name = "debug")]
    Debug {
        #[command(subcommand)]
        subcommand: DebugCommands,
    },
}

/// Program-related subcommands
#[derive(Subcommand)]
pub enum ProgramCommands {
    /// Create a new program from a program binary
    Create {
        /// Manager program public key (optional)
        #[arg(long)]
        manager: Option<String>,

        /// Make the program ephemeral
        #[arg(long)]
        ephemeral: bool,

        /// Seed for meta account derivation
        seed: String,

        /// Authority account name from config (optional, defaults to 'default')
        #[arg(long)]
        authority: Option<String>,

        /// Program file to upload and create managed program from
        program_file: String,

        /// Chunk size for upload (1024-31000 bytes, default: 30720)
        #[arg(long, value_parser = parse_chunk_size, default_value = "30720")]
        chunk_size: usize,
    },

    /// Upgrade an existing managed program
    Upgrade {
        /// Manager program public key (optional)
        #[arg(long)]
        manager: Option<String>,

        /// Make the program ephemeral
        #[arg(long)]
        ephemeral: bool,

        /// Seed for meta and program account derivation
        seed: String,

        /// Program file to upload and upgrade managed program with
        program_file: String,

        /// Chunk size for upload (1024-31000 bytes, default: 30720)
        #[arg(long, value_parser = parse_chunk_size, default_value = "30720")]
        chunk_size: usize,
    },

    /// Pause or unpause a managed program
    SetPause {
        /// Manager program public key (optional)
        #[arg(long)]
        manager: Option<String>,

        /// Make the program ephemeral
        #[arg(long)]
        ephemeral: bool,

        /// Seed for meta and program account derivation
        seed: String,

        /// Set paused state (true to pause, false to unpause)
        paused: String,
    },

    /// Destroy a managed program and its meta account
    Destroy {
        /// Manager program public key (optional)
        #[arg(long)]
        manager: Option<String>,

        /// Make the program ephemeral
        #[arg(long)]
        ephemeral: bool,

        /// Seed for meta and program account derivation
        seed: String,

        /// Fee payer account name from config (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,
    },

    /// Finalize a managed program (make it immutable)
    Finalize {
        /// Manager program public key (optional)
        #[arg(long)]
        manager: Option<String>,

        /// Make the program ephemeral
        #[arg(long)]
        ephemeral: bool,

        /// Seed for meta and program account derivation
        seed: String,

        /// Fee payer account name from config (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,
    },

    /// Set authority candidate for a managed program
    SetAuthority {
        /// Manager program public key (optional)
        #[arg(long)]
        manager: Option<String>,

        /// Make the program ephemeral
        #[arg(long)]
        ephemeral: bool,

        /// Seed for meta and program account derivation
        seed: String,

        /// New authority candidate public key
        authority_candidate: String,
    },

    /// Claim authority for a managed program
    ClaimAuthority {
        /// Manager program public key (optional)
        #[arg(long)]
        manager: Option<String>,

        /// Make the program ephemeral
        #[arg(long)]
        ephemeral: bool,

        /// Seed for meta and program account derivation
        seed: String,

        /// Fee payer account (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,
    },

    /// Get the program derived address
    DeriveAddress {
        /// Program public key
        program_id: String,

        /// Seed (hex string or UTF-8 string)
        seed: String,

        /// Ephemeral flag
        #[arg(long)]
        ephemeral: bool,
    },

    /// Derive both meta and program account addresses from a seed
    DeriveManagerAccounts {
        /// Manager program public key (optional, uses config default if not specified)
        #[arg(long)]
        manager: Option<String>,

        /// Seed for account derivation (UTF-8 string, max 32 bytes)
        seed: String,

        /// Ephemeral flag
        #[arg(long)]
        ephemeral: bool,
    },

    /// Convert a UTF-8 seed string into zero-padded 32-byte hex
    SeedToHex {
        /// Seed string (UTF-8, maximum 32 bytes)
        seed: String,
    },

    /// Derive the managed program account address from a seed
    DeriveProgramAccount {
        /// Manager program public key (optional, uses config default if not specified)
        #[arg(long)]
        manager: Option<String>,

        /// Seed for account derivation (UTF-8 string, max 32 bytes)
        seed: String,

        /// Ephemeral flag
        #[arg(long)]
        ephemeral: bool,
    },

    /// Check status of program and related accounts
    Status {
        /// Manager program public key (optional, uses config default if not specified)
        #[arg(long)]
        manager: Option<String>,

        /// Seed for account derivation (UTF-8 string, max 32 bytes)
        seed: String,

        /// Ephemeral flag
        #[arg(long)]
        ephemeral: bool,
    },
}

/// ABI-related subcommands
#[derive(Subcommand)]
pub enum AbiCommands {
    /// On-chain ABI account management commands
    #[command(name = "account")]
    Account {
        #[command(subcommand)]
        subcommand: AbiAccountCommands,
    },

    /// Generate code from ABI type definitions
    Codegen {
        /// Input YAML files containing type definitions
        #[arg(short = 'f', long = "files", value_name = "FILE", required = true)]
        files: Vec<PathBuf>,

        /// Include directories for imported type files
        #[arg(short = 'i', long = "include-dir", value_name = "DIR")]
        include_dirs: Vec<PathBuf>,

        /// Target language for code generation
        #[arg(short = 'l', long = "language", value_enum)]
        language: AbiLanguage,

        /// Output directory for generated code
        #[arg(
            short = 'o',
            long = "output",
            value_name = "DIR",
            default_value = "generated"
        )]
        output_dir: PathBuf,

        /// Enable verbose output
        #[arg(short = 'v', long = "verbose")]
        verbose: bool,
    },

    /// Analyze ABI type definitions and show detailed type information
    Analyze {
        /// Input YAML files containing type definitions
        #[arg(short = 'f', long = "files", value_name = "FILE", required = true)]
        files: Vec<PathBuf>,

        /// Include directories for imported type files
        #[arg(short = 'i', long = "include-dir", value_name = "DIR")]
        include_dirs: Vec<PathBuf>,

        /// Print the shared layout IR after analysis
        #[arg(long = "print-ir")]
        print_ir: bool,

        /// Format to use when printing the shared layout IR
        #[arg(long = "ir-format", value_enum, default_value = "json")]
        ir_format: AbiIrFormat,

        /// Print the generated legacy + IR footprint helpers for a specific type
        #[arg(long = "print-footprint", value_name = "TYPE")]
        print_footprint: Option<String>,

        /// Print the generated legacy + IR validate helpers for a specific type
        #[arg(long = "print-validate", value_name = "TYPE")]
        print_validate: Option<String>,
    },

    /// Parse ABI binary data and print JSON reflection results
    Reflect {
        /// ABI file(s) to load
        #[arg(short = 'f', long = "abi-file", required = true)]
        abi_files: Vec<PathBuf>,

        /// Include directories for resolving imports
        #[arg(short = 'i', long = "include-dir")]
        include_dirs: Vec<PathBuf>,

        /// Type name to parse
        #[arg(short = 't', long = "type-name", required = true)]
        type_name: String,

        /// Binary data file to parse
        #[arg(short = 'd', long = "data-file", required = true)]
        data_file: PathBuf,

        /// Pretty print JSON output
        #[arg(short = 'p', long = "pretty")]
        pretty: bool,

        /// Show only values (no type information)
        #[arg(
            long = "values-only",
            conflicts_with_all = ["validate_only", "include_byte_offsets"]
        )]
        values_only: bool,

        /// Only validate buffer without decoding
        #[arg(
            long = "validate-only",
            conflicts_with_all = ["values_only", "include_byte_offsets"]
        )]
        validate_only: bool,

        /// Print dynamic parameters inferred from the buffer
        #[arg(long = "show-params")]
        show_params: bool,

        /// Include byte offset information in the output
        #[arg(
            long = "include-byte-offsets",
            conflicts_with_all = ["validate_only", "values_only"]
        )]
        include_byte_offsets: bool,
    },

    /// Flatten an ABI file by resolving all imports
    Flatten {
        /// Input ABI file
        #[arg(short = 'f', long = "file", required = true)]
        file: PathBuf,

        /// Include directories for resolving imports
        #[arg(short = 'i', long = "include-dir")]
        include_dirs: Vec<PathBuf>,

        /// Output file path
        #[arg(short = 'o', long = "output", required = true)]
        output: PathBuf,

        /// Verbose output
        #[arg(short = 'v', long = "verbose")]
        verbose: bool,
    },

    /// Prepare an ABI file for on-chain publishing
    #[command(name = "prep-for-publish")]
    PrepForPublish {
        /// Input ABI file
        #[arg(short = 'f', long = "file", required = true)]
        file: PathBuf,

        /// Include directories for resolving local imports
        #[arg(short = 'i', long = "include-dir")]
        include_dirs: Vec<PathBuf>,

        /// Target network for validation (e.g., "mainnet", "testnet")
        #[arg(short = 'n', long = "target-network", required = true)]
        target_network: String,

        /// Output file path
        #[arg(short = 'o', long = "output", required = true)]
        output: PathBuf,

        /// Verbose output
        #[arg(short = 'v', long = "verbose")]
        verbose: bool,
    },

    /// Create a dependency manifest for WASM consumption
    Bundle {
        /// Input ABI file
        #[arg(short = 'f', long = "file", required = true)]
        file: PathBuf,

        /// Include directories for resolving imports
        #[arg(short = 'i', long = "include-dir")]
        include_dirs: Vec<PathBuf>,

        /// Output manifest file path (JSON)
        #[arg(short = 'o', long = "output", required = true)]
        output: PathBuf,

        /// Verbose output
        #[arg(short = 'v', long = "verbose")]
        verbose: bool,
    },
}

#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum, Debug)]
pub enum AbiAccountType {
    /// ABI account for a managed program
    Program,
    /// ABI account for an unmanaged target program
    #[value(name = "third-party")]
    ThirdParty,
    /// ABI account not associated with a program
    Standalone,
}

/// On-chain ABI account subcommands
#[derive(Subcommand)]
pub enum AbiAccountCommands {
    /// Create an ABI account
    Create {
        /// Program type (ephemeral matches the ABI account target)
        #[arg(long)]
        ephemeral: bool,

        /// ABI account type
        #[arg(long = "account-type", value_enum, default_value = "program")]
        account_type: AbiAccountType,

        /// Target program account public key (required for `third-party`)
        #[arg(long = "target-program")]
        target_program: Option<String>,

        /// Fee payer account (optional, defaults to config default)
        #[arg(long = "fee-payer")]
        fee_payer: Option<String>,

        /// Authority account name from config (`program` only, accepted as alias for `publisher`)
        #[arg(long, conflicts_with = "publisher")]
        authority: Option<String>,

        /// Publisher account name from config (`third-party` and `standalone` only)
        #[arg(long, conflicts_with = "authority")]
        publisher: Option<String>,

        /// Managed program seed, third-party 32-byte hex seed, or standalone seed string
        seed: String,

        /// ABI definition file to upload
        abi_file: String,
    },

    /// Upgrade an existing ABI account
    Upgrade {
        #[arg(long)]
        ephemeral: bool,

        #[arg(long = "account-type", value_enum, default_value = "program")]
        account_type: AbiAccountType,

        #[arg(long = "target-program")]
        target_program: Option<String>,

        #[arg(long = "fee-payer")]
        fee_payer: Option<String>,

        #[arg(long, conflicts_with = "publisher")]
        authority: Option<String>,

        #[arg(long, conflicts_with = "authority")]
        publisher: Option<String>,

        seed: String,
        abi_file: String,
    },

    /// Finalize an ABI account so it becomes immutable
    Finalize {
        #[arg(long)]
        ephemeral: bool,

        #[arg(long = "account-type", value_enum, default_value = "program")]
        account_type: AbiAccountType,

        #[arg(long = "target-program")]
        target_program: Option<String>,

        #[arg(long = "fee-payer")]
        fee_payer: Option<String>,

        #[arg(long, conflicts_with = "publisher")]
        authority: Option<String>,

        #[arg(long, conflicts_with = "authority")]
        publisher: Option<String>,

        seed: String,
    },

    /// Close an ABI account and reclaim its balance
    Close {
        #[arg(long)]
        ephemeral: bool,

        #[arg(long = "account-type", value_enum, default_value = "program")]
        account_type: AbiAccountType,

        #[arg(long = "target-program")]
        target_program: Option<String>,

        #[arg(long = "fee-payer")]
        fee_payer: Option<String>,

        #[arg(long, conflicts_with = "publisher")]
        authority: Option<String>,

        #[arg(long, conflicts_with = "authority")]
        publisher: Option<String>,

        seed: String,
    },

    /// Inspect an ABI account's metadata and optionally dump its YAML contents
    Get {
        /// ABI account public key (Thru address)
        abi_account: String,

        /// Include ABI YAML contents in the CLI output
        #[arg(long = "include-data", alias = "data")]
        include_data: bool,

        /// Optional file path to write the ABI YAML contents
        #[arg(long = "out")]
        out: Option<String>,
    },
}

#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum, Debug)]
pub enum AbiLanguage {
    C,
    Rust,
    #[value(name = "typescript")]
    TypeScript,
}

#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum, Debug)]
pub enum AbiIrFormat {
    Json,
    Protobuf,
}

/// Uploader-related subcommands
#[derive(Subcommand)]
pub enum UploaderCommands {
    /// Upload a file payload through uploader accounts
    Upload {
        /// Custom uploader program public key (optional)
        #[arg(long)]
        uploader: Option<String>,

        /// Chunk size for upload transactions (1024-31000 bytes)
        #[arg(long, value_parser = parse_chunk_size, default_value = "30720")]
        chunk_size: usize,

        /// Seed for account derivation
        seed: String,

        /// Path to the file payload to upload
        #[arg(value_name = "FILE")]
        program_file: String,
    },

    /// Clean up uploader accounts
    Cleanup {
        /// Custom uploader program public key (optional)
        #[arg(long)]
        uploader: Option<String>,

        /// Seed for account derivation
        seed: String,
    },

    /// Check status of uploader accounts
    Status {
        /// Custom uploader program public key (optional)
        #[arg(long)]
        uploader: Option<String>,

        /// Seed for account derivation
        seed: String,
    },
}

/// Key management subcommands
#[derive(Subcommand)]
pub enum KeysCommands {
    /// List all key names
    List,

    /// Add a new key
    Add {
        /// Overwrite existing key
        #[arg(long)]
        overwrite: bool,

        /// Key name (case-insensitive)
        name: String,

        /// Private key (64 hex characters)
        key: String,
    },

    /// Get a key value
    Get {
        /// Key name to retrieve
        name: String,
    },

    /// Generate a new random key
    Generate {
        /// Overwrite existing key
        #[arg(long)]
        overwrite: bool,

        /// Key name for the new key
        name: String,
    },

    /// Remove a key
    #[command(name = "rm")]
    Remove {
        /// Allow removing the default key
        #[arg(long)]
        force: bool,

        /// Key name to remove
        name: String,
    },
}

/// Network profile management subcommands
#[derive(Subcommand)]
pub enum NetworkCommands {
    /// Add a new named network profile
    Add {
        /// Network profile name (case-insensitive)
        name: String,

        /// RPC endpoint URL
        #[arg(long)]
        url: String,

        /// Optional authorization token
        #[arg(long = "auth-token")]
        auth_token: Option<String>,
    },

    /// Use a named network profile
    #[command(name = "use")]
    Use {
        /// Network profile name to make active
        name: String,
    },

    /// Update fields on an existing network profile
    Set {
        /// Network profile name to update
        name: String,

        /// New RPC endpoint URL
        #[arg(long)]
        url: Option<String>,

        /// New authorization token (use empty string to clear)
        #[arg(long = "auth-token")]
        auth_token: Option<String>,
    },

    /// Remove a network profile
    #[command(name = "rm")]
    Remove {
        /// Network profile name to remove
        name: String,
    },
}

/// Transaction management subcommands
#[derive(Subcommand)]
pub enum TxnCommands {
    /// Create and sign a transaction, output as base64 string
    Sign {
        /// Program public key (ta... format or key name from config)
        program: String,

        /// Instruction data as hex string
        instruction_data: String,

        /// Fee payer account (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Transaction fee (optional, defaults to 1)
        #[arg(long, default_value = "1")]
        fee: u64,

        /// Compute units (optional, defaults to 1000000000)
        #[arg(long, default_value = "1000000000")]
        compute_units: u32,

        /// State units (optional, defaults to 10000)
        #[arg(long, default_value = "10000")]
        state_units: u16,

        /// Memory units (optional, defaults to 10000)
        #[arg(long, default_value = "10000")]
        memory_units: u16,

        /// Expiry after (optional, defaults to 100)
        #[arg(long, default_value = "100")]
        expiry_after: u32,

        /// Read-write account addresses in ascending order (optional)
        #[arg(long)]
        readwrite_accounts: Vec<String>,

        /// Read-only account addresses in ascending order (optional)
        #[arg(long)]
        readonly_accounts: Vec<String>,
    },

    /// Create, sign and execute a transaction, print response
    Execute {
        /// Program public key (ta... format or key name from config)
        program: String,

        /// Instruction data as hex string
        instruction_data: String,

        /// Fee payer account (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Transaction fee (optional, defaults to 1)
        #[arg(long, default_value = "1")]
        fee: u64,

        /// Compute units (optional, defaults to 1000000000)
        #[arg(long, default_value = "300000000")]
        compute_units: u32,

        /// State units (optional, defaults to 10000)
        #[arg(long, default_value = "10000")]
        state_units: u16,

        /// Memory units (optional, defaults to 10000)
        #[arg(long, default_value = "10000")]
        memory_units: u16,

        /// Expiry after (optional, defaults to 100)
        #[arg(long, default_value = "100")]
        expiry_after: u32,

        /// Transaction timeout in seconds (optional, defaults to 30)
        #[arg(long, default_value = "30")]
        timeout: u64,

        /// Read-write account addresses in ascending order (optional)
        #[arg(long)]
        readwrite_accounts: Vec<String>,

        /// Read-only account addresses in ascending order (optional)
        #[arg(long)]
        readonly_accounts: Vec<String>,
    },

    /// Create a cryptographic state proof for a given account
    #[command(name = "make-state-proof")]
    MakeStateProof {
        /// Type of proof to create (creating, updating, existing)
        proof_type: String,

        /// Account public key for which to create the state proof
        account: String,

        /// Slot to create the proof for (optional)
        #[arg(long)]
        slot: Option<u64>,
    },

    /// Get transaction details by signature
    Get {
        /// Transaction signature (ts... format or 128 hex characters)
        signature: String,

        /// Number of retry attempts (1-60, default: 1)
        #[arg(long = "retry-count", value_name = "COUNT", default_value = "1", value_parser = clap::value_parser!(u32).range(1..=60))]
        retry_count: u32,
    },

    /// Debug a confirmed transaction
    Debug {
        /// Transaction signature (ts... format or 128 hex characters)
        signature: String,

        /// Include account state snapshots before execution
        #[arg(long = "state-before", alias = "include-state-before")]
        include_state_before: bool,

        /// Include account state snapshots after execution
        #[arg(long = "state-after", alias = "include-state-after")]
        include_state_after: bool,

        /// Include full account data in state snapshots
        #[arg(long = "account-data", alias = "include-account-data")]
        include_account_data: bool,

        /// Save VM execution trace to file
        #[arg(long, value_name = "FILE")]
        output_trace: Option<String>,

        /// Include the full trace string in JSON output
        #[arg(long)]
        inline_trace: bool,

        /// Include full memory dump (stack + heap pages)
        #[arg(long = "memory-dump", alias = "include-memory-dump")]
        include_memory_dump: bool,
    },

    /// Sort public keys for inclusion in transaction account lists
    Sort {
        /// Public keys to sort (hex or ta... format)
        pubkeys: Vec<String>,
    },
}

/// Account management subcommands
#[derive(Subcommand)]
pub enum AccountCommands {
    /// Create a new account with fee payer proof
    Create {
        /// Key name from configuration (optional, defaults to 'default')
        key_name: Option<String>,
    },

    /// Get account information (alias to getaccountinfo)
    Info {
        /// Key name from configuration (optional, defaults to 'default')
        key_name: Option<String>,
    },

    /// List transactions involving an account
    #[command(name = "transactions")]
    Transactions {
        /// Account identifier (key name from config or public key, defaults to 'default')
        account: Option<String>,

        /// Maximum number of transactions to return (defaults to server setting)
        #[arg(long = "page-size")]
        page_size: Option<u32>,

        /// Page token to continue from a previous request
        #[arg(long = "page-token")]
        page_token: Option<String>,
    },

    /// Compress an account
    Compress {
        /// Target account to compress (key name from config or ta... address)
        target_account: String,
        /// Fee payer account (key name from config or ta... address, optional - defaults to 'default')
        fee_payer: Option<String>,
    },

    /// Decompress an account
    Decompress {
        /// Target account to decompress (key name from config or ta... address)
        target_account: String,
        /// Fee payer account (key name from config or ta... address, optional - defaults to 'default')
        fee_payer: Option<String>,
    },

    /// Prepare account decompression - get account data and proof
    PrepareDecompression {
        /// Account address or key name from configuration
        account: String,
    },
}

/// Utility subcommands
#[derive(Subcommand)]
pub enum UtilCommands {
    /// Format conversion commands
    #[command(name = "convert")]
    Convert {
        #[command(subcommand)]
        subcommand: ConvertCommands,
    },
}

/// Format conversion subcommands
#[derive(Subcommand)]
pub enum ConvertCommands {
    /// Public key conversion commands
    #[command(name = "pubkey")]
    Pubkey {
        #[command(subcommand)]
        subcommand: PubkeyConvertCommands,
    },

    /// Signature conversion commands
    #[command(name = "signature")]
    Signature {
        #[command(subcommand)]
        subcommand: SignatureConvertCommands,
    },
}

/// Public key conversion subcommands
#[derive(Subcommand)]
pub enum PubkeyConvertCommands {
    /// Convert hex public key to thru format (ta...)
    #[command(name = "hex-to-thrufmt")]
    HexToThruFmt {
        /// Hex-encoded public key (64 hex characters)
        hex_pubkey: String,
    },

    /// Convert thru format public key (ta...) to hex
    #[command(name = "thrufmt-to-hex")]
    ThruFmtToHex {
        /// Thru format public key (46 characters starting with ta)
        thrufmt_pubkey: String,
    },
}

/// Signature conversion subcommands
#[derive(Subcommand)]
pub enum SignatureConvertCommands {
    /// Convert hex signature to thru format (ts...)
    #[command(name = "hex-to-thrufmt")]
    HexToThruFmt {
        /// Hex-encoded signature (128 hex characters)
        hex_signature: String,
    },

    /// Convert thru format signature (ts...) to hex
    #[command(name = "thrufmt-to-hex")]
    ThruFmtToHex {
        /// Thru format signature (90 characters starting with ts)
        thrufmt_signature: String,
    },
}

/// Token program subcommands
#[derive(Subcommand)]
pub enum TokenCommands {
    /// Initialize a new token mint
    InitializeMint {
        /// Creator address (must be authorized to create)
        creator: String,

        /// Mint authority address (optional, defaults to creator)
        #[arg(long)]
        mint_authority: Option<String>,

        /// Freeze authority address (optional)
        #[arg(long)]
        freeze_authority: Option<String>,

        /// Number of decimal places
        #[arg(long, default_value = "9")]
        decimals: u8,

        /// Token ticker symbol (max 8 characters)
        ticker: String,

        /// Seed for mint account derivation (32 bytes hex)
        seed: String,

        /// State proof for mint account creation (hex encoded, optional - will auto-generate if not provided)
        #[arg(long)]
        state_proof: Option<String>,

        /// Fee payer account (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Override token program address (ta... or hex)
        #[arg(long = "token-program")]
        token_program: Option<String>,
    },

    /// Initialize a new token account
    InitializeAccount {
        /// Mint account address
        mint: String,

        /// Account owner address
        owner: String,

        /// Seed for token account derivation (32 bytes hex)
        seed: String,

        /// State proof for token account creation (hex encoded, optional - will auto-generate if not provided)
        #[arg(long)]
        state_proof: Option<String>,

        /// Fee payer account (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Override token program address (ta... or hex)
        #[arg(long = "token-program")]
        token_program: Option<String>,
    },

    /// Transfer tokens between accounts
    Transfer {
        /// Source token account address
        from: String,

        /// Destination token account address
        to: String,

        /// Amount to transfer
        amount: u64,

        /// Fee payer account (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Override token program address (ta... or hex)
        #[arg(long = "token-program")]
        token_program: Option<String>,
    },

    /// Mint new tokens to an account
    MintTo {
        /// Mint account address
        mint: String,

        /// Destination token account address
        to: String,

        /// Mint authority address
        authority: String,

        /// Amount to mint
        amount: u64,

        /// Fee payer account (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Override token program address (ta... or hex)
        #[arg(long = "token-program")]
        token_program: Option<String>,
    },

    /// Burn tokens from an account
    Burn {
        /// Token account address
        account: String,

        /// Mint account address
        mint: String,

        /// Account authority address
        authority: String,

        /// Amount to burn
        amount: u64,

        /// Fee payer account (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Override token program address (ta... or hex)
        #[arg(long = "token-program")]
        token_program: Option<String>,
    },

    /// Close a token account
    CloseAccount {
        /// Token account address
        account: String,

        /// Destination for remaining balance
        destination: String,

        /// Account authority address
        authority: String,

        /// Fee payer account (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Override token program address (ta... or hex)
        #[arg(long = "token-program")]
        token_program: Option<String>,
    },

    /// Freeze a token account
    FreezeAccount {
        /// Token account address
        account: String,

        /// Mint account address
        mint: String,

        /// Freeze authority address
        authority: String,

        /// Fee payer account (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Override token program address (ta... or hex)
        #[arg(long = "token-program")]
        token_program: Option<String>,
    },

    /// Unfreeze a token account
    ThawAccount {
        /// Token account address
        account: String,

        /// Mint account address
        mint: String,

        /// Freeze authority address
        authority: String,

        /// Fee payer account (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Override token program address (ta... or hex)
        #[arg(long = "token-program")]
        token_program: Option<String>,
    },

    /// Derive token account address from mint, owner, and seed
    DeriveTokenAccount {
        /// Mint account address
        mint: String,

        /// Account owner address
        owner: String,

        /// Seed for derivation (32 bytes hex, optional - defaults to all zeros)
        #[arg(long)]
        seed: Option<String>,

        /// Override token program address (ta... or hex)
        #[arg(long = "token-program")]
        token_program: Option<String>,
    },

    /// Derive mint account address from creator and seed
    DeriveMintAccount {
        /// Creator address
        creator: String,

        /// Seed for derivation (32 bytes hex)
        seed: String,

        /// Override token program address (ta... or hex)
        #[arg(long = "token-program")]
        token_program: Option<String>,
    },
}

/// Faucet program subcommands
#[derive(Subcommand)]
pub enum FaucetCommands {
    /// Deposit tokens into the faucet
    Deposit {
        /// Account identifier (key name or ta.../hex pubkey) to use as depositor (must match fee payer)
        account: String,

        /// Amount to deposit
        amount: u64,

        /// Fee payer account name (defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,
    },

    /// Withdraw tokens from the faucet
    Withdraw {
        /// Account identifier (key name or ta.../hex pubkey) to use as recipient
        account: String,

        /// Amount to withdraw (max 10000 per transaction)
        amount: u64,

        /// Fee payer account name (defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,
    },
}

/// Thru registrar program subcommands
#[derive(Subcommand)]
pub enum RegistrarCommands {
    /// Initialize the .thru registry
    InitializeRegistry {
        /// Name service program address
        #[arg(long = "name-service-program")]
        name_service_program: Option<String>,

        /// Root registrar account address
        root_registrar_account: String,

        /// Treasurer token account address
        treasurer_account: String,

        /// Token mint address (the mint itself, not a holder account)
        token_mint_account: String,

        /// Token program address
        #[arg(long = "token-program")]
        token_program: Option<String>,

        /// Price per year in base units
        price_per_year: u64,

        /// Root domain name (e.g., "thru")
        #[arg(default_value = "thru")]
        root_domain_name: String,

        /// State proof for config account creation (hex encoded, optional - will auto-generate if not provided)
        #[arg(long)]
        config_proof: Option<String>,

        /// State proof for registrar account creation (hex encoded, optional - will auto-generate if not provided)
        #[arg(long)]
        registrar_proof: Option<String>,

        /// Fee payer account (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Override thru registrar program address (ta... or hex)
        #[arg(long = "thru-registrar-program", alias = "thru-name-service-program")]
        thru_registrar_program: Option<String>,
    },

    /// Purchase a .thru domain
    PurchaseDomain {
        /// Domain name without .thru suffix (e.g., "example")
        domain_name: String,

        /// Number of years to purchase (must be > 0)
        years: u8,

        /// Config account address (must exist and be initialized)
        config_account: String,

        /// Payer token account (must be an account for the registry mint owned by fee payer)
        payer_token_account: String,

        /// State proof for lease account creation (hex encoded, optional - will auto-generate if not provided)
        #[arg(long)]
        lease_proof: Option<String>,

        /// State proof for domain account creation (hex encoded, optional - will auto-generate if not provided)
        #[arg(long)]
        domain_proof: Option<String>,

        /// Fee payer account (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Override thru registrar program address (ta... or hex)
        #[arg(long = "thru-registrar-program", alias = "thru-name-service-program")]
        thru_registrar_program: Option<String>,
    },

    /// Renew an existing domain lease
    RenewLease {
        /// Lease account address
        lease_account: String,

        /// Number of years to extend the lease (must be > 0)
        years: u8,

        /// Config account address (must exist and be initialized)
        config_account: String,

        /// Payer token account (must be an account for the registry mint owned by fee payer)
        payer_token_account: String,

        /// Fee payer account (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Override thru registrar program address (ta... or hex)
        #[arg(long = "thru-registrar-program", alias = "thru-name-service-program")]
        thru_registrar_program: Option<String>,
    },

    /// Claim an expired domain
    ClaimExpiredDomain {
        /// Lease account address
        lease_account: String,

        /// Number of years to claim the domain (must be > 0)
        years: u8,

        /// Config account address (must exist and be initialized)
        config_account: String,

        /// Payer token account (must be an account for the registry mint owned by fee payer)
        payer_token_account: String,

        /// Fee payer account (optional, defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Override thru registrar program address (ta... or hex)
        #[arg(long = "thru-registrar-program", alias = "thru-name-service-program")]
        thru_registrar_program: Option<String>,
    },
}

/// Name service program subcommands
#[derive(Subcommand)]
pub enum NameServiceCommands {
    /// Append a key/value record to a domain
    #[command(name = "append-record")]
    AppendRecord {
        /// Domain account address
        domain_account: String,

        /// Record key (<=32 bytes)
        key: String,

        /// Record value (<=256 bytes)
        value: String,

        /// Owner account pubkey (defaults to fee payer)
        #[arg(long)]
        owner: Option<String>,

        /// Fee payer account (defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Name service program address
        #[arg(long = "name-service-program")]
        name_service_program: Option<String>,
    },

    /// Delete a key/value record from a domain
    #[command(name = "delete-record")]
    DeleteRecord {
        /// Domain account address
        domain_account: String,

        /// Record key to delete
        key: String,

        /// Owner account pubkey (defaults to fee payer)
        #[arg(long)]
        owner: Option<String>,

        /// Fee payer account (defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Name service program address
        #[arg(long = "name-service-program")]
        name_service_program: Option<String>,
    },

    /// Derive config account address
    DeriveConfigAccount {
        /// Override thru registrar program address (ta... or hex)
        #[arg(long = "thru-registrar-program", alias = "thru-name-service-program")]
        thru_registrar_program: Option<String>,
    },

    /// Derive a domain account address from parent and name
    #[command(name = "derive-domain-account")]
    DeriveDomainAccount {
        /// Parent registrar or domain account address
        parent_account: String,

        /// Domain name segment (e.g., "example")
        domain_name: String,

        /// Name service program address
        #[arg(long = "name-service-program")]
        name_service_program: Option<String>,
    },

    /// Derive lease account address from domain name
    DeriveLeaseAccount {
        /// Domain name without .thru suffix (e.g., "example")
        domain_name: String,

        /// Override thru registrar program address (ta... or hex)
        #[arg(long = "thru-registrar-program", alias = "thru-name-service-program")]
        thru_registrar_program: Option<String>,
    },

    /// Derive a root registrar account address from the root name
    #[command(name = "derive-registrar-account")]
    DeriveRegistrarAccount {
        /// Root domain name segment
        root_name: String,

        /// Name service program address
        #[arg(long = "name-service-program")]
        name_service_program: Option<String>,
    },

    /// Initialize a root registrar for the base name service program
    #[command(name = "init-root")]
    InitRoot {
        /// Root domain name (e.g., "thru")
        root_name: String,

        /// Name service program address
        #[arg(long = "name-service-program")]
        name_service_program: Option<String>,

        /// Registrar account address (derived automatically if omitted)
        #[arg(long)]
        registrar_account: Option<String>,

        /// Authority account pubkey (defaults to fee payer)
        #[arg(long)]
        authority: Option<String>,

        /// State proof for registrar account creation (hex encoded, optional - auto-generated if not provided)
        #[arg(long)]
        proof: Option<String>,

        /// Fee payer account (defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,
    },

    /// List records stored on a domain
    #[command(name = "list-records")]
    ListRecords {
        /// Domain account address
        domain_account: String,

        /// Name service program address
        #[arg(long = "name-service-program")]
        name_service_program: Option<String>,
    },

    /// Register a subdomain under a parent registrar or domain
    #[command(name = "register-subdomain")]
    RegisterSubdomain {
        /// Subdomain name segment (e.g., "example")
        domain_name: String,

        /// Parent registrar or domain account address
        parent_account: String,

        /// Name service program address
        #[arg(long = "name-service-program")]
        name_service_program: Option<String>,

        /// Domain account address (derived automatically if omitted)
        #[arg(long)]
        domain_account: Option<String>,

        /// Owner account pubkey (defaults to fee payer)
        #[arg(long)]
        owner: Option<String>,

        /// Authority account pubkey (defaults to owner)
        #[arg(long)]
        authority: Option<String>,

        /// State proof for domain account creation (hex encoded, optional - auto-generated if not provided)
        #[arg(long)]
        proof: Option<String>,

        /// Fee payer account (defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,
    },

    /// Resolve a domain account and optionally retrieve a record value
    #[command(name = "resolve")]
    Resolve {
        /// Domain account address
        domain_account: String,

        /// Optional record key to fetch
        #[arg(long)]
        key: Option<String>,

        /// Name service program address
        #[arg(long = "name-service-program")]
        name_service_program: Option<String>,
    },

    /// Unregister (delete) a subdomain
    #[command(name = "unregister-subdomain")]
    UnregisterSubdomain {
        /// Domain account address
        domain_account: String,

        /// Owner account pubkey (defaults to fee payer)
        #[arg(long)]
        owner: Option<String>,

        /// Fee payer account (defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Name service program address
        #[arg(long = "name-service-program")]
        name_service_program: Option<String>,
    },
}

/// WTHRU program subcommands
#[derive(Subcommand)]
pub enum WthruCommands {
    /// Initialize the WTHRU mint and vault accounts
    Initialize {
        /// Fee payer account name (defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Override WTHRU program address (ta... or hex)
        #[arg(long = "program")]
        program: Option<String>,

        /// Override token program address (ta... or hex)
        #[arg(long = "token-program")]
        token_program: Option<String>,
    },

    /// Deposit native THRU and receive WTHRU tokens
    Deposit {
        /// Destination WTHRU token account address
        dest_token_account: String,

        /// Amount of native THRU to wrap (lamports)
        amount: u64,

        /// Fee payer account name (defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Override WTHRU program address (ta... or hex)
        #[arg(long = "program")]
        program: Option<String>,

        /// Override token program address (ta... or hex)
        #[arg(long = "token-program")]
        token_program: Option<String>,

        /// Skip the native transfer (only run the deposit instruction)
        #[arg(long = "skip-transfer")]
        skip_transfer: bool,
    },

    /// Withdraw native THRU by burning WTHRU tokens
    Withdraw {
        /// Source WTHRU token account address
        wthru_token_account: String,

        /// Recipient native account address (ta...)
        recipient: String,

        /// Amount of WTHRU to unwrap (lamports)
        amount: u64,

        /// Fee payer/owner account name (defaults to 'default')
        #[arg(long)]
        fee_payer: Option<String>,

        /// Override WTHRU program address (ta... or hex)
        #[arg(long = "program")]
        program: Option<String>,

        /// Override token program address (ta... or hex)
        #[arg(long = "token-program")]
        token_program: Option<String>,
    },
}

/// Validator program subcommands
#[derive(Subcommand)]
pub enum ValidatorCommands {
    /// Activate a validator in the validator program
    Activate {
        /// Source token account holding stake tokens
        #[arg(long = "source-token-account")]
        source_token_account: String,

        /// Amount of tokens to stake
        #[arg(long = "token-amount")]
        token_amount: u64,

        /// Validator BLS public key as 96-byte uncompressed hex
        #[arg(
            long = "bls-pubkey",
            conflicts_with = "bls_seed",
            required_unless_present = "bls_seed"
        )]
        bls_pubkey: Option<String>,

        /// Deterministic test seed used to derive a valid BLS public key
        #[arg(long = "bls-seed", conflicts_with = "bls_pubkey")]
        bls_seed: Option<u64>,

        /// Claim authority pubkey or key name (defaults to fee payer)
        #[arg(long = "claim-authority")]
        claim_authority: Option<String>,

        /// Fee payer account name (defaults to 'default')
        #[arg(long = "fee-payer")]
        fee_payer: Option<String>,

        /// Override consensus validator program address
        #[arg(long = "program")]
        program: Option<String>,

        /// Override attestor table account address
        #[arg(long = "attestor-table")]
        attestor_table: Option<String>,

        /// Override token program address
        #[arg(long = "token-program")]
        token_program: Option<String>,

        /// Override converted vault address
        #[arg(long = "converted-vault")]
        converted_vault: Option<String>,
    },

    /// Deactivate a validator and withdraw unclaimed rewards
    Deactivate {
        /// Destination token account for unclaimed rewards
        #[arg(long = "dest-token-account")]
        dest_token_account: String,

        /// Fee payer account name (defaults to 'default')
        #[arg(long = "fee-payer")]
        fee_payer: Option<String>,

        /// Override consensus validator program address
        #[arg(long = "program")]
        program: Option<String>,

        /// Override attestor table account address
        #[arg(long = "attestor-table")]
        attestor_table: Option<String>,

        /// Override token program address
        #[arg(long = "token-program")]
        token_program: Option<String>,

        /// Override unclaimed vault address
        #[arg(long = "unclaimed-vault")]
        unclaimed_vault: Option<String>,
    },

    /// Convert additional tokens into stake weight
    #[command(name = "convert-tokens")]
    ConvertTokens {
        /// Source token account holding additional stake tokens
        #[arg(long = "source-token-account")]
        source_token_account: String,

        /// Amount of tokens to convert
        #[arg(long = "token-amount")]
        token_amount: u64,

        /// Fee payer account name (defaults to 'default')
        #[arg(long = "fee-payer")]
        fee_payer: Option<String>,

        /// Override consensus validator program address
        #[arg(long = "program")]
        program: Option<String>,

        /// Override attestor table account address
        #[arg(long = "attestor-table")]
        attestor_table: Option<String>,

        /// Override token program address
        #[arg(long = "token-program")]
        token_program: Option<String>,

        /// Override converted vault address
        #[arg(long = "converted-vault")]
        converted_vault: Option<String>,
    },

    /// Claim accumulated rewards for a validator subject
    Claim {
        /// Validator identity pubkey or key name whose rewards should be claimed
        #[arg(long = "subject-attestor")]
        subject_attestor: String,

        /// Destination token account for claimed rewards
        #[arg(long = "dest-token-account")]
        dest_token_account: String,

        /// Fee payer account name (defaults to 'default')
        #[arg(long = "fee-payer")]
        fee_payer: Option<String>,

        /// Override consensus validator program address
        #[arg(long = "program")]
        program: Option<String>,

        /// Override attestor table account address
        #[arg(long = "attestor-table")]
        attestor_table: Option<String>,

        /// Override token program address
        #[arg(long = "token-program")]
        token_program: Option<String>,

        /// Override unclaimed vault address
        #[arg(long = "unclaimed-vault")]
        unclaimed_vault: Option<String>,
    },

    /// Update the claim authority for a validator subject
    #[command(name = "set-claim-authority")]
    SetClaimAuthority {
        /// Validator identity pubkey or key name whose claim authority is changing
        #[arg(long = "subject-attestor")]
        subject_attestor: String,

        /// New claim authority pubkey or key name
        #[arg(long = "new-claim-authority")]
        new_claim_authority: String,

        /// Fee payer account name (defaults to 'default')
        #[arg(long = "fee-payer")]
        fee_payer: Option<String>,

        /// Override consensus validator program address
        #[arg(long = "program")]
        program: Option<String>,

        /// Override attestor table account address
        #[arg(long = "attestor-table")]
        attestor_table: Option<String>,
    },

    /// Show the validator table
    Table {
        /// Override attestor table account address
        #[arg(long = "attestor-table")]
        attestor_table: Option<String>,
    },

    /// Show details for a specific validator by SID, address, or key name
    Info {
        /// Validator SID, address, or configured key name
        validator: String,

        /// Override attestor table account address
        #[arg(long = "attestor-table")]
        attestor_table: Option<String>,
    },
}

/// Developer tools subcommands
#[derive(Subcommand)]
pub enum DevCommands {
    /// Toolchain management commands
    #[command(name = "toolchain")]
    Toolchain {
        #[command(subcommand)]
        subcommand: ToolchainCommands,
    },

    /// SDK management commands
    #[command(name = "sdk")]
    Sdk {
        #[command(subcommand)]
        subcommand: SdkCommands,
    },

    /// Initialize new projects
    #[command(name = "init")]
    Init {
        #[command(subcommand)]
        subcommand: InitCommands,
    },
}

/// Toolchain management subcommands
#[derive(Subcommand)]
pub enum ToolchainCommands {
    /// Install toolchain from GitHub releases
    Install {
        /// Toolchain version (optional, defaults to latest)
        #[arg(long)]
        version: Option<String>,

        /// Installation path (optional, defaults to ~/.thru/sdk/toolchain/)
        #[arg(long)]
        path: Option<String>,

        /// GitHub repository (format: owner/repo, defaults to Unto-Labs/thru)
        #[arg(long)]
        repo: Option<String>,
    },

    /// Update toolchain to latest version
    Update {
        /// Installation path (optional, defaults to ~/.thru/sdk/toolchain/)
        #[arg(long)]
        path: Option<String>,

        /// GitHub repository (format: owner/repo, defaults to Unto-Labs/thru)
        #[arg(long)]
        repo: Option<String>,
    },

    /// Uninstall toolchain
    Uninstall {
        /// Installation path (optional, defaults to ~/.thru/sdk/toolchain/)
        #[arg(long)]
        path: Option<String>,

        /// Skip confirmation prompt
        #[arg(long)]
        force: bool,
    },

    /// Get toolchain installation path
    Path {
        /// Installation path (optional, defaults to ~/.thru/sdk/toolchain/)
        #[arg(long)]
        path: Option<String>,
    },
}

/// SDK management subcommands
#[derive(Subcommand)]
pub enum SdkCommands {
    /// Install SDK from GitHub releases
    Install {
        /// SDK language (c, cpp, rust)
        language: String,

        /// SDK version (optional, defaults to latest)
        #[arg(long)]
        version: Option<String>,

        /// Installation path (optional, defaults to ~/.thru/sdk/{language}/)
        #[arg(long)]
        path: Option<String>,

        /// GitHub repository (format: owner/repo, defaults to Unto-Labs/thru)
        #[arg(long)]
        repo: Option<String>,
    },

    /// Update SDK to latest version
    Update {
        /// SDK language (c, cpp, rust)
        language: String,

        /// Installation path (optional, defaults to ~/.thru/sdk/{language}/)
        #[arg(long)]
        path: Option<String>,

        /// GitHub repository (format: owner/repo, defaults to Unto-Labs/thru)
        #[arg(long)]
        repo: Option<String>,
    },

    /// Uninstall SDK
    Uninstall {
        /// SDK language (c, cpp, rust)
        language: String,

        /// Installation path (optional, defaults to ~/.thru/sdk/{language}/)
        #[arg(long)]
        path: Option<String>,

        /// Skip confirmation prompt
        #[arg(long)]
        force: bool,
    },

    /// Get SDK installation path
    Path {
        /// SDK language (c, cpp, rust)
        language: String,

        /// Installation path (optional, defaults to ~/.thru/sdk/{language}/)
        #[arg(long)]
        path: Option<String>,
    },
}

/// Project initialization subcommands
#[derive(Subcommand)]
pub enum InitCommands {
    /// Initialize a new C project
    #[command(name = "c")]
    C {
        /// Project name
        project_name: String,

        /// Project directory (optional, defaults to current directory)
        #[arg(long)]
        path: Option<String>,
    },

    /// Initialize a new C++ project (not yet implemented)
    #[command(name = "cpp")]
    Cpp {
        /// Project name
        project_name: String,

        /// Project directory (optional, defaults to current directory)
        #[arg(long)]
        path: Option<String>,
    },

    /// Initialize a new Rust project (not yet implemented)
    #[command(name = "rust")]
    Rust {
        /// Project name
        project_name: String,

        /// Project directory (optional, defaults to current directory)
        #[arg(long)]
        path: Option<String>,
    },
}

/// Debug subcommands
#[derive(Subcommand)]
pub enum DebugCommands {
    /// Resolve DWARF debug info for a transaction debug response
    ///
    /// Takes a program .elf (built with -g) and either a response JSON file or a
    /// transaction signature (calls transaction debug via gRPC). Produces a source-level
    /// error report with file:line mappings, call stack, variables, and annotated trace.
    #[command(name = "resolve")]
    Resolve {
        /// Path to the program .elf file with DWARF debug info
        #[arg(long)]
        elf: std::path::PathBuf,

        /// Path to the transaction debug response JSON file (mutually exclusive with --signature)
        #[arg(long, group = "input")]
        response: Option<std::path::PathBuf>,

        /// Transaction signature to debug via gRPC (mutually exclusive with --response)
        #[arg(long, group = "input")]
        signature: Option<String>,

        /// Number of trace lines to include before the fault
        #[arg(long, default_value = "20")]
        trace_tail: usize,

        /// Source context lines above/below the fault line
        #[arg(long, default_value = "5")]
        context: u32,
    },
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parses_abi_codegen_command() {
        let cli = Cli::try_parse_from([
            "thru",
            "abi",
            "codegen",
            "-f",
            "input.abi.yaml",
            "-l",
            "rust",
        ])
        .expect("codegen command should parse");

        match cli.command {
            Commands::Abi {
                subcommand:
                    AbiCommands::Codegen {
                        files,
                        include_dirs,
                        language,
                        output_dir,
                        verbose,
                    },
            } => {
                assert_eq!(files, vec![PathBuf::from("input.abi.yaml")]);
                assert!(include_dirs.is_empty());
                assert_eq!(language, AbiLanguage::Rust);
                assert_eq!(output_dir, PathBuf::from("generated"));
                assert!(!verbose);
            }
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn parses_abi_account_create_command() {
        let cli = Cli::try_parse_from([
            "thru",
            "abi",
            "account",
            "create",
            "seed-1",
            "program.abi.yaml",
        ])
        .expect("abi account create should parse");

        match cli.command {
            Commands::Abi {
                subcommand:
                    AbiCommands::Account {
                        subcommand:
                            AbiAccountCommands::Create {
                                ephemeral,
                                account_type,
                                target_program,
                                seed,
                                fee_payer,
                                authority,
                                publisher,
                                abi_file,
                            },
                    },
            } => {
                assert!(!ephemeral);
                assert_eq!(account_type, AbiAccountType::Program);
                assert_eq!(target_program, None);
                assert_eq!(seed, "seed-1");
                assert_eq!(fee_payer, None);
                assert_eq!(authority, None);
                assert_eq!(publisher, None);
                assert_eq!(abi_file, "program.abi.yaml");
            }
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn parses_abi_account_get_include_data_flag() {
        let cli = Cli::try_parse_from(["thru", "abi", "account", "get", "ta123", "--include-data"])
            .expect("abi account get should parse");

        match cli.command {
            Commands::Abi {
                subcommand:
                    AbiCommands::Account {
                        subcommand:
                            AbiAccountCommands::Get {
                                abi_account,
                                include_data,
                                out,
                            },
                    },
            } => {
                assert_eq!(abi_account, "ta123");
                assert!(include_data);
                assert_eq!(out, None);
            }
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn parses_abi_account_upgrade_third_party_command() {
        let cli = Cli::try_parse_from([
            "thru",
            "abi",
            "account",
            "upgrade",
            "--account-type",
            "third-party",
            "--target-program",
            "ta_target",
            "--publisher",
            "alice",
            "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
            "program.abi.yaml",
        ])
        .expect("third-party abi account upgrade should parse");

        match cli.command {
            Commands::Abi {
                subcommand:
                    AbiCommands::Account {
                        subcommand:
                            AbiAccountCommands::Upgrade {
                                account_type,
                                publisher,
                                authority,
                                target_program,
                                seed,
                                abi_file,
                                ..
                            },
                    },
            } => {
                assert_eq!(account_type, AbiAccountType::ThirdParty);
                assert_eq!(publisher.as_deref(), Some("alice"));
                assert_eq!(authority, None);
                assert_eq!(target_program.as_deref(), Some("ta_target"));
                assert_eq!(
                    seed,
                    "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
                );
                assert_eq!(abi_file, "program.abi.yaml");
            }
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn parses_abi_account_finalize_standalone_authority_alias() {
        let cli = Cli::try_parse_from([
            "thru",
            "abi",
            "account",
            "finalize",
            "--account-type",
            "standalone",
            "--authority",
            "alice",
            "my-abi-seed",
        ])
        .expect("standalone abi account finalize should parse authority alias");

        match cli.command {
            Commands::Abi {
                subcommand:
                    AbiCommands::Account {
                        subcommand:
                            AbiAccountCommands::Finalize {
                                account_type,
                                target_program,
                                authority,
                                publisher,
                                seed,
                                ..
                            },
                    },
            } => {
                assert_eq!(account_type, AbiAccountType::Standalone);
                assert_eq!(target_program, None);
                assert_eq!(authority.as_deref(), Some("alice"));
                assert_eq!(publisher, None);
                assert_eq!(seed, "my-abi-seed");
            }
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn parses_abi_account_close_command() {
        let cli = Cli::try_parse_from([
            "thru",
            "abi",
            "account",
            "close",
            "--fee-payer",
            "bob",
            "--authority",
            "alice",
            "seed-1",
        ])
        .expect("abi account close should parse");

        match cli.command {
            Commands::Abi {
                subcommand:
                    AbiCommands::Account {
                        subcommand:
                            AbiAccountCommands::Close {
                                account_type,
                                target_program,
                                fee_payer,
                                authority,
                                publisher,
                                seed,
                                ..
                            },
                    },
            } => {
                assert_eq!(account_type, AbiAccountType::Program);
                assert_eq!(target_program, None);
                assert_eq!(fee_payer.as_deref(), Some("bob"));
                assert_eq!(authority.as_deref(), Some("alice"));
                assert_eq!(publisher, None);
                assert_eq!(seed, "seed-1");
            }
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn rejects_conflicting_abi_account_actor_flags() {
        let result = Cli::try_parse_from([
            "thru",
            "abi",
            "account",
            "create",
            "--account-type",
            "standalone",
            "--authority",
            "alice",
            "--publisher",
            "bob",
            "my-abi-seed",
            "program.abi.yaml",
        ]);

        assert!(
            result.is_err(),
            "conflicting abi account actor flags should fail"
        );
    }

    #[test]
    fn parses_network_use_command() {
        let cli =
            Cli::try_parse_from(["thru", "network", "use", "1"]).expect("network use should parse");

        match cli.command {
            Commands::Network {
                subcommand: Some(NetworkCommands::Use { name }),
            } => assert_eq!(name, "1"),
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn parses_bare_network_command() {
        let cli = Cli::try_parse_from(["thru", "network"]).expect("bare network should parse");

        match cli.command {
            Commands::Network { subcommand: None } => {}
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn rejects_legacy_network_set_default_alias() {
        let cli = Cli::try_parse_from(["thru", "network", "set-default", "1"]);

        assert!(
            cli.is_err(),
            "legacy network set-default alias should no longer parse"
        );
    }

    #[test]
    fn rejects_legacy_network_list_subcommand() {
        let cli = Cli::try_parse_from(["thru", "network", "list"]);

        assert!(
            cli.is_err(),
            "legacy network list subcommand should no longer parse"
        );
    }

    #[test]
    fn parses_network_remove_command() {
        let cli =
            Cli::try_parse_from(["thru", "network", "rm", "1"]).expect("network rm should parse");

        match cli.command {
            Commands::Network {
                subcommand: Some(NetworkCommands::Remove { name }),
            } => assert_eq!(name, "1"),
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn rejects_conflicting_abi_reflect_flags() {
        let result = Cli::try_parse_from([
            "thru",
            "abi",
            "reflect",
            "-f",
            "input.abi.yaml",
            "-t",
            "MyType",
            "-d",
            "data.bin",
            "--validate-only",
            "--values-only",
        ]);

        assert!(result.is_err(), "conflicting reflect flags should fail");
    }

    #[test]
    fn abi_reflect_short_v_is_no_longer_values_only() {
        let result = Cli::try_parse_from([
            "thru",
            "abi",
            "reflect",
            "-f",
            "input.abi.yaml",
            "-t",
            "MyType",
            "-d",
            "data.bin",
            "-v",
        ]);

        assert!(
            result.is_err(),
            "short -v should no longer parse for abi reflect"
        );
    }

    #[test]
    fn parses_abi_prep_for_publish_command() {
        let cli = Cli::try_parse_from([
            "thru",
            "abi",
            "prep-for-publish",
            "-f",
            "root.abi.yaml",
            "--target-network",
            "mainnet",
            "-o",
            "publish.abi.yaml",
        ])
        .expect("prep-for-publish command should parse");

        match cli.command {
            Commands::Abi {
                subcommand:
                    AbiCommands::PrepForPublish {
                        file,
                        include_dirs,
                        target_network,
                        output,
                        verbose,
                    },
            } => {
                assert_eq!(file, PathBuf::from("root.abi.yaml"));
                assert!(include_dirs.is_empty());
                assert_eq!(target_network, "mainnet");
                assert_eq!(output, PathBuf::from("publish.abi.yaml"));
                assert!(!verbose);
            }
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn parses_txn_debug_inline_trace_flag() {
        let cli = Cli::try_parse_from([
            "thru",
            "txn",
            "debug",
            "ts11111111111111111111111111111111111111111111111111111111111111111111111111111111111111",
            "--inline-trace",
            "--output-trace",
            "trace.log",
            "--state-before",
        ])
        .expect("txn debug command should parse");

        match cli.command {
            Commands::Txn {
                subcommand:
                    TxnCommands::Debug {
                        signature,
                        include_state_before,
                        include_state_after,
                        include_account_data,
                        output_trace,
                        inline_trace,
                        include_memory_dump,
                    },
            } => {
                assert_eq!(
                    signature,
                    "ts11111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
                );
                assert!(include_state_before);
                assert!(!include_state_after);
                assert!(!include_account_data);
                assert_eq!(output_trace.as_deref(), Some("trace.log"));
                assert!(inline_trace);
                assert!(!include_memory_dump);
            }
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn parses_txn_debug_legacy_include_flag_aliases() {
        let cli = Cli::try_parse_from([
            "thru",
            "txn",
            "debug",
            "ts11111111111111111111111111111111111111111111111111111111111111111111111111111111111111",
            "--include-state-after",
            "--include-account-data",
            "--include-memory-dump",
        ])
        .expect("legacy txn debug flag aliases should continue to parse");

        match cli.command {
            Commands::Txn {
                subcommand:
                    TxnCommands::Debug {
                        include_state_before,
                        include_state_after,
                        include_account_data,
                        include_memory_dump,
                        ..
                    },
            } => {
                assert!(!include_state_before);
                assert!(include_state_after);
                assert!(include_account_data);
                assert!(include_memory_dump);
            }
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn parses_consensus_validator_activate_command() {
        let cli = Cli::try_parse_from([
            "thru",
            "validator",
            "activate",
            "--source-token-account",
            "ta_source",
            "--token-amount",
            "1000",
            "--bls-pubkey",
            &"11".repeat(96),
            "--claim-authority",
            "alice",
            "--fee-payer",
            "bob",
            "--converted-vault",
            "ta_vault",
        ])
        .expect("validator activate should parse");

        match cli.command {
            Commands::Validator {
                subcommand:
                    ValidatorCommands::Activate {
                        source_token_account,
                        token_amount,
                        bls_pubkey,
                        bls_seed,
                        claim_authority,
                        fee_payer,
                        converted_vault,
                        ..
                    },
            } => {
                assert_eq!(source_token_account, "ta_source");
                assert_eq!(token_amount, 1000);
                assert_eq!(bls_pubkey.as_deref(), Some("11".repeat(96).as_str()));
                assert_eq!(bls_seed, None);
                assert_eq!(claim_authority.as_deref(), Some("alice"));
                assert_eq!(fee_payer.as_deref(), Some("bob"));
                assert_eq!(converted_vault.as_deref(), Some("ta_vault"));
            }
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn parses_consensus_validator_convert_tokens_command() {
        let cli = Cli::try_parse_from([
            "thru",
            "validator",
            "convert-tokens",
            "--source-token-account",
            "ta_source",
            "--token-amount",
            "250",
            "--token-program",
            "ta_token",
        ])
        .expect("validator convert-tokens should parse");

        match cli.command {
            Commands::Validator {
                subcommand:
                    ValidatorCommands::ConvertTokens {
                        source_token_account,
                        token_amount,
                        token_program,
                        ..
                    },
            } => {
                assert_eq!(source_token_account, "ta_source");
                assert_eq!(token_amount, 250);
                assert_eq!(token_program.as_deref(), Some("ta_token"));
            }
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn parses_consensus_validator_set_claim_authority_command() {
        let cli = Cli::try_parse_from([
            "thru",
            "validator",
            "set-claim-authority",
            "--subject-attestor",
            "alice",
            "--new-claim-authority",
            "bob",
            "--attestor-table",
            "ta_table",
        ])
        .expect("validator set-claim-authority should parse");

        match cli.command {
            Commands::Validator {
                subcommand:
                    ValidatorCommands::SetClaimAuthority {
                        subject_attestor,
                        new_claim_authority,
                        attestor_table,
                        ..
                    },
            } => {
                assert_eq!(subject_attestor, "alice");
                assert_eq!(new_claim_authority, "bob");
                assert_eq!(attestor_table.as_deref(), Some("ta_table"));
            }
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn parses_validator_table_command() {
        let cli =
            Cli::try_parse_from(["thru", "validator", "table", "--attestor-table", "ta_table"])
                .expect("validator table should parse");

        match cli.command {
            Commands::Validator {
                subcommand: ValidatorCommands::Table { attestor_table },
            } => {
                assert_eq!(attestor_table.as_deref(), Some("ta_table"));
            }
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn parses_validator_activate_with_bls_seed() {
        let cli = Cli::try_parse_from([
            "thru",
            "validator",
            "activate",
            "--source-token-account",
            "ta_source",
            "--token-amount",
            "1000",
            "--bls-seed",
            "17",
        ])
        .expect("validator activate with bls seed should parse");

        match cli.command {
            Commands::Validator {
                subcommand:
                    ValidatorCommands::Activate {
                        bls_pubkey,
                        bls_seed,
                        ..
                    },
            } => {
                assert_eq!(bls_pubkey, None);
                assert_eq!(bls_seed, Some(17));
            }
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn parses_validator_info_command() {
        let cli = Cli::try_parse_from([
            "thru",
            "validator",
            "info",
            "alice",
            "--attestor-table",
            "ta_table",
        ])
        .expect("validator info should parse");

        match cli.command {
            Commands::Validator {
                subcommand:
                    ValidatorCommands::Info {
                        validator,
                        attestor_table,
                    },
            } => {
                assert_eq!(validator, "alice");
                assert_eq!(attestor_table.as_deref(), Some("ta_table"));
            }
            _ => panic!("unexpected command"),
        }
    }

    #[test]
    fn rejects_debug_re_execute_command() {
        let result = Cli::try_parse_from([
            "thru",
            "debug",
            "re-execute",
            "ts11111111111111111111111111111111111111111111111111111111111111111111111111111111111111",
        ]);

        assert!(result.is_err(), "debug re-execute should no longer parse");
    }
}