//! Tauri commands for the desktop wallet
//!
//! All commands are async and return Result<T, Error> which Tauri
//! serializes as { ok: T } or { error: string } to the frontend.

use serde::{Deserialize, Serialize};
use tauri::{AppHandle, Manager, State};

use crate::wallet::{WalletState, WalletAddress, NetworkConnection};
use crate::{Error, Result};

// ============================================================================
// Wallet Management Commands
// ============================================================================

/// Response from wallet creation
#[derive(Debug, Serialize)]
pub struct CreateWalletResponse {
    pub mnemonic: String,
    pub address: String,
}

/// Create a new wallet with a random mnemonic
#[tauri::command]
pub async fn create_wallet(
    app: AppHandle,
    state: State<'_, WalletState>,
    password: String,
) -> Result<CreateWalletResponse> {
    // Validate password strength
    if password.len() < 8 {
        return Err(Error::Crypto("Password must be at least 8 characters".to_string()));
    }

    // Set up data directory
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    state.set_data_dir(app_data_dir).await?;

    // Check if wallet already exists
    if state.wallet_exists().await {
        return Err(Error::Internal("Wallet already exists. Import or unlock instead.".to_string()));
    }

    // Create wallet with encryption (testnet by default for safety)
    let (mnemonic, address) = state.create(&password, true).await?;

    Ok(CreateWalletResponse { mnemonic, address })
}

/// Import request
#[derive(Debug, Deserialize)]
pub struct ImportWalletRequest {
    pub mnemonic: String,
    pub password: String,
}

/// Import a wallet from mnemonic phrase
#[tauri::command]
pub async fn import_wallet(
    app: AppHandle,
    state: State<'_, WalletState>,
    request: ImportWalletRequest,
) -> Result<String> {
    // Validate password strength
    if request.password.len() < 8 {
        return Err(Error::Crypto("Password must be at least 8 characters".to_string()));
    }

    // Set up data directory
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    state.set_data_dir(app_data_dir).await?;

    // Import wallet with encryption (testnet by default for safety)
    let address = state.import(&request.mnemonic, &request.password, true).await?;

    Ok(address)
}

/// Unlock an existing wallet
#[tauri::command]
pub async fn unlock_wallet(
    app: AppHandle,
    state: State<'_, WalletState>,
    password: String,
) -> Result<bool> {
    // Set up data directory
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    state.set_data_dir(app_data_dir).await?;

    // Load wallet metadata from file
    state.load_metadata().await?;

    // Decrypt and unlock
    state.unlock(&password).await?;

    Ok(true)
}

/// Lock the wallet (clear sensitive data from memory)
#[tauri::command]
pub async fn lock_wallet(state: State<'_, WalletState>) -> Result<()> {
    state.lock().await;
    Ok(())
}

/// Wallet info returned to frontend
#[derive(Debug, Serialize)]
pub struct WalletInfo {
    pub locked: bool,
    pub address_count: usize,
    pub network: Option<String>,
}

/// Get wallet information
#[tauri::command]
pub async fn get_wallet_info(state: State<'_, WalletState>) -> Result<WalletInfo> {
    let locked = !state.is_unlocked().await;
    let addresses = state.addresses.read().await;
    let connection = state.connection.read().await;

    Ok(WalletInfo {
        locked,
        address_count: addresses.len(),
        network: connection.as_ref().map(|c| c.network.clone()),
    })
}

/// Export the mnemonic phrase (requires unlock)
#[tauri::command]
pub async fn export_mnemonic(
    state: State<'_, WalletState>,
    password: String,
) -> Result<String> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }
    // TODO: Re-verify password and return mnemonic
    Err(Error::Internal("Not implemented".to_string()))
}

// ============================================================================
// Multi-Wallet Management Commands
// ============================================================================

use crate::wallet_manager::{WalletManager, WalletSummary};

/// List all wallets
#[tauri::command]
pub async fn wallets_list(
    manager: State<'_, WalletManager>,
) -> Result<Vec<WalletSummary>> {
    Ok(manager.list_wallets().await)
}

/// Create wallet response (multi-wallet)
#[derive(Debug, Serialize)]
pub struct MultiWalletCreateResponse {
    pub wallet_id: String,
    pub mnemonic: String,
    pub address: String,
}

/// Create a new wallet (multi-wallet version)
#[tauri::command]
pub async fn wallets_create(
    app: AppHandle,
    manager: State<'_, WalletManager>,
    label: String,
    password: String,
    testnet: Option<bool>,
) -> Result<MultiWalletCreateResponse> {
    // Validate password strength
    if password.len() < 8 {
        return Err(Error::Crypto("Password must be at least 8 characters".to_string()));
    }

    // Set up data directory
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    manager.set_data_dir(app_data_dir).await?;

    // Create wallet
    let (wallet_id, mnemonic, address) = manager.create_wallet(
        label,
        &password,
        testnet.unwrap_or(true),
    ).await?;

    Ok(MultiWalletCreateResponse {
        wallet_id,
        mnemonic,
        address,
    })
}

/// Import wallet response (multi-wallet)
#[derive(Debug, Serialize)]
pub struct MultiWalletImportResponse {
    pub wallet_id: String,
    pub address: String,
}

/// Import a wallet from mnemonic (multi-wallet version)
#[tauri::command]
pub async fn wallets_import(
    app: AppHandle,
    manager: State<'_, WalletManager>,
    label: String,
    mnemonic: String,
    password: String,
    testnet: Option<bool>,
) -> Result<MultiWalletImportResponse> {
    // Validate password strength
    if password.len() < 8 {
        return Err(Error::Crypto("Password must be at least 8 characters".to_string()));
    }

    // Set up data directory
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    manager.set_data_dir(app_data_dir).await?;

    // Import wallet
    let (wallet_id, address) = manager.import_wallet(
        label,
        &mnemonic,
        &password,
        testnet.unwrap_or(true),
    ).await?;

    Ok(MultiWalletImportResponse { wallet_id, address })
}

/// Switch to a different wallet
#[tauri::command]
pub async fn wallets_switch(
    app: AppHandle,
    manager: State<'_, WalletManager>,
    wallet_id: String,
) -> Result<()> {
    // Ensure data dir is set
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    manager.set_data_dir(app_data_dir).await?;

    manager.switch_wallet(&wallet_id).await
}

/// Rename a wallet
#[tauri::command]
pub async fn wallets_rename(
    app: AppHandle,
    manager: State<'_, WalletManager>,
    wallet_id: String,
    new_label: String,
) -> Result<()> {
    // Ensure data dir is set
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    manager.set_data_dir(app_data_dir).await?;

    manager.rename_wallet(&wallet_id, new_label).await
}

/// Delete a wallet
#[tauri::command]
pub async fn wallets_delete(
    app: AppHandle,
    manager: State<'_, WalletManager>,
    wallet_id: String,
) -> Result<()> {
    // Ensure data dir is set
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    manager.set_data_dir(app_data_dir).await?;

    manager.delete_wallet(&wallet_id).await
}

/// Get the currently active wallet info
#[derive(Debug, Serialize)]
pub struct ActiveWalletInfo {
    pub wallet_id: Option<String>,
    pub is_unlocked: bool,
    pub wallet_count: usize,
}

#[tauri::command]
pub async fn wallets_get_active(
    app: AppHandle,
    manager: State<'_, WalletManager>,
) -> Result<ActiveWalletInfo> {
    // Ensure data dir is set
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    manager.set_data_dir(app_data_dir).await?;

    let wallet_id = manager.get_active_wallet_id().await;
    let is_unlocked = manager.is_active_unlocked().await;
    let wallet_count = manager.wallet_count().await;

    Ok(ActiveWalletInfo {
        wallet_id,
        is_unlocked,
        wallet_count,
    })
}

/// Unlock the active wallet
#[tauri::command]
pub async fn wallets_unlock_active(
    app: AppHandle,
    manager: State<'_, WalletManager>,
    password: String,
) -> Result<bool> {
    // Ensure data dir is set
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    manager.set_data_dir(app_data_dir).await?;

    manager.unlock_active(&password).await?;
    Ok(true)
}

/// Lock the active wallet
#[tauri::command]
pub async fn wallets_lock_active(
    manager: State<'_, WalletManager>,
) -> Result<()> {
    manager.lock_active().await
}

/// Migrate legacy single-wallet to multi-wallet
#[tauri::command]
pub async fn wallets_migrate_legacy(
    app: AppHandle,
    manager: State<'_, WalletManager>,
) -> Result<Option<String>> {
    // Ensure data dir is set
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    manager.set_data_dir(app_data_dir).await?;

    manager.migrate_legacy_wallet().await
}

// ============================================================================
// Watch-Only Address Commands
// ============================================================================

use crate::watch_only::{WatchOnlyManager, WatchOnlyAddress};

/// List all watch-only addresses
#[tauri::command]
pub async fn watch_only_list(
    app: AppHandle,
    manager: State<'_, WatchOnlyManager>,
) -> Result<Vec<WatchOnlyAddress>> {
    // Ensure data dir is set
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    manager.set_data_dir(app_data_dir).await?;

    Ok(manager.list_addresses().await)
}

/// Add watch-only address request
#[derive(Debug, Deserialize)]
pub struct AddWatchOnlyRequest {
    pub address: String,
    pub label: String,
    pub network: Option<String>,
    pub notes: Option<String>,
    #[serde(default)]
    pub tags: Vec<String>,
}

/// Add a watch-only address
#[tauri::command]
pub async fn watch_only_add(
    app: AppHandle,
    manager: State<'_, WatchOnlyManager>,
    request: AddWatchOnlyRequest,
) -> Result<WatchOnlyAddress> {
    // Ensure data dir is set
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    manager.set_data_dir(app_data_dir).await?;

    // Determine network from address prefix if not provided
    let network = request.network.unwrap_or_else(|| {
        if request.address.starts_with("tsynor1") {
            "testnet".to_string()
        } else {
            "mainnet".to_string()
        }
    });

    manager.add_address(
        request.address,
        request.label,
        network,
        request.notes,
        request.tags,
    ).await
}

/// Update watch-only address request
#[derive(Debug, Deserialize)]
pub struct UpdateWatchOnlyRequest {
    pub address: String,
    pub label: Option<String>,
    pub notes: Option<String>,
    pub tags: Option<Vec<String>>,
}

/// Update a watch-only address
#[tauri::command]
pub async fn watch_only_update(
    app: AppHandle,
    manager: State<'_, WatchOnlyManager>,
    request: UpdateWatchOnlyRequest,
) -> Result<WatchOnlyAddress> {
    // Ensure data dir is set
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    manager.set_data_dir(app_data_dir).await?;

    manager.update_address(
        &request.address,
        request.label,
        request.notes,
        request.tags,
    ).await
}

/// Remove a watch-only address
#[tauri::command]
pub async fn watch_only_remove(
    app: AppHandle,
    manager: State<'_, WatchOnlyManager>,
    address: String,
) -> Result<()> {
    // Ensure data dir is set
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    manager.set_data_dir(app_data_dir).await?;

    manager.remove_address(&address).await
}

/// Get a specific watch-only address
#[tauri::command]
pub async fn watch_only_get(
    app: AppHandle,
    manager: State<'_, WatchOnlyManager>,
    address: String,
) -> Result<Option<WatchOnlyAddress>> {
    // Ensure data dir is set
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    manager.set_data_dir(app_data_dir).await?;

    Ok(manager.get_address(&address).await)
}

/// Refresh balance for a watch-only address
#[tauri::command]
pub async fn watch_only_refresh_balance(
    app: AppHandle,
    manager: State<'_, WatchOnlyManager>,
    app_state: State<'_, AppState>,
    address: String,
) -> Result<u64> {
    // Ensure data dir is set
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    manager.set_data_dir(app_data_dir).await?;

    // Fetch balance from RPC
    let balance_info = app_state.rpc_client.get_balance(&address).await?;
    let balance = balance_info.balance;

    // Update cached balance
    manager.update_balance(&address, balance).await?;

    Ok(balance)
}

/// Get all unique tags
#[tauri::command]
pub async fn watch_only_get_tags(
    app: AppHandle,
    manager: State<'_, WatchOnlyManager>,
) -> Result<Vec<String>> {
    // Ensure data dir is set
    let app_data_dir = app.path().app_data_dir()
        .map_err(|e| Error::Internal(format!("Failed to get app data dir: {}", e)))?;
    manager.set_data_dir(app_data_dir).await?;

    Ok(manager.get_all_tags().await)
}

// ============================================================================
// Address & Balance Commands
// ============================================================================

/// Get all addresses in the wallet
#[tauri::command]
pub async fn get_addresses(state: State<'_, WalletState>) -> Result<Vec<WalletAddress>> {
    let addresses = state.addresses.read().await;
    Ok(addresses.clone())
}

/// Generate a new receive address
#[tauri::command]
pub async fn generate_address(
    state: State<'_, WalletState>,
    label: Option<String>,
) -> Result<WalletAddress> {
    // Use wallet state's generate_address which handles crypto properly
    state.generate_address(label, false).await
}

/// Balance response
#[derive(Debug, Serialize)]
pub struct BalanceResponse {
    /// Balance in sompi (1 SYN = 100_000_000 sompi)
    pub balance: u64,
    /// Human-readable balance
    pub balance_human: String,
    /// Pending incoming
    pub pending: u64,
}

/// Get wallet balance
#[tauri::command]
pub async fn get_balance(state: State<'_, WalletState>) -> Result<BalanceResponse> {
    // TODO: Query node for UTXOs and sum balance
    Ok(BalanceResponse {
        balance: 0,
        balance_human: "0 SYN".to_string(),
        pending: 0,
    })
}

/// UTXO response
#[derive(Debug, Serialize)]
pub struct UtxoResponse {
    pub txid: String,
    pub vout: u32,
    pub amount: u64,
    pub confirmations: u64,
}

/// Get UTXOs for the wallet
#[tauri::command]
pub async fn get_utxos(state: State<'_, WalletState>) -> Result<Vec<UtxoResponse>> {
    // TODO: Query node for UTXOs
    Ok(vec![])
}

// ============================================================================
// Transaction Commands
// ============================================================================

/// Transaction creation request
#[derive(Debug, Deserialize)]
pub struct CreateTransactionRequest {
    pub to: String,
    pub amount: u64,
    pub fee: Option<u64>,
    pub use_dilithium: bool,
}

/// Unsigned transaction response
#[derive(Debug, Serialize)]
pub struct UnsignedTransaction {
    pub tx_hex: String,
    pub fee: u64,
    pub inputs: Vec<UtxoResponse>,
}

/// Create an unsigned transaction
#[tauri::command]
pub async fn create_transaction(
    state: State<'_, WalletState>,
    request: CreateTransactionRequest,
) -> Result<UnsignedTransaction> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    // TODO: Select UTXOs, build transaction
    Err(Error::Internal("Not implemented".to_string()))
}

/// Signed transaction response
#[derive(Debug, Serialize)]
pub struct SignedTransaction {
    pub tx_hex: String,
    pub txid: String,
}

/// Sign a transaction
#[tauri::command]
pub async fn sign_transaction(
    state: State<'_, WalletState>,
    tx_hex: String,
) -> Result<SignedTransaction> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    // TODO: Sign transaction with appropriate key
    Err(Error::Internal("Not implemented".to_string()))
}

/// Broadcast response
#[derive(Debug, Serialize)]
pub struct BroadcastResponse {
    pub txid: String,
    pub accepted: bool,
}

/// Broadcast a signed transaction
#[tauri::command]
pub async fn broadcast_transaction(
    state: State<'_, WalletState>,
    tx_hex: String,
) -> Result<BroadcastResponse> {
    let connection = state.connection.read().await;
    if connection.is_none() {
        return Err(Error::Network("Not connected to node".to_string()));
    }

    // TODO: Submit transaction via RPC
    Err(Error::Internal("Not implemented".to_string()))
}

// ============================================================================
// Batch Transaction Commands
// ============================================================================

/// Batch transaction output
#[derive(Debug, Deserialize)]
pub struct BatchOutput {
    pub address: String,
    pub amount: u64, // in sompi
}

/// Batch transaction response
#[derive(Debug, Serialize)]
pub struct BatchTransactionResponse {
    pub tx_hex: String,
    pub tx_id: String,
    pub total_sent: u64,
    pub fee: u64,
    pub recipient_count: usize,
}

/// Create a batch transaction with multiple outputs
#[tauri::command]
pub async fn create_batch_transaction(
    state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    outputs: Vec<BatchOutput>,
    fee: Option<u64>,
) -> Result<BatchTransactionResponse> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    if outputs.is_empty() {
        return Err(Error::Validation("At least one output is required".to_string()));
    }

    // Validate outputs
    let mut total_amount: u64 = 0;
    for output in &outputs {
        // Validate address format
        if !output.address.starts_with("synor1") && !output.address.starts_with("tsynor1") {
            return Err(Error::Validation(format!("Invalid address: {}", output.address)));
        }
        // Validate amount
        if output.amount == 0 {
            return Err(Error::Validation("Amount must be greater than 0".to_string()));
        }
        total_amount = total_amount.checked_add(output.amount)
            .ok_or_else(|| Error::Validation("Total amount overflow".to_string()))?;
    }

    // Use provided fee or estimate (500 sompi per output + 500 base)
    let tx_fee = fee.unwrap_or_else(|| std::cmp::max(1000, outputs.len() as u64 * 500 + 500));

    // Get UTXOs for the wallet's addresses
    let addresses = state.addresses.read().await;
    let first_address = addresses.first()
        .ok_or(Error::WalletNotFound)?;
    let address = first_address.address.clone();
    drop(addresses);

    // Get balance to check if we have enough
    let balance = app_state.rpc_client.get_balance(&address).await?;
    let required = total_amount.checked_add(tx_fee)
        .ok_or_else(|| Error::Validation("Total + fee overflow".to_string()))?;

    if balance.balance < required {
        return Err(Error::InsufficientBalance {
            available: balance.balance,
            required,
        });
    }

    // Generate transaction ID (placeholder - actual implementation would build real tx)
    let tx_id = format!("batch-{:x}", std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_millis());

    // TODO: Build actual UTXO-based transaction with multiple outputs
    // For now, return a placeholder that indicates success
    // The tx_hex would be the serialized unsigned transaction
    let tx_hex = format!("0200000001{}{}{}",
        hex::encode(address.as_bytes()),
        outputs.len(),
        hex::encode(&total_amount.to_le_bytes())
    );

    Ok(BatchTransactionResponse {
        tx_hex,
        tx_id,
        total_sent: total_amount,
        fee: tx_fee,
        recipient_count: outputs.len(),
    })
}

/// Transaction history entry
#[derive(Debug, Serialize)]
pub struct TransactionHistoryEntry {
    pub txid: String,
    pub direction: String, // "sent" or "received"
    pub amount: u64,
    pub fee: Option<u64>,
    pub timestamp: i64,
    pub confirmations: u64,
    pub counterparty: Option<String>,
}

/// Get transaction history
#[tauri::command]
pub async fn get_transaction_history(
    state: State<'_, WalletState>,
    limit: Option<usize>,
) -> Result<Vec<TransactionHistoryEntry>> {
    // TODO: Query indexed transactions
    Ok(vec![])
}

// ============================================================================
// Fee Market Analytics Commands
// ============================================================================

/// Mempool statistics
#[derive(Debug, Clone, Serialize)]
pub struct MempoolStats {
    pub tx_count: u64,
    pub total_size_bytes: u64,
    pub total_fees: u64,
    pub min_fee_rate: f64,    // sompi per byte
    pub avg_fee_rate: f64,
    pub max_fee_rate: f64,
    pub percentile_10: f64,   // fee rate at 10th percentile
    pub percentile_50: f64,   // fee rate at 50th percentile (median)
    pub percentile_90: f64,   // fee rate at 90th percentile
    pub last_updated: i64,    // unix timestamp
}

/// Fee tier recommendations
#[derive(Debug, Clone, Serialize)]
pub struct FeeRecommendation {
    pub tier: String,         // "economy", "standard", "priority", "instant"
    pub fee_rate: f64,        // sompi per byte
    pub estimated_blocks: u32, // blocks until confirmation
    pub estimated_time_secs: u64, // time estimate in seconds
    pub description: String,
}

/// Fee market analytics response
#[derive(Debug, Serialize)]
pub struct FeeAnalytics {
    pub mempool: MempoolStats,
    pub recommendations: Vec<FeeRecommendation>,
    pub fee_history: Vec<FeeHistoryPoint>,
    pub network_congestion: String,  // "low", "medium", "high"
    pub block_target_time_secs: u64,
}

/// Historical fee data point
#[derive(Debug, Clone, Serialize)]
pub struct FeeHistoryPoint {
    pub timestamp: i64,
    pub avg_fee_rate: f64,
    pub min_fee_rate: f64,
    pub max_fee_rate: f64,
    pub block_height: u64,
}

/// Get mempool statistics
#[tauri::command]
pub async fn fee_get_mempool_stats(
    app_state: State<'_, AppState>,
) -> Result<MempoolStats> {
    // Try to get real mempool stats from RPC
    // For now, return simulated data
    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    // Simulate varying mempool conditions
    let seed = (now / 60) as u64; // Changes every minute
    let congestion_factor = ((seed % 100) as f64) / 100.0;

    let base_count = 50 + (congestion_factor * 200.0) as u64;
    let base_fee = 1.0 + (congestion_factor * 4.0);

    Ok(MempoolStats {
        tx_count: base_count,
        total_size_bytes: base_count * 250, // avg tx ~250 bytes
        total_fees: (base_count as f64 * base_fee * 250.0) as u64,
        min_fee_rate: base_fee * 0.5,
        avg_fee_rate: base_fee,
        max_fee_rate: base_fee * 3.0,
        percentile_10: base_fee * 0.6,
        percentile_50: base_fee,
        percentile_90: base_fee * 2.0,
        last_updated: now,
    })
}

/// Get fee recommendations for different confirmation speeds
#[tauri::command]
pub async fn fee_get_recommendations(
    app_state: State<'_, AppState>,
) -> Result<Vec<FeeRecommendation>> {
    // Get current mempool stats to base recommendations on
    let stats = fee_get_mempool_stats_internal(&app_state).await;
    let base_rate = stats.avg_fee_rate;

    Ok(vec![
        FeeRecommendation {
            tier: "economy".to_string(),
            fee_rate: (base_rate * 0.5).max(0.5),
            estimated_blocks: 10,
            estimated_time_secs: 10 * 60, // ~10 blocks
            description: "May take longer, best for non-urgent transactions".to_string(),
        },
        FeeRecommendation {
            tier: "standard".to_string(),
            fee_rate: base_rate,
            estimated_blocks: 3,
            estimated_time_secs: 3 * 60, // ~3 blocks
            description: "Recommended for normal transactions".to_string(),
        },
        FeeRecommendation {
            tier: "priority".to_string(),
            fee_rate: base_rate * 1.5,
            estimated_blocks: 1,
            estimated_time_secs: 60, // ~1 block
            description: "Faster confirmation, higher fee".to_string(),
        },
        FeeRecommendation {
            tier: "instant".to_string(),
            fee_rate: base_rate * 2.5,
            estimated_blocks: 1,
            estimated_time_secs: 30, // next block guaranteed
            description: "Highest priority, guaranteed next block".to_string(),
        },
    ])
}

/// Get full fee analytics (mempool + recommendations + history)
#[tauri::command]
pub async fn fee_get_analytics(
    app_state: State<'_, AppState>,
) -> Result<FeeAnalytics> {
    let mempool = fee_get_mempool_stats_internal(&app_state).await;
    let recommendations = fee_get_recommendations_internal(&app_state).await;
    let fee_history = fee_get_history_internal(&app_state).await;

    // Determine congestion level
    let congestion = if mempool.tx_count < 100 {
        "low"
    } else if mempool.tx_count < 200 {
        "medium"
    } else {
        "high"
    };

    Ok(FeeAnalytics {
        mempool,
        recommendations,
        fee_history,
        network_congestion: congestion.to_string(),
        block_target_time_secs: 60, // 1 minute blocks
    })
}

/// Get fee history for charting
#[tauri::command]
pub async fn fee_get_history(
    app_state: State<'_, AppState>,
    hours: Option<u32>,
) -> Result<Vec<FeeHistoryPoint>> {
    Ok(fee_get_history_internal(&app_state).await)
}

/// Calculate fee for a transaction
#[tauri::command]
pub async fn fee_calculate(
    app_state: State<'_, AppState>,
    tx_size_bytes: u64,
    tier: String,
) -> Result<u64> {
    let recommendations = fee_get_recommendations_internal(&app_state).await;

    let fee_rate = recommendations
        .iter()
        .find(|r| r.tier == tier)
        .map(|r| r.fee_rate)
        .unwrap_or(1.0);

    Ok((tx_size_bytes as f64 * fee_rate) as u64)
}

// Internal helper functions (not exported as Tauri commands)

async fn fee_get_mempool_stats_internal(app_state: &State<'_, AppState>) -> MempoolStats {
    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let seed = (now / 60) as u64;
    let congestion_factor = ((seed % 100) as f64) / 100.0;

    let base_count = 50 + (congestion_factor * 200.0) as u64;
    let base_fee = 1.0 + (congestion_factor * 4.0);

    MempoolStats {
        tx_count: base_count,
        total_size_bytes: base_count * 250,
        total_fees: (base_count as f64 * base_fee * 250.0) as u64,
        min_fee_rate: base_fee * 0.5,
        avg_fee_rate: base_fee,
        max_fee_rate: base_fee * 3.0,
        percentile_10: base_fee * 0.6,
        percentile_50: base_fee,
        percentile_90: base_fee * 2.0,
        last_updated: now,
    }
}

async fn fee_get_recommendations_internal(app_state: &State<'_, AppState>) -> Vec<FeeRecommendation> {
    let stats = fee_get_mempool_stats_internal(app_state).await;
    let base_rate = stats.avg_fee_rate;

    vec![
        FeeRecommendation {
            tier: "economy".to_string(),
            fee_rate: (base_rate * 0.5).max(0.5),
            estimated_blocks: 10,
            estimated_time_secs: 10 * 60,
            description: "May take longer, best for non-urgent transactions".to_string(),
        },
        FeeRecommendation {
            tier: "standard".to_string(),
            fee_rate: base_rate,
            estimated_blocks: 3,
            estimated_time_secs: 3 * 60,
            description: "Recommended for normal transactions".to_string(),
        },
        FeeRecommendation {
            tier: "priority".to_string(),
            fee_rate: base_rate * 1.5,
            estimated_blocks: 1,
            estimated_time_secs: 60,
            description: "Faster confirmation, higher fee".to_string(),
        },
        FeeRecommendation {
            tier: "instant".to_string(),
            fee_rate: base_rate * 2.5,
            estimated_blocks: 1,
            estimated_time_secs: 30,
            description: "Highest priority, guaranteed next block".to_string(),
        },
    ]
}

async fn fee_get_history_internal(app_state: &State<'_, AppState>) -> Vec<FeeHistoryPoint> {
    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    // Generate 24 hours of simulated fee history (hourly data points)
    (0..24)
        .rev()
        .map(|hours_ago| {
            let timestamp = now - (hours_ago * 3600);
            let seed = ((timestamp / 3600) % 100) as f64;
            let base_fee = 1.0 + (seed / 100.0 * 3.0);

            FeeHistoryPoint {
                timestamp,
                avg_fee_rate: base_fee,
                min_fee_rate: base_fee * 0.5,
                max_fee_rate: base_fee * 2.0,
                block_height: 1000000 + (24 - hours_ago) as u64 * 60,
            }
        })
        .collect()
}

// ============================================================================
// Time-Locked Vaults Commands
// ============================================================================

use std::collections::HashMap;
use tokio::sync::Mutex;
use std::sync::Arc;
use once_cell::sync::Lazy;

/// Time-locked vault data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Vault {
    pub id: String,
    pub name: String,
    pub amount: u64,           // in sompi
    pub created_at: i64,       // unix timestamp
    pub unlock_at: i64,        // unix timestamp when funds become available
    pub status: String,        // "locked", "unlocked", "withdrawn"
    pub description: Option<String>,
    pub tx_id: Option<String>, // transaction that created the vault
}

/// Vault creation request
#[derive(Debug, Deserialize)]
pub struct CreateVaultRequest {
    pub name: String,
    pub amount: u64,           // in sompi
    pub lock_duration_secs: u64,
    pub description: Option<String>,
}

/// Vault summary for dashboard
#[derive(Debug, Serialize)]
pub struct VaultSummary {
    pub total_locked: u64,
    pub total_vaults: usize,
    pub locked_vaults: usize,
    pub unlocked_vaults: usize,
    pub next_unlock: Option<i64>,
}

// In-memory vault storage (would be persisted to file in production)
static VAULTS: Lazy<Arc<Mutex<HashMap<String, Vault>>>> = Lazy::new(|| {
    Arc::new(Mutex::new(HashMap::new()))
});

/// List all vaults
#[tauri::command]
pub async fn vault_list(
    state: State<'_, WalletState>,
) -> Result<Vec<Vault>> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let vaults = VAULTS.lock().await;
    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    // Update status of vaults based on current time
    let vault_list: Vec<Vault> = vaults.values().map(|v| {
        let mut vault = v.clone();
        if vault.status == "locked" && now >= vault.unlock_at {
            vault.status = "unlocked".to_string();
        }
        vault
    }).collect();

    Ok(vault_list)
}

/// Get vault summary statistics
#[tauri::command]
pub async fn vault_get_summary(
    state: State<'_, WalletState>,
) -> Result<VaultSummary> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let vaults = VAULTS.lock().await;
    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let mut total_locked: u64 = 0;
    let mut locked_count = 0;
    let mut unlocked_count = 0;
    let mut next_unlock: Option<i64> = None;

    for vault in vaults.values() {
        if vault.status == "withdrawn" {
            continue;
        }

        if vault.status == "locked" && now < vault.unlock_at {
            total_locked += vault.amount;
            locked_count += 1;

            // Find the nearest unlock time
            if next_unlock.is_none() || vault.unlock_at < next_unlock.unwrap() {
                next_unlock = Some(vault.unlock_at);
            }
        } else {
            unlocked_count += 1;
        }
    }

    Ok(VaultSummary {
        total_locked,
        total_vaults: vaults.len(),
        locked_vaults: locked_count,
        unlocked_vaults: unlocked_count,
        next_unlock,
    })
}

/// Create a new time-locked vault
#[tauri::command]
pub async fn vault_create(
    state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    request: CreateVaultRequest,
) -> Result<Vault> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    // Validate amount
    if request.amount == 0 {
        return Err(Error::Validation("Amount must be greater than 0".to_string()));
    }

    // Validate lock duration (minimum 1 minute, maximum 10 years)
    if request.lock_duration_secs < 60 {
        return Err(Error::Validation("Lock duration must be at least 1 minute".to_string()));
    }
    if request.lock_duration_secs > 10 * 365 * 24 * 60 * 60 {
        return Err(Error::Validation("Lock duration cannot exceed 10 years".to_string()));
    }

    // Check balance
    let addresses = state.addresses.read().await;
    let first_address = addresses.first()
        .ok_or(Error::WalletNotFound)?;
    let address = first_address.address.clone();
    drop(addresses);

    let balance = app_state.rpc_client.get_balance(&address).await?;
    if balance.balance < request.amount {
        return Err(Error::InsufficientBalance {
            available: balance.balance,
            required: request.amount,
        });
    }

    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let vault_id = format!("vault-{:x}", now);

    let vault = Vault {
        id: vault_id.clone(),
        name: request.name,
        amount: request.amount,
        created_at: now,
        unlock_at: now + request.lock_duration_secs as i64,
        status: "locked".to_string(),
        description: request.description,
        tx_id: None, // Would be set after actual transaction
    };

    let mut vaults = VAULTS.lock().await;
    vaults.insert(vault_id, vault.clone());

    Ok(vault)
}

/// Get a specific vault by ID
#[tauri::command]
pub async fn vault_get(
    state: State<'_, WalletState>,
    vault_id: String,
) -> Result<Vault> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let vaults = VAULTS.lock().await;
    let vault = vaults.get(&vault_id)
        .ok_or_else(|| Error::NotFound(format!("Vault {} not found", vault_id)))?;

    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let mut result = vault.clone();
    if result.status == "locked" && now >= result.unlock_at {
        result.status = "unlocked".to_string();
    }

    Ok(result)
}

/// Withdraw funds from an unlocked vault
#[tauri::command]
pub async fn vault_withdraw(
    state: State<'_, WalletState>,
    vault_id: String,
) -> Result<String> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut vaults = VAULTS.lock().await;
    let vault = vaults.get_mut(&vault_id)
        .ok_or_else(|| Error::NotFound(format!("Vault {} not found", vault_id)))?;

    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    // Check if vault is unlocked
    if vault.status == "withdrawn" {
        return Err(Error::Validation("Vault has already been withdrawn".to_string()));
    }

    if vault.status == "locked" && now < vault.unlock_at {
        let remaining = vault.unlock_at - now;
        return Err(Error::Validation(format!(
            "Vault is still locked. {} seconds remaining",
            remaining
        )));
    }

    // Mark as withdrawn
    vault.status = "withdrawn".to_string();

    // TODO: Create actual withdrawal transaction
    let tx_id = format!("withdraw-{:x}", now);
    vault.tx_id = Some(tx_id.clone());

    Ok(tx_id)
}

/// Delete a vault (only if withdrawn or can be cancelled)
#[tauri::command]
pub async fn vault_delete(
    state: State<'_, WalletState>,
    vault_id: String,
) -> Result<()> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut vaults = VAULTS.lock().await;
    let vault = vaults.get(&vault_id)
        .ok_or_else(|| Error::NotFound(format!("Vault {} not found", vault_id)))?;

    // Only allow deletion of withdrawn vaults
    if vault.status != "withdrawn" {
        return Err(Error::Validation(
            "Can only delete withdrawn vaults. Withdraw funds first.".to_string()
        ));
    }

    vaults.remove(&vault_id);
    Ok(())
}

/// Get time until vault unlocks (in seconds)
#[tauri::command]
pub async fn vault_time_remaining(
    state: State<'_, WalletState>,
    vault_id: String,
) -> Result<i64> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let vaults = VAULTS.lock().await;
    let vault = vaults.get(&vault_id)
        .ok_or_else(|| Error::NotFound(format!("Vault {} not found", vault_id)))?;

    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let remaining = vault.unlock_at - now;
    Ok(if remaining > 0 { remaining } else { 0 })
}

// ============================================================================
// Social Recovery Commands
// ============================================================================

/// A guardian for social recovery
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Guardian {
    pub id: String,
    pub name: String,
    pub email: Option<String>,
    pub address: Option<String>,  // Synor address if they have a wallet
    pub public_key: Option<String>,
    pub added_at: i64,
    pub status: String,  // "pending", "confirmed", "revoked"
}

/// Social recovery configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RecoveryConfig {
    pub enabled: bool,
    pub threshold: u32,          // Number of guardians required
    pub total_guardians: u32,
    pub guardians: Vec<Guardian>,
    pub recovery_delay_secs: u64, // Delay before recovery completes
    pub created_at: i64,
    pub updated_at: i64,
}

/// Recovery request
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RecoveryRequest {
    pub id: String,
    pub wallet_address: String,
    pub new_owner_address: String,
    pub created_at: i64,
    pub expires_at: i64,
    pub status: String,  // "pending", "approved", "completed", "cancelled", "expired"
    pub approvals: Vec<String>,  // Guardian IDs that have approved
    pub required_approvals: u32,
}

// In-memory storage for recovery config and requests
static RECOVERY_CONFIG: Lazy<Arc<Mutex<Option<RecoveryConfig>>>> = Lazy::new(|| {
    Arc::new(Mutex::new(None))
});

static RECOVERY_REQUESTS: Lazy<Arc<Mutex<HashMap<String, RecoveryRequest>>>> = Lazy::new(|| {
    Arc::new(Mutex::new(HashMap::new()))
});

/// Get current recovery configuration
#[tauri::command]
pub async fn recovery_get_config(
    state: State<'_, WalletState>,
) -> Result<Option<RecoveryConfig>> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let config = RECOVERY_CONFIG.lock().await;
    Ok(config.clone())
}

/// Setup social recovery with guardians
#[tauri::command]
pub async fn recovery_setup(
    state: State<'_, WalletState>,
    threshold: u32,
    recovery_delay_secs: u64,
) -> Result<RecoveryConfig> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    // Validate threshold
    if threshold < 1 {
        return Err(Error::Validation("Threshold must be at least 1".to_string()));
    }

    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let config = RecoveryConfig {
        enabled: true,
        threshold,
        total_guardians: 0,
        guardians: vec![],
        recovery_delay_secs,
        created_at: now,
        updated_at: now,
    };

    let mut stored = RECOVERY_CONFIG.lock().await;
    *stored = Some(config.clone());

    Ok(config)
}

/// Add a guardian
#[tauri::command]
pub async fn recovery_add_guardian(
    state: State<'_, WalletState>,
    name: String,
    email: Option<String>,
    address: Option<String>,
) -> Result<Guardian> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut config = RECOVERY_CONFIG.lock().await;
    let config = config.as_mut()
        .ok_or_else(|| Error::Validation("Recovery not set up. Run recovery_setup first.".to_string()))?;

    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let guardian_id = format!("guardian-{:x}", now);

    let guardian = Guardian {
        id: guardian_id.clone(),
        name,
        email,
        address,
        public_key: None,  // Would be set when guardian confirms
        added_at: now,
        status: "pending".to_string(),
    };

    config.guardians.push(guardian.clone());
    config.total_guardians = config.guardians.len() as u32;
    config.updated_at = now;

    Ok(guardian)
}

/// Remove a guardian
#[tauri::command]
pub async fn recovery_remove_guardian(
    state: State<'_, WalletState>,
    guardian_id: String,
) -> Result<()> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut config = RECOVERY_CONFIG.lock().await;
    let config = config.as_mut()
        .ok_or_else(|| Error::Validation("Recovery not set up".to_string()))?;

    let index = config.guardians.iter()
        .position(|g| g.id == guardian_id)
        .ok_or_else(|| Error::NotFound(format!("Guardian {} not found", guardian_id)))?;

    config.guardians.remove(index);
    config.total_guardians = config.guardians.len() as u32;
    config.updated_at = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    Ok(())
}

/// List all guardians
#[tauri::command]
pub async fn recovery_list_guardians(
    state: State<'_, WalletState>,
) -> Result<Vec<Guardian>> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let config = RECOVERY_CONFIG.lock().await;
    match config.as_ref() {
        Some(cfg) => Ok(cfg.guardians.clone()),
        None => Ok(vec![]),
    }
}

/// Update recovery threshold
#[tauri::command]
pub async fn recovery_update_threshold(
    state: State<'_, WalletState>,
    threshold: u32,
) -> Result<RecoveryConfig> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut config = RECOVERY_CONFIG.lock().await;
    let config = config.as_mut()
        .ok_or_else(|| Error::Validation("Recovery not set up".to_string()))?;

    if threshold > config.total_guardians {
        return Err(Error::Validation(
            format!("Threshold cannot exceed number of guardians ({})", config.total_guardians)
        ));
    }

    if threshold < 1 {
        return Err(Error::Validation("Threshold must be at least 1".to_string()));
    }

    config.threshold = threshold;
    config.updated_at = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    Ok(config.clone())
}

/// Initiate a recovery request (for when wallet access is lost)
#[tauri::command]
pub async fn recovery_initiate(
    wallet_address: String,
    new_owner_address: String,
) -> Result<RecoveryRequest> {
    let config = RECOVERY_CONFIG.lock().await;
    let config = config.as_ref()
        .ok_or_else(|| Error::Validation("Recovery not configured for this wallet".to_string()))?;

    if !config.enabled {
        return Err(Error::Validation("Recovery is disabled".to_string()));
    }

    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let request_id = format!("recovery-{:x}", now);

    let request = RecoveryRequest {
        id: request_id.clone(),
        wallet_address,
        new_owner_address,
        created_at: now,
        expires_at: now + 7 * 24 * 60 * 60, // 7 day expiry
        status: "pending".to_string(),
        approvals: vec![],
        required_approvals: config.threshold,
    };

    let mut requests = RECOVERY_REQUESTS.lock().await;
    requests.insert(request_id, request.clone());

    Ok(request)
}

/// Guardian approves a recovery request
#[tauri::command]
pub async fn recovery_approve(
    request_id: String,
    guardian_id: String,
) -> Result<RecoveryRequest> {
    let config = RECOVERY_CONFIG.lock().await;
    let config = config.as_ref()
        .ok_or_else(|| Error::Validation("Recovery not configured".to_string()))?;

    // Verify guardian exists
    let guardian = config.guardians.iter()
        .find(|g| g.id == guardian_id)
        .ok_or_else(|| Error::NotFound(format!("Guardian {} not found", guardian_id)))?;

    if guardian.status != "confirmed" && guardian.status != "pending" {
        return Err(Error::Validation("Guardian is not active".to_string()));
    }

    drop(config);

    let mut requests = RECOVERY_REQUESTS.lock().await;
    let request = requests.get_mut(&request_id)
        .ok_or_else(|| Error::NotFound(format!("Recovery request {} not found", request_id)))?;

    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    // Check if expired
    if now > request.expires_at {
        request.status = "expired".to_string();
        return Err(Error::Validation("Recovery request has expired".to_string()));
    }

    // Check if already approved by this guardian
    if request.approvals.contains(&guardian_id) {
        return Err(Error::Validation("Guardian has already approved this request".to_string()));
    }

    // Add approval
    request.approvals.push(guardian_id);

    // Check if threshold met
    if request.approvals.len() >= request.required_approvals as usize {
        request.status = "approved".to_string();
    }

    Ok(request.clone())
}

/// Get a recovery request by ID
#[tauri::command]
pub async fn recovery_get_request(
    request_id: String,
) -> Result<RecoveryRequest> {
    let requests = RECOVERY_REQUESTS.lock().await;
    let request = requests.get(&request_id)
        .ok_or_else(|| Error::NotFound(format!("Recovery request {} not found", request_id)))?;
    Ok(request.clone())
}

/// List all recovery requests
#[tauri::command]
pub async fn recovery_list_requests() -> Result<Vec<RecoveryRequest>> {
    let requests = RECOVERY_REQUESTS.lock().await;
    Ok(requests.values().cloned().collect())
}

/// Cancel a recovery request
#[tauri::command]
pub async fn recovery_cancel(
    state: State<'_, WalletState>,
    request_id: String,
) -> Result<()> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut requests = RECOVERY_REQUESTS.lock().await;
    let request = requests.get_mut(&request_id)
        .ok_or_else(|| Error::NotFound(format!("Recovery request {} not found", request_id)))?;

    if request.status == "completed" {
        return Err(Error::Validation("Cannot cancel completed recovery".to_string()));
    }

    request.status = "cancelled".to_string();
    Ok(())
}

/// Disable social recovery
#[tauri::command]
pub async fn recovery_disable(
    state: State<'_, WalletState>,
) -> Result<()> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut config = RECOVERY_CONFIG.lock().await;
    if let Some(cfg) = config.as_mut() {
        cfg.enabled = false;
        cfg.updated_at = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs() as i64;
    }

    Ok(())
}

// ============================================================================
// Decoy Wallets Commands
// ============================================================================

/// A decoy wallet entry
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DecoyWallet {
    pub id: String,
    pub name: String,
    pub address: String,
    pub balance: u64,
    pub created_at: i64,
    pub last_accessed: Option<i64>,
    pub is_active: bool,
}

/// Decoy wallets configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DecoyConfig {
    pub enabled: bool,
    pub decoy_wallets: Vec<DecoyWallet>,
    pub duress_password_hash: Option<String>,  // Hash of the duress password
}

// In-memory storage for decoy config
static DECOY_CONFIG: Lazy<Arc<Mutex<Option<DecoyConfig>>>> = Lazy::new(|| {
    Arc::new(Mutex::new(None))
});

/// Check if decoy wallets feature is enabled
#[tauri::command]
pub async fn decoy_is_enabled() -> Result<bool> {
    let config = DECOY_CONFIG.lock().await;
    Ok(config.as_ref().map(|c| c.enabled).unwrap_or(false))
}

/// Setup decoy wallets
#[tauri::command]
pub async fn decoy_setup(
    state: State<'_, WalletState>,
    duress_password: String,
) -> Result<DecoyConfig> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    if duress_password.len() < 8 {
        return Err(Error::Validation("Duress password must be at least 8 characters".to_string()));
    }

    // Hash the duress password (simplified - would use proper hashing in production)
    let duress_hash = format!("{:x}", md5::compute(duress_password.as_bytes()));

    let config = DecoyConfig {
        enabled: true,
        decoy_wallets: vec![],
        duress_password_hash: Some(duress_hash),
    };

    let mut stored = DECOY_CONFIG.lock().await;
    *stored = Some(config.clone());

    Ok(config)
}

/// Create a decoy wallet
#[tauri::command]
pub async fn decoy_create(
    state: State<'_, WalletState>,
    name: String,
    initial_balance: u64,
) -> Result<DecoyWallet> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut config = DECOY_CONFIG.lock().await;
    let config = config.as_mut()
        .ok_or_else(|| Error::Validation("Decoy wallets not set up".to_string()))?;

    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let decoy_id = format!("decoy-{:x}", now);

    // Generate a fake address for the decoy
    let decoy_address = format!("synor1decoy{:x}", now);

    let decoy = DecoyWallet {
        id: decoy_id.clone(),
        name,
        address: decoy_address,
        balance: initial_balance,
        created_at: now,
        last_accessed: None,
        is_active: true,
    };

    config.decoy_wallets.push(decoy.clone());

    Ok(decoy)
}

/// List all decoy wallets
#[tauri::command]
pub async fn decoy_list(
    state: State<'_, WalletState>,
) -> Result<Vec<DecoyWallet>> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let config = DECOY_CONFIG.lock().await;
    match config.as_ref() {
        Some(c) => Ok(c.decoy_wallets.clone()),
        None => Ok(vec![]),
    }
}

/// Update decoy wallet balance
#[tauri::command]
pub async fn decoy_update_balance(
    state: State<'_, WalletState>,
    decoy_id: String,
    balance: u64,
) -> Result<DecoyWallet> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut config = DECOY_CONFIG.lock().await;
    let config = config.as_mut()
        .ok_or_else(|| Error::Validation("Decoy wallets not set up".to_string()))?;

    let decoy = config.decoy_wallets.iter_mut()
        .find(|d| d.id == decoy_id)
        .ok_or_else(|| Error::NotFound(format!("Decoy {} not found", decoy_id)))?;

    decoy.balance = balance;

    Ok(decoy.clone())
}

/// Delete a decoy wallet
#[tauri::command]
pub async fn decoy_delete(
    state: State<'_, WalletState>,
    decoy_id: String,
) -> Result<()> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut config = DECOY_CONFIG.lock().await;
    let config = config.as_mut()
        .ok_or_else(|| Error::Validation("Decoy wallets not set up".to_string()))?;

    let index = config.decoy_wallets.iter()
        .position(|d| d.id == decoy_id)
        .ok_or_else(|| Error::NotFound(format!("Decoy {} not found", decoy_id)))?;

    config.decoy_wallets.remove(index);

    Ok(())
}

/// Check if a password is the duress password (opens decoy wallets)
#[tauri::command]
pub async fn decoy_check_duress(
    password: String,
) -> Result<bool> {
    let config = DECOY_CONFIG.lock().await;

    if let Some(c) = config.as_ref() {
        if let Some(hash) = &c.duress_password_hash {
            let input_hash = format!("{:x}", md5::compute(password.as_bytes()));
            return Ok(&input_hash == hash);
        }
    }

    Ok(false)
}

/// Disable decoy wallets
#[tauri::command]
pub async fn decoy_disable(
    state: State<'_, WalletState>,
) -> Result<()> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut config = DECOY_CONFIG.lock().await;
    if let Some(c) = config.as_mut() {
        c.enabled = false;
    }

    Ok(())
}

// ============================================================================
// Network Commands
// ============================================================================

/// Connect to a Synor node
#[tauri::command]
pub async fn connect_node(
    state: State<'_, WalletState>,
    rpc_url: String,
    ws_url: Option<String>,
) -> Result<NetworkConnection> {
    // TODO: Test connection, get network info
    let network = if rpc_url.contains("testnet") || rpc_url.contains("17110") {
        "testnet"
    } else {
        "mainnet"
    };

    let connection = NetworkConnection {
        rpc_url,
        ws_url,
        connected: true,
        network: network.to_string(),
    };

    let mut conn = state.connection.write().await;
    *conn = Some(connection.clone());

    Ok(connection)
}

/// Disconnect from the current node
#[tauri::command]
pub async fn disconnect_node(state: State<'_, WalletState>) -> Result<()> {
    let mut connection = state.connection.write().await;
    *connection = None;
    Ok(())
}

/// Network status
#[derive(Debug, Serialize)]
pub struct NetworkStatus {
    pub connected: bool,
    pub network: Option<String>,
    pub block_height: Option<u64>,
    pub peer_count: Option<u32>,
    pub synced: Option<bool>,
}

/// Get network status
#[tauri::command]
pub async fn get_network_status(state: State<'_, WalletState>) -> Result<NetworkStatus> {
    let connection = state.connection.read().await;

    if let Some(conn) = connection.as_ref() {
        // TODO: Query node for actual status
        Ok(NetworkStatus {
            connected: conn.connected,
            network: Some(conn.network.clone()),
            block_height: None,
            peer_count: None,
            synced: None,
        })
    } else {
        Ok(NetworkStatus {
            connected: false,
            network: None,
            block_height: None,
            peer_count: None,
            synced: None,
        })
    }
}

// ============================================================================
// Node Management Commands
// ============================================================================

use crate::node::{ConnectionMode, NodeManager, NodeStatus, PeerInfo, SyncProgress};
use crate::rpc_client::RpcClient;
use std::path::PathBuf;
use std::sync::Arc;

/// Application state containing node manager and RPC client
pub struct AppState {
    pub node_manager: Arc<NodeManager>,
    pub rpc_client: Arc<RpcClient>,
}

/// Connect to external RPC node
#[tauri::command]
pub async fn node_connect_external(
    state: State<'_, AppState>,
    http_url: String,
    ws_url: Option<String>,
) -> Result<NodeStatus> {
    state
        .node_manager
        .connect_external(http_url, ws_url)
        .await?;

    Ok(state.node_manager.status().await)
}

/// Start embedded node (requires embedded-node feature)
#[tauri::command]
pub async fn node_start_embedded(
    state: State<'_, AppState>,
    network: String,
    data_dir: Option<String>,
    mining_enabled: bool,
    coinbase_address: Option<String>,
    mining_threads: usize,
) -> Result<NodeStatus> {
    let data_dir = data_dir.map(PathBuf::from);

    state
        .node_manager
        .start_embedded_node(
            &network,
            data_dir,
            mining_enabled,
            coinbase_address,
            mining_threads,
        )
        .await?;

    Ok(state.node_manager.status().await)
}

/// Stop the current node connection
#[tauri::command]
pub async fn node_stop(state: State<'_, AppState>) -> Result<()> {
    state.node_manager.disconnect().await
}

/// Get current node status
#[tauri::command]
pub async fn node_get_status(state: State<'_, AppState>) -> Result<NodeStatus> {
    state.node_manager.refresh_status().await
}

/// Get current connection mode
#[tauri::command]
pub async fn node_get_connection_mode(state: State<'_, AppState>) -> Result<ConnectionMode> {
    Ok(state.node_manager.connection_mode().await)
}

/// Get connected peers
#[tauri::command]
pub async fn node_get_peers(state: State<'_, AppState>) -> Result<Vec<PeerInfo>> {
    state.rpc_client.get_peers().await
}

/// Get sync progress
#[tauri::command]
pub async fn node_get_sync_progress(state: State<'_, AppState>) -> Result<SyncProgress> {
    let status = state.node_manager.status().await;

    Ok(SyncProgress {
        current_height: status.block_height,
        target_height: status.block_height, // TODO: Get from peers
        progress: status.sync_progress,
        eta_seconds: None,
        status: if status.is_syncing {
            "Syncing...".to_string()
        } else {
            "Synced".to_string()
        },
    })
}

// ============================================================================
// Mining Commands
// ============================================================================

/// Mining status
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MiningStatus {
    /// Is mining active
    pub is_mining: bool,
    /// Is mining paused
    pub is_paused: bool,
    /// Current hashrate (H/s)
    pub hashrate: f64,
    /// Blocks found in this session
    pub blocks_found: u64,
    /// Total shares submitted
    pub shares_submitted: u64,
    /// Number of mining threads
    pub threads: usize,
    /// Coinbase address for rewards
    pub coinbase_address: Option<String>,
}

/// Mining stats (more detailed)
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MiningStats {
    /// Current hashrate (H/s)
    pub hashrate: f64,
    /// Average hashrate (H/s)
    pub avg_hashrate: f64,
    /// Peak hashrate (H/s)
    pub peak_hashrate: f64,
    /// Blocks found
    pub blocks_found: u64,
    /// Rejected blocks
    pub blocks_rejected: u64,
    /// Estimated daily coins
    pub estimated_daily_coins: f64,
    /// Mining uptime in seconds
    pub uptime_seconds: u64,
    /// Per-thread hashrates
    pub thread_hashrates: Vec<f64>,
}

/// Global mining state
pub struct MiningState {
    pub is_mining: std::sync::atomic::AtomicBool,
    pub is_paused: std::sync::atomic::AtomicBool,
    pub threads: std::sync::atomic::AtomicUsize,
    pub coinbase_address: tokio::sync::RwLock<Option<String>>,
    pub blocks_found: std::sync::atomic::AtomicU64,
    pub hashrate: tokio::sync::RwLock<f64>,
}

impl MiningState {
    pub fn new() -> Self {
        MiningState {
            is_mining: std::sync::atomic::AtomicBool::new(false),
            is_paused: std::sync::atomic::AtomicBool::new(false),
            threads: std::sync::atomic::AtomicUsize::new(0),
            coinbase_address: tokio::sync::RwLock::new(None),
            blocks_found: std::sync::atomic::AtomicU64::new(0),
            hashrate: tokio::sync::RwLock::new(0.0),
        }
    }
}

impl Default for MiningState {
    fn default() -> Self {
        Self::new()
    }
}

/// Start mining
#[tauri::command]
pub async fn mining_start(
    app_state: State<'_, AppState>,
    mining_state: State<'_, MiningState>,
    coinbase_address: String,
    threads: usize,
) -> Result<MiningStatus> {
    use std::sync::atomic::Ordering;

    // Verify we're connected to a node
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // Store mining configuration
    *mining_state.coinbase_address.write().await = Some(coinbase_address.clone());
    mining_state.threads.store(threads, Ordering::SeqCst);
    mining_state.is_mining.store(true, Ordering::SeqCst);
    mining_state.is_paused.store(false, Ordering::SeqCst);

    // TODO: Actually start mining via embedded node or external RPC
    // For embedded node with mining feature:
    // if let Some(node) = app_state.node_manager.embedded_node().await {
    //     node.miner().start().await?;
    // }

    Ok(MiningStatus {
        is_mining: true,
        is_paused: false,
        hashrate: 0.0,
        blocks_found: 0,
        shares_submitted: 0,
        threads,
        coinbase_address: Some(coinbase_address),
    })
}

/// Stop mining
#[tauri::command]
pub async fn mining_stop(
    mining_state: State<'_, MiningState>,
) -> Result<()> {
    use std::sync::atomic::Ordering;

    mining_state.is_mining.store(false, Ordering::SeqCst);
    mining_state.is_paused.store(false, Ordering::SeqCst);
    *mining_state.hashrate.write().await = 0.0;

    // TODO: Actually stop mining

    Ok(())
}

/// Pause mining
#[tauri::command]
pub async fn mining_pause(
    mining_state: State<'_, MiningState>,
) -> Result<()> {
    use std::sync::atomic::Ordering;

    if !mining_state.is_mining.load(Ordering::SeqCst) {
        return Err(Error::MiningError("Mining is not active".to_string()));
    }

    mining_state.is_paused.store(true, Ordering::SeqCst);

    Ok(())
}

/// Resume mining
#[tauri::command]
pub async fn mining_resume(
    mining_state: State<'_, MiningState>,
) -> Result<()> {
    use std::sync::atomic::Ordering;

    if !mining_state.is_mining.load(Ordering::SeqCst) {
        return Err(Error::MiningError("Mining is not active".to_string()));
    }

    mining_state.is_paused.store(false, Ordering::SeqCst);

    Ok(())
}

/// Get mining status
#[tauri::command]
pub async fn mining_get_status(
    mining_state: State<'_, MiningState>,
) -> Result<MiningStatus> {
    use std::sync::atomic::Ordering;

    Ok(MiningStatus {
        is_mining: mining_state.is_mining.load(Ordering::SeqCst),
        is_paused: mining_state.is_paused.load(Ordering::SeqCst),
        hashrate: *mining_state.hashrate.read().await,
        blocks_found: mining_state.blocks_found.load(Ordering::SeqCst),
        shares_submitted: 0,
        threads: mining_state.threads.load(Ordering::SeqCst),
        coinbase_address: mining_state.coinbase_address.read().await.clone(),
    })
}

/// Get detailed mining stats
#[tauri::command]
pub async fn mining_get_stats(
    mining_state: State<'_, MiningState>,
) -> Result<MiningStats> {
    use std::sync::atomic::Ordering;

    let hashrate = *mining_state.hashrate.read().await;
    let threads = mining_state.threads.load(Ordering::SeqCst);

    Ok(MiningStats {
        hashrate,
        avg_hashrate: hashrate,
        peak_hashrate: hashrate,
        blocks_found: mining_state.blocks_found.load(Ordering::SeqCst),
        blocks_rejected: 0,
        estimated_daily_coins: 0.0, // TODO: Calculate based on network difficulty
        uptime_seconds: 0,
        thread_hashrates: vec![hashrate / threads.max(1) as f64; threads],
    })
}

/// Set mining threads
#[tauri::command]
pub async fn mining_set_threads(
    mining_state: State<'_, MiningState>,
    threads: usize,
) -> Result<()> {
    use std::sync::atomic::Ordering;

    if threads == 0 {
        return Err(Error::MiningError("Threads must be greater than 0".to_string()));
    }

    mining_state.threads.store(threads, Ordering::SeqCst);

    // TODO: Actually adjust mining threads

    Ok(())
}

// ============================================================================
// Enhanced Wallet Commands (using RPC client)
// ============================================================================

/// Get balance using RPC client
#[tauri::command]
pub async fn wallet_get_balance(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
) -> Result<BalanceResponse> {
    let addresses = wallet_state.addresses.read().await;
    if addresses.is_empty() {
        return Ok(BalanceResponse {
            balance: 0,
            balance_human: "0 SYN".to_string(),
            pending: 0,
        });
    }

    let mut total_balance: u64 = 0;

    for addr in addresses.iter() {
        match app_state.rpc_client.get_balance(&addr.address).await {
            Ok(balance) => {
                total_balance += balance.balance;
            }
            Err(e) => {
                tracing::warn!("Failed to get balance for {}: {}", addr.address, e);
            }
        }
    }

    // Convert sompi to SYN (1 SYN = 100_000_000 sompi)
    let syn = total_balance as f64 / 100_000_000.0;
    let balance_human = format!("{:.8} SYN", syn);

    Ok(BalanceResponse {
        balance: total_balance,
        balance_human,
        pending: 0, // TODO: Track pending transactions
    })
}

/// Get UTXOs using RPC client
#[tauri::command]
pub async fn wallet_get_utxos(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
) -> Result<Vec<crate::rpc_client::Utxo>> {
    let addresses = wallet_state.addresses.read().await;
    let mut all_utxos = Vec::new();

    for addr in addresses.iter() {
        match app_state.rpc_client.get_utxos(&addr.address).await {
            Ok(utxos) => {
                all_utxos.extend(utxos);
            }
            Err(e) => {
                tracing::warn!("Failed to get UTXOs for {}: {}", addr.address, e);
            }
        }
    }

    Ok(all_utxos)
}

/// Get network info using RPC client
#[tauri::command]
pub async fn wallet_get_network_info(
    app_state: State<'_, AppState>,
) -> Result<crate::rpc_client::NetworkInfo> {
    app_state.rpc_client.get_network_info().await
}

/// Get fee estimate using RPC client
#[tauri::command]
pub async fn wallet_get_fee_estimate(
    app_state: State<'_, AppState>,
) -> Result<crate::rpc_client::FeeEstimate> {
    app_state.rpc_client.get_fee_estimate().await
}

// ============================================================================
// Smart Contract Commands
// ============================================================================

/// Contract deployment request
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DeployContractRequest {
    /// Contract bytecode (hex)
    pub bytecode: String,
    /// Constructor arguments (encoded)
    pub constructor_args: Option<String>,
    /// Gas limit
    pub gas_limit: u64,
    /// Initial value to send (in sompi)
    pub value: u64,
}

/// Contract deployment response
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DeployContractResponse {
    /// Transaction ID
    pub tx_id: String,
    /// Contract address (available after confirmation)
    pub contract_address: Option<String>,
    /// Gas used
    pub gas_used: u64,
}

/// Deploy a smart contract
#[tauri::command]
pub async fn contract_deploy(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    request: DeployContractRequest,
) -> Result<DeployContractResponse> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: Build and sign contract deployment transaction
    // 1. Create transaction with contract bytecode in payload
    // 2. Sign with wallet key
    // 3. Broadcast to network

    // For now, return a placeholder
    Ok(DeployContractResponse {
        tx_id: "pending".to_string(),
        contract_address: None,
        gas_used: 0,
    })
}

/// Contract call request
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CallContractRequest {
    /// Contract address
    pub contract_address: String,
    /// Method to call (encoded)
    pub method: String,
    /// Arguments (encoded)
    pub args: Option<String>,
    /// Gas limit
    pub gas_limit: u64,
    /// Value to send (in sompi)
    pub value: u64,
}

/// Contract call response
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CallContractResponse {
    /// Transaction ID (for state-changing calls)
    pub tx_id: Option<String>,
    /// Return data (for view calls)
    pub result: Option<String>,
    /// Gas used
    pub gas_used: u64,
}

/// Call a smart contract method
#[tauri::command]
pub async fn contract_call(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    request: CallContractRequest,
) -> Result<CallContractResponse> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: Build and execute contract call
    Ok(CallContractResponse {
        tx_id: None,
        result: None,
        gas_used: 0,
    })
}

/// Contract read request (view function, no transaction needed)
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ReadContractRequest {
    /// Contract address
    pub contract_address: String,
    /// Method to call (encoded)
    pub method: String,
    /// Arguments (encoded)
    pub args: Option<String>,
}

/// Read from a smart contract (view function)
#[tauri::command]
pub async fn contract_read(
    app_state: State<'_, AppState>,
    request: ReadContractRequest,
) -> Result<String> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: Execute view call via RPC
    Ok("0x".to_string())
}

/// Contract info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ContractInfo {
    /// Contract address
    pub address: String,
    /// Contract name (if known)
    pub name: Option<String>,
    /// Contract type (e.g., "ERC20", "Custom")
    pub contract_type: String,
    /// Deployment transaction ID
    pub deploy_tx_id: String,
    /// Creation timestamp
    pub created_at: i64,
}

/// Get contract information
#[tauri::command]
pub async fn contract_get_info(
    app_state: State<'_, AppState>,
    address: String,
) -> Result<ContractInfo> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: Query contract info from node
    Ok(ContractInfo {
        address,
        name: None,
        contract_type: "Unknown".to_string(),
        deploy_tx_id: "".to_string(),
        created_at: 0,
    })
}

// ============================================================================
// Token Commands
// ============================================================================

/// Token creation request
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateTokenRequest {
    /// Token name
    pub name: String,
    /// Token symbol (e.g., "SYN")
    pub symbol: String,
    /// Decimal places (usually 8 or 18)
    pub decimals: u8,
    /// Initial supply (in smallest units)
    pub initial_supply: String,
    /// Maximum supply (optional, for capped tokens)
    pub max_supply: Option<String>,
    /// Is mintable (can create more tokens later)
    pub mintable: bool,
    /// Is burnable (can destroy tokens)
    pub burnable: bool,
    /// Is pausable (can pause transfers)
    pub pausable: bool,
}

/// Token creation response
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateTokenResponse {
    /// Deployment transaction ID
    pub tx_id: String,
    /// Token contract address (available after confirmation)
    pub token_address: Option<String>,
    /// Token ID (unique identifier)
    pub token_id: String,
}

/// Create a new token
#[tauri::command]
pub async fn token_create(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    request: CreateTokenRequest,
) -> Result<CreateTokenResponse> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // Validate token parameters
    if request.name.is_empty() || request.name.len() > 64 {
        return Err(Error::Validation("Token name must be 1-64 characters".to_string()));
    }
    if request.symbol.is_empty() || request.symbol.len() > 8 {
        return Err(Error::Validation("Token symbol must be 1-8 characters".to_string()));
    }
    if request.decimals > 18 {
        return Err(Error::Validation("Decimals must be 0-18".to_string()));
    }

    // TODO: Deploy standard token contract
    // 1. Use pre-compiled token contract bytecode
    // 2. Encode constructor args (name, symbol, decimals, supply, etc.)
    // 3. Deploy contract
    // 4. Return token address

    let token_id = format!(
        "{}:{}",
        request.symbol.to_uppercase(),
        hex::encode([0u8; 4]) // Placeholder
    );

    Ok(CreateTokenResponse {
        tx_id: "pending".to_string(),
        token_address: None,
        token_id,
    })
}

/// Token information
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TokenInfo {
    /// Token contract address
    pub address: String,
    /// Token name
    pub name: String,
    /// Token symbol
    pub symbol: String,
    /// Decimal places
    pub decimals: u8,
    /// Total supply
    pub total_supply: String,
    /// Maximum supply (if capped)
    pub max_supply: Option<String>,
    /// Your balance
    pub balance: String,
    /// Is verified/trusted
    pub is_verified: bool,
    /// Logo URL (if available)
    pub logo_url: Option<String>,
}

/// Get token information
#[tauri::command]
pub async fn token_get_info(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    token_address: String,
) -> Result<TokenInfo> {
    let _wallet_state = wallet_state; // Silence unused warning
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: Query token contract for info
    // Call name(), symbol(), decimals(), totalSupply(), balanceOf(user)

    Ok(TokenInfo {
        address: token_address,
        name: "Unknown Token".to_string(),
        symbol: "???".to_string(),
        decimals: 8,
        total_supply: "0".to_string(),
        max_supply: None,
        balance: "0".to_string(),
        is_verified: false,
        logo_url: None,
    })
}

/// Token transfer request
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TransferTokenRequest {
    /// Token contract address
    pub token_address: String,
    /// Recipient address
    pub to: String,
    /// Amount to transfer (in smallest units)
    pub amount: String,
}

/// Transfer tokens
#[tauri::command]
pub async fn token_transfer(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    request: TransferTokenRequest,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _request = request; // Silence unused warning

    // TODO: Call token contract's transfer(to, amount) function
    // 1. Encode transfer function call
    // 2. Build and sign transaction
    // 3. Broadcast

    Ok("pending".to_string())
}

/// Get token balance for an address
#[tauri::command]
pub async fn token_get_balance(
    app_state: State<'_, AppState>,
    token_address: String,
    owner_address: String,
) -> Result<String> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_token_address, _owner_address) = (token_address, owner_address); // Silence unused

    // TODO: Call token contract's balanceOf(owner) function
    Ok("0".to_string())
}

/// List tokens held by wallet
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TokenBalance {
    /// Token address
    pub address: String,
    /// Token name
    pub name: String,
    /// Token symbol
    pub symbol: String,
    /// Decimals
    pub decimals: u8,
    /// Balance in smallest units
    pub balance: String,
    /// Balance formatted (e.g., "1,000.00")
    pub balance_formatted: String,
    /// USD value (if available)
    pub usd_value: Option<f64>,
}

/// Get all token balances for the wallet
#[tauri::command]
pub async fn token_list_balances(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
) -> Result<Vec<TokenBalance>> {
    let _wallet_state = wallet_state; // Silence unused warning
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: Query indexed token transfers to find held tokens
    // Then query each token's balance

    Ok(vec![])
}

/// Mint tokens (if authorized)
#[tauri::command]
pub async fn token_mint(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    token_address: String,
    to: String,
    amount: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_token_address, _to, _amount) = (token_address, to, amount); // Silence unused

    // TODO: Call token contract's mint(to, amount) function
    Ok("pending".to_string())
}

/// Burn tokens
#[tauri::command]
pub async fn token_burn(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    token_address: String,
    amount: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_token_address, _amount) = (token_address, amount); // Silence unused

    // TODO: Call token contract's burn(amount) function
    Ok("pending".to_string())
}

// ============================================================================
// NFT (Non-Fungible Token) Commands
// ============================================================================

/// NFT Collection creation request
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateNftCollectionRequest {
    /// Collection name
    pub name: String,
    /// Collection symbol
    pub symbol: String,
    /// Base URI for token metadata
    pub base_uri: String,
    /// Maximum supply (0 for unlimited)
    pub max_supply: u64,
    /// Royalty percentage (in basis points, e.g., 250 = 2.5%)
    pub royalty_bps: u16,
    /// Whether the collection is soulbound (non-transferable)
    pub soulbound: bool,
}

/// NFT Collection creation response
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateNftCollectionResponse {
    /// Transaction ID
    pub tx_hash: String,
    /// Collection contract address
    pub collection_address: String,
}

/// Create a new NFT collection (deploy NFT contract)
#[tauri::command]
pub async fn nft_create_collection(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    request: CreateNftCollectionRequest,
) -> Result<CreateNftCollectionResponse> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // Validate inputs
    if request.name.is_empty() {
        return Err(Error::Validation("Collection name is required".to_string()));
    }
    if request.symbol.is_empty() {
        return Err(Error::Validation("Collection symbol is required".to_string()));
    }
    if request.royalty_bps > 10000 {
        return Err(Error::Validation("Royalty cannot exceed 100%".to_string()));
    }

    // Silence unused for now
    let _request = request;

    // TODO: Deploy NFT collection contract
    // 1. Compile NFT contract with parameters
    // 2. Deploy contract
    // 3. Return contract address

    Ok(CreateNftCollectionResponse {
        tx_hash: "pending".to_string(),
        collection_address: "pending".to_string(),
    })
}

/// NFT Collection info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NftCollectionInfo {
    /// Collection contract address
    pub address: String,
    /// Collection name
    pub name: String,
    /// Collection symbol
    pub symbol: String,
    /// Base URI for metadata
    pub base_uri: String,
    /// Total supply minted
    pub total_supply: u64,
    /// Maximum supply (0 if unlimited)
    pub max_supply: u64,
    /// Royalty in basis points
    pub royalty_bps: u16,
    /// Owner/creator address
    pub owner: String,
    /// Whether tokens are soulbound
    pub soulbound: bool,
}

/// Get NFT collection info
#[tauri::command]
pub async fn nft_get_collection_info(
    app_state: State<'_, AppState>,
    collection_address: String,
) -> Result<NftCollectionInfo> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _collection_address = collection_address; // Silence unused

    // TODO: Query NFT contract for collection info
    Ok(NftCollectionInfo {
        address: "".to_string(),
        name: "".to_string(),
        symbol: "".to_string(),
        base_uri: "".to_string(),
        total_supply: 0,
        max_supply: 0,
        royalty_bps: 0,
        owner: "".to_string(),
        soulbound: false,
    })
}

/// NFT mint request
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MintNftRequest {
    /// Collection contract address
    pub collection_address: String,
    /// Recipient address
    pub to: String,
    /// Token URI (metadata URL)
    pub token_uri: String,
    /// Optional attributes as JSON
    pub attributes: Option<String>,
}

/// NFT mint response
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MintNftResponse {
    /// Transaction ID
    pub tx_hash: String,
    /// Minted token ID
    pub token_id: String,
}

/// Mint a new NFT in a collection
#[tauri::command]
pub async fn nft_mint(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    request: MintNftRequest,
) -> Result<MintNftResponse> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    if request.collection_address.is_empty() {
        return Err(Error::Validation("Collection address is required".to_string()));
    }
    if request.to.is_empty() {
        return Err(Error::Validation("Recipient address is required".to_string()));
    }

    let _request = request; // Silence unused

    // TODO: Call NFT contract's mint function
    Ok(MintNftResponse {
        tx_hash: "pending".to_string(),
        token_id: "0".to_string(),
    })
}

/// Batch mint multiple NFTs
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BatchMintNftRequest {
    /// Collection contract address
    pub collection_address: String,
    /// Recipient address
    pub to: String,
    /// List of token URIs
    pub token_uris: Vec<String>,
}

/// Batch mint NFTs
#[tauri::command]
pub async fn nft_batch_mint(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    request: BatchMintNftRequest,
) -> Result<Vec<MintNftResponse>> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    if request.token_uris.is_empty() {
        return Err(Error::Validation("At least one token URI is required".to_string()));
    }
    if request.token_uris.len() > 100 {
        return Err(Error::Validation("Cannot mint more than 100 NFTs at once".to_string()));
    }

    let _request = request; // Silence unused

    // TODO: Batch mint NFTs
    Ok(vec![])
}

/// NFT token info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NftTokenInfo {
    /// Token ID
    pub token_id: String,
    /// Collection address
    pub collection_address: String,
    /// Current owner
    pub owner: String,
    /// Token URI (metadata URL)
    pub token_uri: String,
    /// Token name (from metadata)
    pub name: Option<String>,
    /// Token description (from metadata)
    pub description: Option<String>,
    /// Token image URL (from metadata)
    pub image: Option<String>,
    /// Token attributes (from metadata)
    pub attributes: Option<String>,
}

/// Get NFT token info
#[tauri::command]
pub async fn nft_get_token_info(
    app_state: State<'_, AppState>,
    collection_address: String,
    token_id: String,
) -> Result<NftTokenInfo> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_collection_address, _token_id) = (collection_address, token_id); // Silence unused

    // TODO: Query NFT contract for token info
    Ok(NftTokenInfo {
        token_id: "".to_string(),
        collection_address: "".to_string(),
        owner: "".to_string(),
        token_uri: "".to_string(),
        name: None,
        description: None,
        image: None,
        attributes: None,
    })
}

/// Transfer an NFT
#[tauri::command]
pub async fn nft_transfer(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    collection_address: String,
    token_id: String,
    to: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    if to.is_empty() {
        return Err(Error::Validation("Recipient address is required".to_string()));
    }

    let (_collection_address, _token_id, _to) = (collection_address, token_id, to); // Silence unused

    // TODO: Call NFT contract's transferFrom function
    Ok("pending".to_string())
}

/// Burn an NFT
#[tauri::command]
pub async fn nft_burn(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    collection_address: String,
    token_id: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_collection_address, _token_id) = (collection_address, token_id); // Silence unused

    // TODO: Call NFT contract's burn function
    Ok("pending".to_string())
}

/// List NFTs owned by an address
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OwnedNft {
    /// Collection address
    pub collection_address: String,
    /// Collection name
    pub collection_name: String,
    /// Collection symbol
    pub collection_symbol: String,
    /// Token ID
    pub token_id: String,
    /// Token URI
    pub token_uri: String,
    /// Token name (from metadata)
    pub name: Option<String>,
    /// Token image (from metadata)
    pub image: Option<String>,
}

/// Get all NFTs owned by an address
#[tauri::command]
pub async fn nft_list_owned(
    app_state: State<'_, AppState>,
    owner: String,
) -> Result<Vec<OwnedNft>> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _owner = owner; // Silence unused

    // TODO: Query blockchain for all NFTs owned by address
    Ok(vec![])
}

/// Get NFTs in a specific collection owned by an address
#[tauri::command]
pub async fn nft_list_owned_in_collection(
    app_state: State<'_, AppState>,
    collection_address: String,
    owner: String,
) -> Result<Vec<OwnedNft>> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_collection_address, _owner) = (collection_address, owner); // Silence unused

    // TODO: Query NFT contract for tokens owned by address
    Ok(vec![])
}

/// Set approval for an operator to manage NFTs
#[tauri::command]
pub async fn nft_set_approval_for_all(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    collection_address: String,
    operator: String,
    approved: bool,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_collection_address, _operator, _approved) = (collection_address, operator, approved);

    // TODO: Call NFT contract's setApprovalForAll function
    Ok("pending".to_string())
}

/// Update collection base URI (owner only)
#[tauri::command]
pub async fn nft_set_base_uri(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    collection_address: String,
    base_uri: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_collection_address, _base_uri) = (collection_address, base_uri);

    // TODO: Call NFT contract's setBaseURI function
    Ok("pending".to_string())
}

// ============================================================================
// Staking Commands
// ============================================================================

/// Staking pool info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StakingPoolInfo {
    /// Pool address
    pub pool_address: String,
    /// Pool name
    pub name: String,
    /// Total staked amount
    pub total_staked: String,
    /// Annual percentage yield (APY) in basis points
    pub apy_bps: u32,
    /// Minimum stake amount
    pub min_stake: String,
    /// Lock period in seconds (0 for flexible)
    pub lock_period: u64,
    /// Whether pool is active
    pub is_active: bool,
}

/// User's stake info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UserStakeInfo {
    /// Pool address
    pub pool_address: String,
    /// Staked amount
    pub staked_amount: String,
    /// Pending rewards
    pub pending_rewards: String,
    /// Stake timestamp
    pub staked_at: u64,
    /// Unlock timestamp (0 if already unlocked)
    pub unlock_at: u64,
}

/// Get available staking pools
#[tauri::command]
pub async fn staking_get_pools(
    app_state: State<'_, AppState>,
) -> Result<Vec<StakingPoolInfo>> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: Query staking contract for pools
    Ok(vec![
        StakingPoolInfo {
            pool_address: "synor1staking...".to_string(),
            name: "Flexible Staking".to_string(),
            total_staked: "1000000000000".to_string(),
            apy_bps: 500, // 5%
            min_stake: "100000000".to_string(),
            lock_period: 0,
            is_active: true,
        },
        StakingPoolInfo {
            pool_address: "synor1staking30...".to_string(),
            name: "30-Day Lock".to_string(),
            total_staked: "5000000000000".to_string(),
            apy_bps: 1000, // 10%
            min_stake: "100000000".to_string(),
            lock_period: 2592000, // 30 days
            is_active: true,
        },
    ])
}

/// Get user's stake info
#[tauri::command]
pub async fn staking_get_user_stakes(
    app_state: State<'_, AppState>,
    address: String,
) -> Result<Vec<UserStakeInfo>> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _address = address;
    // TODO: Query staking contract for user stakes
    Ok(vec![])
}

/// Stake tokens
#[tauri::command]
pub async fn staking_stake(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    pool_address: String,
    amount: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_pool_address, _amount) = (pool_address, amount);
    // TODO: Call staking contract's stake function
    Ok("pending".to_string())
}

/// Unstake tokens
#[tauri::command]
pub async fn staking_unstake(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    pool_address: String,
    amount: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_pool_address, _amount) = (pool_address, amount);
    // TODO: Call staking contract's unstake function
    Ok("pending".to_string())
}

/// Claim staking rewards
#[tauri::command]
pub async fn staking_claim_rewards(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    pool_address: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _pool_address = pool_address;
    // TODO: Call staking contract's claim function
    Ok("pending".to_string())
}

// ============================================================================
// DEX/Swap Commands
// ============================================================================

/// Swap quote
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SwapQuote {
    /// Input token address (empty for native)
    pub token_in: String,
    /// Output token address (empty for native)
    pub token_out: String,
    /// Input amount
    pub amount_in: String,
    /// Expected output amount
    pub amount_out: String,
    /// Minimum output (with slippage)
    pub amount_out_min: String,
    /// Price impact percentage (basis points)
    pub price_impact_bps: u32,
    /// Route path
    pub route: Vec<String>,
    /// Estimated gas
    pub estimated_gas: u64,
}

/// Liquidity pool info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LiquidityPoolInfo {
    /// Pool address
    pub pool_address: String,
    /// Token A address
    pub token_a: String,
    /// Token B address
    pub token_b: String,
    /// Token A symbol
    pub symbol_a: String,
    /// Token B symbol
    pub symbol_b: String,
    /// Reserve A
    pub reserve_a: String,
    /// Reserve B
    pub reserve_b: String,
    /// Total LP tokens
    pub total_supply: String,
    /// Fee in basis points
    pub fee_bps: u32,
}

/// Get swap quote
#[tauri::command]
pub async fn swap_get_quote(
    app_state: State<'_, AppState>,
    token_in: String,
    token_out: String,
    amount_in: String,
    slippage_bps: u32,
) -> Result<SwapQuote> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_token_in, _token_out, _amount_in, _slippage_bps) = (token_in.clone(), token_out.clone(), amount_in.clone(), slippage_bps);

    // TODO: Query DEX for quote
    Ok(SwapQuote {
        token_in,
        token_out,
        amount_in: amount_in.clone(),
        amount_out: amount_in, // Placeholder
        amount_out_min: "0".to_string(),
        price_impact_bps: 0,
        route: vec![],
        estimated_gas: 100000,
    })
}

/// Execute swap
#[tauri::command]
pub async fn swap_execute(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    token_in: String,
    token_out: String,
    amount_in: String,
    amount_out_min: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_token_in, _token_out, _amount_in, _amount_out_min) = (token_in, token_out, amount_in, amount_out_min);
    // TODO: Execute swap on DEX
    Ok("pending".to_string())
}

/// Get liquidity pools
#[tauri::command]
pub async fn swap_get_pools(
    app_state: State<'_, AppState>,
) -> Result<Vec<LiquidityPoolInfo>> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: Query DEX for pools
    Ok(vec![])
}

/// Add liquidity
#[tauri::command]
pub async fn swap_add_liquidity(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    token_a: String,
    token_b: String,
    amount_a: String,
    amount_b: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_token_a, _token_b, _amount_a, _amount_b) = (token_a, token_b, amount_a, amount_b);
    // TODO: Add liquidity to DEX pool
    Ok("pending".to_string())
}

/// Remove liquidity
#[tauri::command]
pub async fn swap_remove_liquidity(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    pool_address: String,
    lp_amount: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_pool_address, _lp_amount) = (pool_address, lp_amount);
    // TODO: Remove liquidity from DEX pool
    Ok("pending".to_string())
}

// ============================================================================
// Address Book Commands
// ============================================================================

/// Address book entry
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AddressBookEntry {
    /// Unique ID
    pub id: String,
    /// Display name
    pub name: String,
    /// Address
    pub address: String,
    /// Optional notes
    pub notes: Option<String>,
    /// Tags for categorization
    pub tags: Vec<String>,
    /// Created timestamp
    pub created_at: u64,
}

/// Address book state (in-memory, persisted by frontend)
static ADDRESS_BOOK: std::sync::LazyLock<tokio::sync::RwLock<Vec<AddressBookEntry>>> =
    std::sync::LazyLock::new(|| tokio::sync::RwLock::new(Vec::new()));

/// Get all address book entries
#[tauri::command]
pub async fn addressbook_get_all() -> Result<Vec<AddressBookEntry>> {
    let entries = ADDRESS_BOOK.read().await;
    Ok(entries.clone())
}

/// Add address book entry
#[tauri::command]
pub async fn addressbook_add(
    name: String,
    address: String,
    notes: Option<String>,
    tags: Vec<String>,
) -> Result<AddressBookEntry> {
    let entry = AddressBookEntry {
        id: uuid::Uuid::new_v4().to_string(),
        name,
        address,
        notes,
        tags,
        created_at: std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs(),
    };

    let mut entries = ADDRESS_BOOK.write().await;
    entries.push(entry.clone());
    Ok(entry)
}

/// Update address book entry
#[tauri::command]
pub async fn addressbook_update(
    id: String,
    name: String,
    address: String,
    notes: Option<String>,
    tags: Vec<String>,
) -> Result<AddressBookEntry> {
    let mut entries = ADDRESS_BOOK.write().await;
    if let Some(entry) = entries.iter_mut().find(|e| e.id == id) {
        entry.name = name;
        entry.address = address;
        entry.notes = notes;
        entry.tags = tags;
        Ok(entry.clone())
    } else {
        Err(Error::Validation("Entry not found".to_string()))
    }
}

/// Delete address book entry
#[tauri::command]
pub async fn addressbook_delete(id: String) -> Result<()> {
    let mut entries = ADDRESS_BOOK.write().await;
    entries.retain(|e| e.id != id);
    Ok(())
}

// ============================================================================
// Price/Market Data Commands
// ============================================================================

/// Token price info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TokenPriceInfo {
    /// Token symbol
    pub symbol: String,
    /// Price in USD
    pub price_usd: f64,
    /// 24h change percentage
    pub change_24h: f64,
    /// 24h volume
    pub volume_24h: f64,
    /// Market cap
    pub market_cap: f64,
}

/// Price history point
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PriceHistoryPoint {
    /// Timestamp
    pub timestamp: u64,
    /// Price
    pub price: f64,
}

/// Get token prices
#[tauri::command]
pub async fn market_get_prices(
    symbols: Vec<String>,
) -> Result<Vec<TokenPriceInfo>> {
    // TODO: Fetch from price oracle or external API
    Ok(symbols
        .into_iter()
        .map(|symbol| TokenPriceInfo {
            symbol,
            price_usd: 0.0,
            change_24h: 0.0,
            volume_24h: 0.0,
            market_cap: 0.0,
        })
        .collect())
}

/// Get price history
#[tauri::command]
pub async fn market_get_history(
    symbol: String,
    interval: String, // "1h", "1d", "1w", "1m"
    limit: u32,
) -> Result<Vec<PriceHistoryPoint>> {
    let (_symbol, _interval, _limit) = (symbol, interval, limit);
    // TODO: Fetch price history
    Ok(vec![])
}

// ============================================================================
// Multi-sig Wallet Commands
// ============================================================================

/// Multi-sig wallet info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MultisigWalletInfo {
    /// Wallet address
    pub address: String,
    /// Wallet name
    pub name: String,
    /// Required signatures
    pub threshold: u32,
    /// Owner addresses
    pub owners: Vec<String>,
    /// Pending transaction count
    pub pending_tx_count: u32,
    /// Balance
    pub balance: String,
}

/// Pending multi-sig transaction
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PendingMultisigTx {
    /// Transaction ID
    pub tx_id: String,
    /// Destination
    pub to: String,
    /// Value
    pub value: String,
    /// Data (for contract calls)
    pub data: Option<String>,
    /// Current signatures
    pub signatures: Vec<String>,
    /// Required signatures
    pub threshold: u32,
    /// Proposer
    pub proposer: String,
    /// Proposed at
    pub proposed_at: u64,
}

/// Create multi-sig wallet
#[tauri::command]
pub async fn multisig_create(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    name: String,
    owners: Vec<String>,
    threshold: u32,
) -> Result<MultisigWalletInfo> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    if threshold == 0 || threshold as usize > owners.len() {
        return Err(Error::Validation("Invalid threshold".to_string()));
    }

    let (_name, _owners, _threshold) = (name.clone(), owners.clone(), threshold);
    // TODO: Deploy multi-sig contract
    Ok(MultisigWalletInfo {
        address: "synor1multisig...".to_string(),
        name,
        threshold,
        owners,
        pending_tx_count: 0,
        balance: "0".to_string(),
    })
}

/// Get multi-sig wallet info
#[tauri::command]
pub async fn multisig_get_info(
    app_state: State<'_, AppState>,
    wallet_address: String,
) -> Result<MultisigWalletInfo> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _wallet_address = wallet_address;
    // TODO: Query multi-sig contract
    Err(Error::Validation("Wallet not found".to_string()))
}

/// Propose multi-sig transaction
#[tauri::command]
pub async fn multisig_propose_tx(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    wallet_address: String,
    to: String,
    value: String,
    data: Option<String>,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_wallet_address, _to, _value, _data) = (wallet_address, to, value, data);
    // TODO: Propose transaction on multi-sig contract
    Ok("pending".to_string())
}

/// Sign multi-sig transaction
#[tauri::command]
pub async fn multisig_sign_tx(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    wallet_address: String,
    tx_id: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_wallet_address, _tx_id) = (wallet_address, tx_id);
    // TODO: Add signature to multi-sig transaction
    Ok("pending".to_string())
}

/// Execute multi-sig transaction (after threshold reached)
#[tauri::command]
pub async fn multisig_execute_tx(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    wallet_address: String,
    tx_id: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_wallet_address, _tx_id) = (wallet_address, tx_id);
    // TODO: Execute multi-sig transaction
    Ok("pending".to_string())
}

/// Get pending multi-sig transactions
#[tauri::command]
pub async fn multisig_get_pending_txs(
    app_state: State<'_, AppState>,
    wallet_address: String,
) -> Result<Vec<PendingMultisigTx>> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _wallet_address = wallet_address;
    // TODO: Query pending transactions
    Ok(vec![])
}

// ============================================================================
// Backup/Export Commands
// ============================================================================

/// Export wallet backup (encrypted)
#[tauri::command]
pub async fn backup_export_wallet(
    wallet_state: State<'_, WalletState>,
    password: String,
    include_metadata: bool,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let (_password, _include_metadata) = (password, include_metadata);
    // TODO: Export encrypted wallet backup
    // Returns base64-encoded encrypted backup
    Ok("encrypted_backup_data".to_string())
}

/// Import wallet from backup
#[tauri::command]
pub async fn backup_import_wallet(
    backup_data: String,
    password: String,
) -> Result<()> {
    let (_backup_data, _password) = (backup_data, password);
    // TODO: Import and decrypt wallet backup
    Ok(())
}

/// Export transaction history as CSV
#[tauri::command]
pub async fn backup_export_history(
    wallet_state: State<'_, WalletState>,
    format: String, // "csv" or "json"
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let _format = format;
    // TODO: Export transaction history
    Ok("".to_string())
}

// ============================================================================
// Hardware Wallet Commands
// ============================================================================

/// Hardware wallet device info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HardwareWalletDevice {
    /// Device type
    pub device_type: String, // "ledger" or "trezor"
    /// Device model
    pub model: String,
    /// Device path/ID
    pub path: String,
    /// Whether app is open
    pub app_open: bool,
}

/// Detect connected hardware wallets
#[tauri::command]
pub async fn hardware_detect_devices() -> Result<Vec<HardwareWalletDevice>> {
    // TODO: Scan for connected Ledger/Trezor devices
    Ok(vec![])
}

/// Get address from hardware wallet
#[tauri::command]
pub async fn hardware_get_address(
    device_path: String,
    account_index: u32,
    address_index: u32,
) -> Result<String> {
    let (_device_path, _account_index, _address_index) = (device_path, account_index, address_index);
    // TODO: Get address from hardware wallet
    Err(Error::Validation("No device connected".to_string()))
}

/// Sign transaction with hardware wallet
#[tauri::command]
pub async fn hardware_sign_transaction(
    device_path: String,
    account_index: u32,
    tx_hex: String,
) -> Result<String> {
    let (_device_path, _account_index, _tx_hex) = (device_path, account_index, tx_hex);
    // TODO: Sign with hardware wallet
    Err(Error::Validation("No device connected".to_string()))
}

// ============================================================================
// QR Code Commands
// ============================================================================

/// Generate QR code for address/payment request
#[tauri::command]
pub async fn qr_generate(
    data: String,
    size: u32,
) -> Result<String> {
    // Generate QR code as base64 PNG
    // Using qrcode crate would be ideal
    let (_data, _size) = (data, size);
    // TODO: Generate actual QR code
    Ok("base64_qr_image".to_string())
}

/// Parse QR code data (payment URI)
#[tauri::command]
pub async fn qr_parse_payment(
    data: String,
) -> Result<serde_json::Value> {
    // Parse synor: payment URI
    // Format: synor:<address>?amount=<amount>&label=<label>
    if !data.starts_with("synor:") {
        return Err(Error::Validation("Invalid payment URI".to_string()));
    }

    let uri = data.trim_start_matches("synor:");
    let parts: Vec<&str> = uri.split('?').collect();
    let address = parts[0].to_string();

    let mut amount = None;
    let mut label = None;
    let mut message = None;

    if parts.len() > 1 {
        for param in parts[1].split('&') {
            let kv: Vec<&str> = param.split('=').collect();
            if kv.len() == 2 {
                match kv[0] {
                    "amount" => amount = Some(kv[1].to_string()),
                    "label" => label = Some(kv[1].to_string()),
                    "message" => message = Some(kv[1].to_string()),
                    _ => {}
                }
            }
        }
    }

    Ok(serde_json::json!({
        "address": address,
        "amount": amount,
        "label": label,
        "message": message
    }))
}

// ============================================================================
// DApp Browser Commands
// ============================================================================

/// DApp connection request
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DAppConnectionRequest {
    /// DApp origin (URL)
    pub origin: String,
    /// DApp name
    pub name: String,
    /// DApp icon URL
    pub icon: Option<String>,
    /// Requested permissions
    pub permissions: Vec<String>,
}

/// Connected DApp info
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConnectedDApp {
    /// DApp origin
    pub origin: String,
    /// DApp name
    pub name: String,
    /// Connected address
    pub connected_address: String,
    /// Granted permissions
    pub permissions: Vec<String>,
    /// Connected at
    pub connected_at: u64,
}

/// Connected DApps storage
static CONNECTED_DAPPS: std::sync::LazyLock<tokio::sync::RwLock<Vec<ConnectedDApp>>> =
    std::sync::LazyLock::new(|| tokio::sync::RwLock::new(Vec::new()));

/// Get connected DApps
#[tauri::command]
pub async fn dapp_get_connected() -> Result<Vec<ConnectedDApp>> {
    let dapps = CONNECTED_DAPPS.read().await;
    Ok(dapps.clone())
}

/// Connect DApp
#[tauri::command]
pub async fn dapp_connect(
    wallet_state: State<'_, WalletState>,
    origin: String,
    name: String,
    address: String,
    permissions: Vec<String>,
) -> Result<ConnectedDApp> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let dapp = ConnectedDApp {
        origin: origin.clone(),
        name,
        connected_address: address,
        permissions,
        connected_at: std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs(),
    };

    let mut dapps = CONNECTED_DAPPS.write().await;
    // Remove existing connection from same origin
    dapps.retain(|d| d.origin != origin);
    dapps.push(dapp.clone());

    Ok(dapp)
}

/// Disconnect DApp
#[tauri::command]
pub async fn dapp_disconnect(origin: String) -> Result<()> {
    let mut dapps = CONNECTED_DAPPS.write().await;
    dapps.retain(|d| d.origin != origin);
    Ok(())
}

/// Handle DApp RPC request
#[tauri::command]
pub async fn dapp_handle_request(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    origin: String,
    method: String,
    params: serde_json::Value,
) -> Result<serde_json::Value> {
    // Verify DApp is connected
    let dapps = CONNECTED_DAPPS.read().await;
    let dapp = dapps.iter().find(|d| d.origin == origin);
    if dapp.is_none() {
        return Err(Error::Validation("DApp not connected".to_string()));
    }

    match method.as_str() {
        "eth_accounts" | "synor_accounts" => {
            let addresses = wallet_state.addresses.read().await;
            let addrs: Vec<String> = addresses.iter().map(|a| a.address.clone()).collect();
            Ok(serde_json::json!(addrs))
        }
        "eth_chainId" | "synor_chainId" => {
            Ok(serde_json::json!("0x1")) // Mainnet
        }
        "eth_blockNumber" | "synor_blockNumber" => {
            let status = app_state.node_manager.status().await;
            Ok(serde_json::json!(format!("0x{:x}", status.block_height)))
        }
        _ => {
            Err(Error::Validation(format!("Unknown method: {}", method)))
        }
    }
}

// ============================================================================
// Storage Commands (Decentralized Storage Network)
// ============================================================================

/// Stored file info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StoredFileInfo {
    /// Content ID (CID)
    pub cid: String,
    /// File name
    pub name: String,
    /// File size in bytes
    pub size: u64,
    /// MIME type
    pub mime_type: String,
    /// Upload timestamp
    pub uploaded_at: u64,
    /// Whether file is pinned
    pub is_pinned: bool,
    /// Encryption status
    pub is_encrypted: bool,
    /// Number of replicas
    pub replica_count: u32,
}

/// Storage usage stats
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StorageUsageStats {
    /// Total bytes used
    pub used_bytes: u64,
    /// Storage limit in bytes
    pub limit_bytes: u64,
    /// Number of files
    pub file_count: u64,
    /// Number of pinned files
    pub pinned_count: u64,
    /// Monthly cost in SYNOR
    pub monthly_cost: String,
}

/// Upload file to decentralized storage
#[tauri::command]
pub async fn storage_upload(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    file_path: String,
    encrypt: bool,
    pin: bool,
) -> Result<StoredFileInfo> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_file_path, _encrypt, _pin) = (file_path, encrypt, pin);
    // TODO: Upload file to storage network
    // 1. Read file and chunk it
    // 2. Apply erasure coding
    // 3. Optionally encrypt with user's key
    // 4. Upload to storage nodes
    // 5. Get CID back

    Ok(StoredFileInfo {
        cid: "bafybeig...".to_string(),
        name: "file.txt".to_string(),
        size: 0,
        mime_type: "application/octet-stream".to_string(),
        uploaded_at: std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs(),
        is_pinned: pin,
        is_encrypted: encrypt,
        replica_count: 3,
    })
}

/// Download file from storage
#[tauri::command]
pub async fn storage_download(
    app_state: State<'_, AppState>,
    cid: String,
    output_path: String,
) -> Result<()> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_cid, _output_path) = (cid, output_path);
    // TODO: Download and reassemble file from storage network
    Ok(())
}

/// Get file info by CID
#[tauri::command]
pub async fn storage_get_file_info(
    app_state: State<'_, AppState>,
    cid: String,
) -> Result<StoredFileInfo> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _cid = cid;
    // TODO: Query storage network for file info
    Err(Error::Validation("File not found".to_string()))
}

/// List user's stored files
#[tauri::command]
pub async fn storage_list_files(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
) -> Result<Vec<StoredFileInfo>> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: List files owned by user
    Ok(vec![])
}

/// Pin a file for persistent storage
#[tauri::command]
pub async fn storage_pin(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    cid: String,
) -> Result<()> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _cid = cid;
    // TODO: Pin file to storage network
    Ok(())
}

/// Unpin a file
#[tauri::command]
pub async fn storage_unpin(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    cid: String,
) -> Result<()> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _cid = cid;
    // TODO: Unpin file from storage network
    Ok(())
}

/// Delete a file from storage
#[tauri::command]
pub async fn storage_delete(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    cid: String,
) -> Result<()> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _cid = cid;
    // TODO: Delete file from storage
    Ok(())
}

/// Get storage usage statistics
#[tauri::command]
pub async fn storage_get_usage(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
) -> Result<StorageUsageStats> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: Query storage usage
    Ok(StorageUsageStats {
        used_bytes: 0,
        limit_bytes: 10_737_418_240, // 10 GB
        file_count: 0,
        pinned_count: 0,
        monthly_cost: "0".to_string(),
    })
}

// ============================================================================
// Hosting Commands (Decentralized Web Hosting)
// ============================================================================

/// Hosted site info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HostedSiteInfo {
    /// Site name (subdomain)
    pub name: String,
    /// Full domain (name.synor.site)
    pub domain: String,
    /// Custom domain (if configured)
    pub custom_domain: Option<String>,
    /// Content CID
    pub content_cid: String,
    /// Deploy timestamp
    pub deployed_at: u64,
    /// SSL enabled
    pub ssl_enabled: bool,
    /// Bandwidth used this month (bytes)
    pub bandwidth_used: u64,
    /// Monthly cost in SYNOR
    pub monthly_cost: String,
}

/// Domain verification status
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DomainVerificationStatus {
    /// Domain name
    pub domain: String,
    /// Is verified
    pub is_verified: bool,
    /// Verification TXT record
    pub txt_record: String,
    /// Expected TXT value
    pub expected_value: String,
}

/// Register a hosting name
#[tauri::command]
pub async fn hosting_register_name(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    name: String,
) -> Result<HostedSiteInfo> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // Validate name
    if name.len() < 3 || name.len() > 63 {
        return Err(Error::Validation("Name must be 3-63 characters".to_string()));
    }
    if !name.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-') {
        return Err(Error::Validation("Name must contain only lowercase letters, digits, and hyphens".to_string()));
    }

    // TODO: Register name on-chain
    Ok(HostedSiteInfo {
        name: name.clone(),
        domain: format!("{}.synor.site", name),
        custom_domain: None,
        content_cid: "".to_string(),
        deployed_at: 0,
        ssl_enabled: true,
        bandwidth_used: 0,
        monthly_cost: "0.1".to_string(),
    })
}

/// Deploy site content
#[tauri::command]
pub async fn hosting_deploy(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    name: String,
    content_cid: String,
) -> Result<HostedSiteInfo> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _name = name.clone();
    let _content_cid = content_cid.clone();
    // TODO: Update on-chain pointer to content CID
    Ok(HostedSiteInfo {
        name: name.clone(),
        domain: format!("{}.synor.site", name),
        custom_domain: None,
        content_cid,
        deployed_at: std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs(),
        ssl_enabled: true,
        bandwidth_used: 0,
        monthly_cost: "0.1".to_string(),
    })
}

/// List user's hosted sites
#[tauri::command]
pub async fn hosting_list_sites(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
) -> Result<Vec<HostedSiteInfo>> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: Query user's hosted sites
    Ok(vec![])
}

/// Add custom domain
#[tauri::command]
pub async fn hosting_add_custom_domain(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    name: String,
    custom_domain: String,
) -> Result<DomainVerificationStatus> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _name = name;
    // TODO: Initiate custom domain verification
    Ok(DomainVerificationStatus {
        domain: custom_domain.clone(),
        is_verified: false,
        txt_record: "_synor-verify".to_string(),
        expected_value: format!("synor-site-verify={}", uuid::Uuid::new_v4()),
    })
}

/// Verify custom domain
#[tauri::command]
pub async fn hosting_verify_domain(
    app_state: State<'_, AppState>,
    custom_domain: String,
) -> Result<DomainVerificationStatus> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _custom_domain = custom_domain.clone();
    // TODO: Check DNS TXT record for verification
    Ok(DomainVerificationStatus {
        domain: custom_domain,
        is_verified: false,
        txt_record: "_synor-verify".to_string(),
        expected_value: "".to_string(),
    })
}

/// Delete hosted site
#[tauri::command]
pub async fn hosting_delete_site(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    name: String,
) -> Result<()> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _name = name;
    // TODO: Delete site registration
    Ok(())
}

// ============================================================================
// Compute Commands (Decentralized Compute Marketplace)
// ============================================================================

/// Compute provider info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ComputeProviderInfo {
    /// Provider address
    pub address: String,
    /// Provider name
    pub name: String,
    /// Available GPU types
    pub gpu_types: Vec<String>,
    /// CPU cores available
    pub cpu_cores: u32,
    /// Memory available (GB)
    pub memory_gb: u32,
    /// Price per hour (SYNOR)
    pub price_per_hour: String,
    /// Reputation score (0-100)
    pub reputation: u32,
    /// Is currently available
    pub is_available: bool,
}

/// Compute job info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ComputeJobInfo {
    /// Job ID
    pub job_id: String,
    /// Job status
    pub status: String, // "pending", "running", "completed", "failed"
    /// Provider address
    pub provider: String,
    /// GPU type used
    pub gpu_type: Option<String>,
    /// CPU cores used
    pub cpu_cores: u32,
    /// Memory used (GB)
    pub memory_gb: u32,
    /// Start time
    pub started_at: Option<u64>,
    /// End time
    pub ended_at: Option<u64>,
    /// Total cost (SYNOR)
    pub total_cost: String,
    /// Result CID (if completed)
    pub result_cid: Option<String>,
}

/// List compute providers
#[tauri::command]
pub async fn compute_list_providers(
    app_state: State<'_, AppState>,
    gpu_type: Option<String>,
    min_memory_gb: Option<u32>,
) -> Result<Vec<ComputeProviderInfo>> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_gpu_type, _min_memory_gb) = (gpu_type, min_memory_gb);
    // TODO: Query compute marketplace for providers
    Ok(vec![
        ComputeProviderInfo {
            address: "synor1provider...".to_string(),
            name: "GPU Farm Alpha".to_string(),
            gpu_types: vec!["RTX 4090".to_string(), "A100".to_string()],
            cpu_cores: 64,
            memory_gb: 256,
            price_per_hour: "0.5".to_string(),
            reputation: 95,
            is_available: true,
        },
    ])
}

/// Submit compute job
#[tauri::command]
pub async fn compute_submit_job(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    provider: String,
    input_cid: String,
    docker_image: String,
    command: Vec<String>,
    gpu_type: Option<String>,
    cpu_cores: u32,
    memory_gb: u32,
    max_hours: u32,
) -> Result<ComputeJobInfo> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_provider, _input_cid, _docker_image, _command) = (provider.clone(), input_cid, docker_image, command);
    let (_gpu_type, _cpu_cores, _memory_gb, _max_hours) = (gpu_type.clone(), cpu_cores, memory_gb, max_hours);

    // TODO: Submit job to compute marketplace
    Ok(ComputeJobInfo {
        job_id: uuid::Uuid::new_v4().to_string(),
        status: "pending".to_string(),
        provider,
        gpu_type,
        cpu_cores,
        memory_gb,
        started_at: None,
        ended_at: None,
        total_cost: "0".to_string(),
        result_cid: None,
    })
}

/// Get compute job status
#[tauri::command]
pub async fn compute_get_job(
    app_state: State<'_, AppState>,
    job_id: String,
) -> Result<ComputeJobInfo> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _job_id = job_id;
    // TODO: Query job status
    Err(Error::Validation("Job not found".to_string()))
}

/// List user's compute jobs
#[tauri::command]
pub async fn compute_list_jobs(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
) -> Result<Vec<ComputeJobInfo>> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: List user's jobs
    Ok(vec![])
}

/// Cancel compute job
#[tauri::command]
pub async fn compute_cancel_job(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    job_id: String,
) -> Result<()> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _job_id = job_id;
    // TODO: Cancel job
    Ok(())
}

// ============================================================================
// Database Commands (Decentralized Multi-Model Database)
// ============================================================================

/// Database instance info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DatabaseInstanceInfo {
    /// Database ID
    pub id: String,
    /// Database name
    pub name: String,
    /// Database type (kv, document, vector, timeseries, graph, sql)
    pub db_type: String,
    /// Region
    pub region: String,
    /// Status
    pub status: String,
    /// Storage used (bytes)
    pub storage_used: u64,
    /// Read operations this month
    pub read_ops: u64,
    /// Write operations this month
    pub write_ops: u64,
    /// Monthly cost
    pub monthly_cost: String,
    /// Connection string
    pub connection_string: String,
}

/// Create database instance
#[tauri::command]
pub async fn database_create(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    name: String,
    db_type: String,
    region: String,
) -> Result<DatabaseInstanceInfo> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // Validate db_type
    let valid_types = ["kv", "document", "vector", "timeseries", "graph", "sql"];
    if !valid_types.contains(&db_type.as_str()) {
        return Err(Error::Validation(format!("Invalid database type. Must be one of: {:?}", valid_types)));
    }

    let db_id = uuid::Uuid::new_v4().to_string();
    // TODO: Provision database instance
    Ok(DatabaseInstanceInfo {
        id: db_id.clone(),
        name,
        db_type,
        region,
        status: "provisioning".to_string(),
        storage_used: 0,
        read_ops: 0,
        write_ops: 0,
        monthly_cost: "0".to_string(),
        connection_string: format!("synordb://{}.db.synor.network", db_id),
    })
}

/// List database instances
#[tauri::command]
pub async fn database_list(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
) -> Result<Vec<DatabaseInstanceInfo>> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: List user's databases
    Ok(vec![])
}

/// Get database instance info
#[tauri::command]
pub async fn database_get_info(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    db_id: String,
) -> Result<DatabaseInstanceInfo> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _db_id = db_id;
    // TODO: Get database info
    Err(Error::Validation("Database not found".to_string()))
}

/// Delete database instance
#[tauri::command]
pub async fn database_delete(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    db_id: String,
) -> Result<()> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _db_id = db_id;
    // TODO: Delete database
    Ok(())
}

/// Execute database query
#[tauri::command]
pub async fn database_query(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    db_id: String,
    query: String,
) -> Result<serde_json::Value> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_db_id, _query) = (db_id, query);
    // TODO: Execute query
    Ok(serde_json::json!({ "results": [] }))
}

// ============================================================================
// Privacy Commands (Confidential Transactions & Privacy Features)
// ============================================================================

/// Confidential balance info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfidentialBalanceInfo {
    /// Encrypted balance commitment
    pub commitment: String,
    /// Your decrypted balance (only visible to you)
    pub balance: String,
    /// Number of confidential UTXOs
    pub utxo_count: u32,
}

/// Privacy transaction request
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PrivacyTransactionRequest {
    /// Recipient address (can be stealth)
    pub to: String,
    /// Amount (will be hidden on-chain)
    pub amount: String,
    /// Use stealth address
    pub use_stealth_address: bool,
    /// Use ring signature
    pub use_ring_signature: bool,
    /// Ring size (if using ring signature)
    pub ring_size: Option<u32>,
}

/// Get confidential balance
#[tauri::command]
pub async fn privacy_get_balance(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
) -> Result<ConfidentialBalanceInfo> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: Query and decrypt confidential UTXOs
    Ok(ConfidentialBalanceInfo {
        commitment: "".to_string(),
        balance: "0".to_string(),
        utxo_count: 0,
    })
}

/// Send confidential transaction
#[tauri::command]
pub async fn privacy_send(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    request: PrivacyTransactionRequest,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _request = request;
    // TODO: Create confidential transaction with Pedersen commitments
    // and Bulletproofs range proofs
    Ok("pending".to_string())
}

/// Generate one-time stealth address
#[tauri::command]
pub async fn privacy_generate_stealth_address(
    wallet_state: State<'_, WalletState>,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    // TODO: Generate stealth address using ECDH
    Ok("synor1stealth...".to_string())
}

/// Shield regular tokens (convert to confidential)
#[tauri::command]
pub async fn privacy_shield(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    amount: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _amount = amount;
    // TODO: Shield tokens by creating confidential UTXOs
    Ok("pending".to_string())
}

/// Unshield confidential tokens (convert back to regular)
#[tauri::command]
pub async fn privacy_unshield(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    amount: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _amount = amount;
    // TODO: Unshield tokens by revealing amount in transaction
    Ok("pending".to_string())
}

/// Create privacy-enabled token
#[tauri::command]
pub async fn privacy_create_token(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    name: String,
    symbol: String,
    initial_supply: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_name, _symbol, _initial_supply) = (name, symbol, initial_supply);
    // TODO: Deploy confidential token contract
    Ok("pending".to_string())
}

/// Deploy privacy-enabled contract
#[tauri::command]
pub async fn privacy_deploy_contract(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    bytecode: String,
    constructor_args: Option<String>,
    hide_code: bool,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_bytecode, _constructor_args, _hide_code) = (bytecode, constructor_args, hide_code);
    // TODO: Deploy contract with optional code encryption
    Ok("pending".to_string())
}

// ============================================================================
// Bridge Commands (Cross-Chain Asset Transfer)
// ============================================================================

/// Supported bridge chains
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BridgeChainInfo {
    /// Chain ID
    pub chain_id: String,
    /// Chain name
    pub name: String,
    /// Native token symbol
    pub native_symbol: String,
    /// Bridge contract address
    pub bridge_address: String,
    /// Is active
    pub is_active: bool,
    /// Confirmation blocks required
    pub confirmations: u32,
    /// Supported tokens
    pub supported_tokens: Vec<String>,
}

/// Bridge transfer info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BridgeTransferInfo {
    /// Transfer ID
    pub transfer_id: String,
    /// Source chain
    pub source_chain: String,
    /// Destination chain
    pub dest_chain: String,
    /// Token symbol
    pub token: String,
    /// Amount
    pub amount: String,
    /// Sender address (source chain)
    pub sender: String,
    /// Recipient address (dest chain)
    pub recipient: String,
    /// Status
    pub status: String, // "pending", "confirming", "relaying", "completed", "failed"
    /// Source tx hash
    pub source_tx_hash: Option<String>,
    /// Destination tx hash
    pub dest_tx_hash: Option<String>,
    /// Created at
    pub created_at: u64,
}

/// Get supported bridge chains
#[tauri::command]
pub async fn bridge_get_chains(
    app_state: State<'_, AppState>,
) -> Result<Vec<BridgeChainInfo>> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: Query bridge contracts for supported chains
    Ok(vec![
        BridgeChainInfo {
            chain_id: "ethereum".to_string(),
            name: "Ethereum".to_string(),
            native_symbol: "ETH".to_string(),
            bridge_address: "0x...".to_string(),
            is_active: true,
            confirmations: 12,
            supported_tokens: vec!["ETH".to_string(), "USDC".to_string(), "USDT".to_string()],
        },
        BridgeChainInfo {
            chain_id: "bitcoin".to_string(),
            name: "Bitcoin".to_string(),
            native_symbol: "BTC".to_string(),
            bridge_address: "bc1...".to_string(),
            is_active: true,
            confirmations: 6,
            supported_tokens: vec!["BTC".to_string()],
        },
        BridgeChainInfo {
            chain_id: "cosmos".to_string(),
            name: "Cosmos Hub".to_string(),
            native_symbol: "ATOM".to_string(),
            bridge_address: "cosmos1...".to_string(),
            is_active: true,
            confirmations: 1,
            supported_tokens: vec!["ATOM".to_string()],
        },
    ])
}

/// Initiate bridge transfer (deposit to Synor)
#[tauri::command]
pub async fn bridge_deposit(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    source_chain: String,
    token: String,
    amount: String,
) -> Result<BridgeTransferInfo> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_source_chain, _token, _amount) = (source_chain.clone(), token.clone(), amount.clone());
    // TODO: Generate deposit address and initiate bridge transfer
    Ok(BridgeTransferInfo {
        transfer_id: uuid::Uuid::new_v4().to_string(),
        source_chain,
        dest_chain: "synor".to_string(),
        token,
        amount,
        sender: "".to_string(),
        recipient: "".to_string(),
        status: "pending".to_string(),
        source_tx_hash: None,
        dest_tx_hash: None,
        created_at: std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs(),
    })
}

/// Initiate bridge withdrawal (from Synor to external chain)
#[tauri::command]
pub async fn bridge_withdraw(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    dest_chain: String,
    dest_address: String,
    token: String,
    amount: String,
) -> Result<BridgeTransferInfo> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_dest_chain, _dest_address, _token, _amount) = (dest_chain.clone(), dest_address.clone(), token.clone(), amount.clone());
    // TODO: Lock tokens and initiate bridge withdrawal
    Ok(BridgeTransferInfo {
        transfer_id: uuid::Uuid::new_v4().to_string(),
        source_chain: "synor".to_string(),
        dest_chain,
        token,
        amount,
        sender: "".to_string(),
        recipient: dest_address,
        status: "pending".to_string(),
        source_tx_hash: None,
        dest_tx_hash: None,
        created_at: std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs(),
    })
}

/// Get bridge transfer status
#[tauri::command]
pub async fn bridge_get_transfer(
    app_state: State<'_, AppState>,
    transfer_id: String,
) -> Result<BridgeTransferInfo> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _transfer_id = transfer_id;
    // TODO: Query transfer status
    Err(Error::Validation("Transfer not found".to_string()))
}

/// List user's bridge transfers
#[tauri::command]
pub async fn bridge_list_transfers(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
) -> Result<Vec<BridgeTransferInfo>> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: List user's transfers
    Ok(vec![])
}

/// Get wrapped token balance
#[tauri::command]
pub async fn bridge_get_wrapped_balance(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    token: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _token = token;
    // TODO: Query wrapped token balance (e.g., sETH, sBTC)
    Ok("0".to_string())
}

// ============================================================================
// Governance Commands (DAO & On-Chain Voting)
// ============================================================================

/// Governance proposal info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GovernanceProposal {
    /// Proposal ID
    pub id: String,
    /// Proposal title
    pub title: String,
    /// Proposal description
    pub description: String,
    /// Proposer address
    pub proposer: String,
    /// Status
    pub status: String, // "pending", "active", "passed", "rejected", "executed", "expired"
    /// For votes
    pub for_votes: String,
    /// Against votes
    pub against_votes: String,
    /// Abstain votes
    pub abstain_votes: String,
    /// Quorum required
    pub quorum: String,
    /// Start block
    pub start_block: u64,
    /// End block
    pub end_block: u64,
    /// Execution delay (blocks after passing)
    pub execution_delay: u64,
    /// Whether user has voted
    pub user_voted: bool,
    /// User's vote (if voted)
    pub user_vote: Option<String>,
}

/// Voting power info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VotingPowerInfo {
    /// Total voting power
    pub voting_power: String,
    /// Delegated to others
    pub delegated_out: String,
    /// Delegated to you
    pub delegated_in: String,
    /// Delegate address (if delegating)
    pub delegate: Option<String>,
}

/// Get governance proposals
#[tauri::command]
pub async fn governance_get_proposals(
    app_state: State<'_, AppState>,
    status_filter: Option<String>,
) -> Result<Vec<GovernanceProposal>> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _status_filter = status_filter;
    // TODO: Query governance contract for proposals
    Ok(vec![])
}

/// Get proposal details
#[tauri::command]
pub async fn governance_get_proposal(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    proposal_id: String,
) -> Result<GovernanceProposal> {
    let _wallet_state = wallet_state;
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _proposal_id = proposal_id;
    // TODO: Query proposal details
    Err(Error::Validation("Proposal not found".to_string()))
}

/// Create governance proposal
#[tauri::command]
pub async fn governance_create_proposal(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    title: String,
    description: String,
    actions: Vec<String>, // Encoded contract calls
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_title, _description, _actions) = (title, description, actions);
    // TODO: Create proposal (requires minimum voting power threshold)
    Ok("pending".to_string())
}

/// Vote on proposal
#[tauri::command]
pub async fn governance_vote(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    proposal_id: String,
    vote: String, // "for", "against", "abstain"
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // Validate vote
    if !["for", "against", "abstain"].contains(&vote.as_str()) {
        return Err(Error::Validation("Vote must be 'for', 'against', or 'abstain'".to_string()));
    }

    let (_proposal_id, _vote) = (proposal_id, vote);
    // TODO: Submit vote
    Ok("pending".to_string())
}

/// Execute passed proposal
#[tauri::command]
pub async fn governance_execute_proposal(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    proposal_id: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _proposal_id = proposal_id;
    // TODO: Execute proposal (anyone can call after delay)
    Ok("pending".to_string())
}

/// Get voting power
#[tauri::command]
pub async fn governance_get_voting_power(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
) -> Result<VotingPowerInfo> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: Query voting power from governance contract
    Ok(VotingPowerInfo {
        voting_power: "0".to_string(),
        delegated_out: "0".to_string(),
        delegated_in: "0".to_string(),
        delegate: None,
    })
}

/// Delegate voting power
#[tauri::command]
pub async fn governance_delegate(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    delegate_to: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _delegate_to = delegate_to;
    // TODO: Delegate voting power
    Ok("pending".to_string())
}

// ============================================================================
// ZK-Rollup Commands
// ============================================================================

/// ZK Rollup stats
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ZkRollupStats {
    /// Current batch number
    pub batch_number: u64,
    /// Total transactions processed
    pub total_transactions: u64,
    /// Average TPS
    pub average_tps: f64,
    /// Last proof timestamp
    pub last_proof_at: u64,
    /// Pending transactions
    pub pending_transactions: u64,
    /// L2 state root
    pub state_root: String,
}

/// ZK account info
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ZkAccountInfo {
    /// L2 address
    pub address: String,
    /// L2 balance
    pub balance: String,
    /// L2 nonce
    pub nonce: u64,
    /// Is account activated
    pub is_activated: bool,
}

/// Get ZK rollup stats
#[tauri::command]
pub async fn zk_get_stats(
    app_state: State<'_, AppState>,
) -> Result<ZkRollupStats> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: Query ZK rollup state
    Ok(ZkRollupStats {
        batch_number: 0,
        total_transactions: 0,
        average_tps: 0.0,
        last_proof_at: 0,
        pending_transactions: 0,
        state_root: "0x0".to_string(),
    })
}

/// Get ZK account info
#[tauri::command]
pub async fn zk_get_account(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
) -> Result<ZkAccountInfo> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    // TODO: Query ZK account state
    Ok(ZkAccountInfo {
        address: "".to_string(),
        balance: "0".to_string(),
        nonce: 0,
        is_activated: false,
    })
}

/// Deposit to ZK rollup
#[tauri::command]
pub async fn zk_deposit(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    amount: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _amount = amount;
    // TODO: Deposit to L2
    Ok("pending".to_string())
}

/// Withdraw from ZK rollup
#[tauri::command]
pub async fn zk_withdraw(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    amount: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _amount = amount;
    // TODO: Initiate L2 -> L1 withdrawal
    Ok("pending".to_string())
}

/// Send L2 transfer
#[tauri::command]
pub async fn zk_transfer(
    wallet_state: State<'_, WalletState>,
    app_state: State<'_, AppState>,
    to: String,
    amount: String,
) -> Result<String> {
    if !wallet_state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let (_to, _amount) = (to, amount);
    // TODO: Submit L2 transfer
    Ok("pending".to_string())
}

// ============================================================================
// Phase 8: Transaction Mixer Commands
// ============================================================================

/// Mix pool status
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MixPoolStatus {
    pub pool_id: String,
    pub denomination: u64,
    pub participants: u32,
    pub required_participants: u32,
    pub status: String,  // "waiting", "mixing", "completed"
    pub estimated_time_secs: Option<u64>,
}

/// Mix request
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MixRequest {
    pub id: String,
    pub amount: u64,
    pub denomination: u64,
    pub status: String,  // "pending", "mixing", "completed", "failed"
    pub output_address: String,
    pub created_at: i64,
    pub completed_at: Option<i64>,
    pub tx_id: Option<String>,
}

// In-memory storage for mix requests
static MIX_REQUESTS: Lazy<Arc<Mutex<HashMap<String, MixRequest>>>> = Lazy::new(|| {
    Arc::new(Mutex::new(HashMap::new()))
});

/// Get available mix pool denominations
#[tauri::command]
pub async fn mixer_get_denominations() -> Result<Vec<u64>> {
    // Standard denominations in sompi (0.1, 1, 10, 100, 1000 SYN)
    Ok(vec![
        10_000_000,      // 0.1 SYN
        100_000_000,     // 1 SYN
        1_000_000_000,   // 10 SYN
        10_000_000_000,  // 100 SYN
        100_000_000_000, // 1000 SYN
    ])
}

/// Get mix pool status for a denomination
#[tauri::command]
pub async fn mixer_get_pool_status(
    denomination: u64,
) -> Result<MixPoolStatus> {
    // Simulated pool status
    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs();

    let participants = ((now / 10) % 5) as u32;

    Ok(MixPoolStatus {
        pool_id: format!("pool-{}", denomination),
        denomination,
        participants,
        required_participants: 5,
        status: if participants >= 5 { "mixing" } else { "waiting" }.to_string(),
        estimated_time_secs: if participants < 5 { Some((5 - participants) as u64 * 60) } else { None },
    })
}

/// Create a mix request
#[tauri::command]
pub async fn mixer_create_request(
    state: State<'_, WalletState>,
    amount: u64,
    denomination: u64,
    output_address: String,
) -> Result<MixRequest> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let request_id = format!("mix-{:x}", now);

    let request = MixRequest {
        id: request_id.clone(),
        amount,
        denomination,
        status: "pending".to_string(),
        output_address,
        created_at: now,
        completed_at: None,
        tx_id: None,
    };

    let mut requests = MIX_REQUESTS.lock().await;
    requests.insert(request_id, request.clone());

    Ok(request)
}

/// Get mix request status
#[tauri::command]
pub async fn mixer_get_request(
    request_id: String,
) -> Result<MixRequest> {
    let requests = MIX_REQUESTS.lock().await;
    requests.get(&request_id)
        .cloned()
        .ok_or_else(|| Error::NotFound(format!("Mix request {} not found", request_id)))
}

/// List all mix requests
#[tauri::command]
pub async fn mixer_list_requests(
    state: State<'_, WalletState>,
) -> Result<Vec<MixRequest>> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let requests = MIX_REQUESTS.lock().await;
    Ok(requests.values().cloned().collect())
}

/// Cancel a pending mix request
#[tauri::command]
pub async fn mixer_cancel_request(
    state: State<'_, WalletState>,
    request_id: String,
) -> Result<()> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut requests = MIX_REQUESTS.lock().await;
    let request = requests.get_mut(&request_id)
        .ok_or_else(|| Error::NotFound(format!("Mix request {} not found", request_id)))?;

    if request.status != "pending" {
        return Err(Error::Validation("Can only cancel pending requests".to_string()));
    }

    request.status = "cancelled".to_string();
    Ok(())
}

// ============================================================================
// Phase 9: Limit Orders Commands
// ============================================================================

/// Limit order
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LimitOrder {
    pub id: String,
    pub order_type: String,  // "buy" or "sell"
    pub pair: String,        // e.g., "SYN/USDT"
    pub price: f64,
    pub amount: u64,
    pub filled_amount: u64,
    pub status: String,      // "open", "partial", "filled", "cancelled"
    pub created_at: i64,
    pub expires_at: Option<i64>,
}

// In-memory storage for limit orders
static LIMIT_ORDERS: Lazy<Arc<Mutex<HashMap<String, LimitOrder>>>> = Lazy::new(|| {
    Arc::new(Mutex::new(HashMap::new()))
});

/// Create a limit order
#[tauri::command]
pub async fn limit_order_create(
    state: State<'_, WalletState>,
    order_type: String,
    pair: String,
    price: f64,
    amount: u64,
    expires_in_hours: Option<u64>,
) -> Result<LimitOrder> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    if order_type != "buy" && order_type != "sell" {
        return Err(Error::Validation("Order type must be 'buy' or 'sell'".to_string()));
    }

    if price <= 0.0 {
        return Err(Error::Validation("Price must be positive".to_string()));
    }

    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let order_id = format!("order-{:x}", now);

    let expires_at = expires_in_hours.map(|h| now + (h as i64 * 3600));

    let order = LimitOrder {
        id: order_id.clone(),
        order_type,
        pair,
        price,
        amount,
        filled_amount: 0,
        status: "open".to_string(),
        created_at: now,
        expires_at,
    };

    let mut orders = LIMIT_ORDERS.lock().await;
    orders.insert(order_id, order.clone());

    Ok(order)
}

/// Get a limit order
#[tauri::command]
pub async fn limit_order_get(
    order_id: String,
) -> Result<LimitOrder> {
    let orders = LIMIT_ORDERS.lock().await;
    orders.get(&order_id)
        .cloned()
        .ok_or_else(|| Error::NotFound(format!("Order {} not found", order_id)))
}

/// List all limit orders
#[tauri::command]
pub async fn limit_order_list(
    state: State<'_, WalletState>,
    status_filter: Option<String>,
) -> Result<Vec<LimitOrder>> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let orders = LIMIT_ORDERS.lock().await;
    let mut result: Vec<LimitOrder> = orders.values()
        .filter(|o| status_filter.as_ref().map_or(true, |s| &o.status == s))
        .cloned()
        .collect();

    result.sort_by(|a, b| b.created_at.cmp(&a.created_at));
    Ok(result)
}

/// Cancel a limit order
#[tauri::command]
pub async fn limit_order_cancel(
    state: State<'_, WalletState>,
    order_id: String,
) -> Result<LimitOrder> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut orders = LIMIT_ORDERS.lock().await;
    let order = orders.get_mut(&order_id)
        .ok_or_else(|| Error::NotFound(format!("Order {} not found", order_id)))?;

    if order.status != "open" && order.status != "partial" {
        return Err(Error::Validation("Can only cancel open or partial orders".to_string()));
    }

    order.status = "cancelled".to_string();
    Ok(order.clone())
}

/// Get order book for a pair
#[tauri::command]
pub async fn limit_order_get_orderbook(
    pair: String,
) -> Result<serde_json::Value> {
    let orders = LIMIT_ORDERS.lock().await;

    let mut bids: Vec<&LimitOrder> = orders.values()
        .filter(|o| o.pair == pair && o.order_type == "buy" && o.status == "open")
        .collect();
    let mut asks: Vec<&LimitOrder> = orders.values()
        .filter(|o| o.pair == pair && o.order_type == "sell" && o.status == "open")
        .collect();

    bids.sort_by(|a, b| b.price.partial_cmp(&a.price).unwrap_or(std::cmp::Ordering::Equal));
    asks.sort_by(|a, b| a.price.partial_cmp(&b.price).unwrap_or(std::cmp::Ordering::Equal));

    Ok(serde_json::json!({
        "pair": pair,
        "bids": bids.iter().map(|o| serde_json::json!({"price": o.price, "amount": o.amount - o.filled_amount})).collect::<Vec<_>>(),
        "asks": asks.iter().map(|o| serde_json::json!({"price": o.price, "amount": o.amount - o.filled_amount})).collect::<Vec<_>>()
    }))
}

// ============================================================================
// Phase 10: Yield Aggregator Commands
// ============================================================================

/// Yield opportunity
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct YieldOpportunity {
    pub id: String,
    pub name: String,
    pub protocol: String,
    pub asset: String,
    pub apy: f64,
    pub tvl: u64,
    pub risk_level: String,  // "low", "medium", "high"
    pub lockup_period_days: u32,
    pub min_deposit: u64,
}

/// User yield position
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct YieldPosition {
    pub id: String,
    pub opportunity_id: String,
    pub deposited_amount: u64,
    pub current_value: u64,
    pub rewards_earned: u64,
    pub auto_compound: bool,
    pub created_at: i64,
    pub last_compound_at: Option<i64>,
}

// In-memory storage for yield positions
static YIELD_POSITIONS: Lazy<Arc<Mutex<HashMap<String, YieldPosition>>>> = Lazy::new(|| {
    Arc::new(Mutex::new(HashMap::new()))
});

/// Get available yield opportunities
#[tauri::command]
pub async fn yield_get_opportunities() -> Result<Vec<YieldOpportunity>> {
    Ok(vec![
        YieldOpportunity {
            id: "syn-staking".to_string(),
            name: "SYN Staking".to_string(),
            protocol: "Synor".to_string(),
            asset: "SYN".to_string(),
            apy: 8.5,
            tvl: 5_000_000_000_000, // 50,000 SYN
            risk_level: "low".to_string(),
            lockup_period_days: 0,
            min_deposit: 100_000_000, // 1 SYN
        },
        YieldOpportunity {
            id: "syn-lp".to_string(),
            name: "SYN/USDT LP".to_string(),
            protocol: "SynorSwap".to_string(),
            asset: "SYN-USDT-LP".to_string(),
            apy: 24.5,
            tvl: 2_000_000_000_000, // 20,000 SYN equivalent
            risk_level: "medium".to_string(),
            lockup_period_days: 0,
            min_deposit: 100_000_000, // 1 SYN
        },
        YieldOpportunity {
            id: "syn-vault-30".to_string(),
            name: "30-Day Vault".to_string(),
            protocol: "Synor".to_string(),
            asset: "SYN".to_string(),
            apy: 15.0,
            tvl: 1_000_000_000_000,
            risk_level: "low".to_string(),
            lockup_period_days: 30,
            min_deposit: 1_000_000_000, // 10 SYN
        },
    ])
}

/// Deposit into a yield opportunity
#[tauri::command]
pub async fn yield_deposit(
    state: State<'_, WalletState>,
    opportunity_id: String,
    amount: u64,
    auto_compound: bool,
) -> Result<YieldPosition> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let position_id = format!("yield-{:x}", now);

    let position = YieldPosition {
        id: position_id.clone(),
        opportunity_id,
        deposited_amount: amount,
        current_value: amount,
        rewards_earned: 0,
        auto_compound,
        created_at: now,
        last_compound_at: None,
    };

    let mut positions = YIELD_POSITIONS.lock().await;
    positions.insert(position_id, position.clone());

    Ok(position)
}

/// Withdraw from a yield position
#[tauri::command]
pub async fn yield_withdraw(
    state: State<'_, WalletState>,
    position_id: String,
    amount: Option<u64>,  // None = withdraw all
) -> Result<YieldPosition> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut positions = YIELD_POSITIONS.lock().await;
    let position = positions.get_mut(&position_id)
        .ok_or_else(|| Error::NotFound(format!("Position {} not found", position_id)))?;

    let withdraw_amount = amount.unwrap_or(position.current_value);
    if withdraw_amount > position.current_value {
        return Err(Error::Validation("Insufficient balance".to_string()));
    }

    position.current_value -= withdraw_amount;
    position.deposited_amount = position.deposited_amount.saturating_sub(withdraw_amount);

    Ok(position.clone())
}

/// List user's yield positions
#[tauri::command]
pub async fn yield_list_positions(
    state: State<'_, WalletState>,
) -> Result<Vec<YieldPosition>> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let positions = YIELD_POSITIONS.lock().await;
    Ok(positions.values().cloned().collect())
}

/// Manually compound rewards
#[tauri::command]
pub async fn yield_compound(
    state: State<'_, WalletState>,
    position_id: String,
) -> Result<YieldPosition> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut positions = YIELD_POSITIONS.lock().await;
    let position = positions.get_mut(&position_id)
        .ok_or_else(|| Error::NotFound(format!("Position {} not found", position_id)))?;

    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    // Add rewards to principal (simplified calculation)
    position.current_value += position.rewards_earned;
    position.rewards_earned = 0;
    position.last_compound_at = Some(now);

    Ok(position.clone())
}

// ============================================================================
// Phase 11: Portfolio Analytics Commands
// ============================================================================

/// Portfolio summary
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PortfolioSummary {
    pub total_value_usd: f64,
    pub total_cost_basis_usd: f64,
    pub total_pnl_usd: f64,
    pub total_pnl_percent: f64,
    pub day_change_usd: f64,
    pub day_change_percent: f64,
}

/// Asset holding
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AssetHolding {
    pub asset: String,
    pub symbol: String,
    pub balance: u64,
    pub balance_formatted: String,
    pub price_usd: f64,
    pub value_usd: f64,
    pub cost_basis_usd: f64,
    pub pnl_usd: f64,
    pub pnl_percent: f64,
    pub allocation_percent: f64,
}

/// Transaction for tax reporting
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TaxableTransaction {
    pub id: String,
    pub tx_type: String,  // "buy", "sell", "swap", "transfer"
    pub asset: String,
    pub amount: f64,
    pub price_usd: f64,
    pub total_usd: f64,
    pub cost_basis_usd: Option<f64>,
    pub gain_loss_usd: Option<f64>,
    pub timestamp: i64,
    pub is_long_term: bool,  // held > 1 year
}

/// Get portfolio summary
#[tauri::command]
pub async fn portfolio_get_summary(
    state: State<'_, WalletState>,
) -> Result<PortfolioSummary> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    // Simulated portfolio data
    Ok(PortfolioSummary {
        total_value_usd: 12500.0,
        total_cost_basis_usd: 10000.0,
        total_pnl_usd: 2500.0,
        total_pnl_percent: 25.0,
        day_change_usd: 125.0,
        day_change_percent: 1.0,
    })
}

/// Get asset holdings breakdown
#[tauri::command]
pub async fn portfolio_get_holdings(
    state: State<'_, WalletState>,
) -> Result<Vec<AssetHolding>> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    // Simulated holdings
    Ok(vec![
        AssetHolding {
            asset: "synor".to_string(),
            symbol: "SYN".to_string(),
            balance: 1000_000_000_000, // 10,000 SYN
            balance_formatted: "10,000.00".to_string(),
            price_usd: 1.25,
            value_usd: 12500.0,
            cost_basis_usd: 10000.0,
            pnl_usd: 2500.0,
            pnl_percent: 25.0,
            allocation_percent: 100.0,
        },
    ])
}

/// Get taxable transactions
#[tauri::command]
pub async fn portfolio_get_tax_report(
    state: State<'_, WalletState>,
    year: u32,
) -> Result<Vec<TaxableTransaction>> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let _year = year;
    // TODO: Generate actual tax report from transaction history
    Ok(vec![])
}

/// Export tax report as CSV
#[tauri::command]
pub async fn portfolio_export_tax_report(
    state: State<'_, WalletState>,
    year: u32,
    format: String,  // "csv", "txf", "json"
) -> Result<String> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let (_year, _format) = (year, format);
    // TODO: Generate and return export data
    Ok("".to_string())
}

/// Get historical portfolio value
#[tauri::command]
pub async fn portfolio_get_history(
    state: State<'_, WalletState>,
    days: u32,
) -> Result<Vec<serde_json::Value>> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let _days = days;
    // Generate simulated history
    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let mut history = Vec::new();
    for i in 0..days {
        history.push(serde_json::json!({
            "timestamp": now - (i as i64 * 86400),
            "value_usd": 12500.0 - (i as f64 * 50.0)
        }));
    }
    history.reverse();
    Ok(history)
}

// ============================================================================
// Phase 12: Price Alerts Commands
// ============================================================================

/// Price alert
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PriceAlert {
    pub id: String,
    pub asset: String,
    pub condition: String,  // "above", "below"
    pub target_price: f64,
    pub current_price: f64,
    pub is_triggered: bool,
    pub is_enabled: bool,
    pub created_at: i64,
    pub triggered_at: Option<i64>,
    pub notification_method: String,  // "push", "email", "both"
}

// In-memory storage for price alerts
static PRICE_ALERTS: Lazy<Arc<Mutex<HashMap<String, PriceAlert>>>> = Lazy::new(|| {
    Arc::new(Mutex::new(HashMap::new()))
});

/// Create a price alert
#[tauri::command]
pub async fn alert_create(
    state: State<'_, WalletState>,
    asset: String,
    condition: String,
    target_price: f64,
    notification_method: String,
) -> Result<PriceAlert> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    if condition != "above" && condition != "below" {
        return Err(Error::Validation("Condition must be 'above' or 'below'".to_string()));
    }

    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let alert_id = format!("alert-{:x}", now);

    let alert = PriceAlert {
        id: alert_id.clone(),
        asset,
        condition,
        target_price,
        current_price: 1.25, // Simulated
        is_triggered: false,
        is_enabled: true,
        created_at: now,
        triggered_at: None,
        notification_method,
    };

    let mut alerts = PRICE_ALERTS.lock().await;
    alerts.insert(alert_id, alert.clone());

    Ok(alert)
}

/// List all price alerts
#[tauri::command]
pub async fn alert_list(
    state: State<'_, WalletState>,
) -> Result<Vec<PriceAlert>> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let alerts = PRICE_ALERTS.lock().await;
    let mut result: Vec<PriceAlert> = alerts.values().cloned().collect();
    result.sort_by(|a, b| b.created_at.cmp(&a.created_at));
    Ok(result)
}

/// Delete a price alert
#[tauri::command]
pub async fn alert_delete(
    state: State<'_, WalletState>,
    alert_id: String,
) -> Result<()> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut alerts = PRICE_ALERTS.lock().await;
    alerts.remove(&alert_id)
        .ok_or_else(|| Error::NotFound(format!("Alert {} not found", alert_id)))?;

    Ok(())
}

/// Toggle alert enabled/disabled
#[tauri::command]
pub async fn alert_toggle(
    state: State<'_, WalletState>,
    alert_id: String,
    enabled: bool,
) -> Result<PriceAlert> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut alerts = PRICE_ALERTS.lock().await;
    let alert = alerts.get_mut(&alert_id)
        .ok_or_else(|| Error::NotFound(format!("Alert {} not found", alert_id)))?;

    alert.is_enabled = enabled;
    Ok(alert.clone())
}

// ============================================================================
// Phase 13: CLI Mode Commands
// ============================================================================

/// CLI command result
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CliResult {
    pub command: String,
    pub output: String,
    pub is_error: bool,
    pub timestamp: i64,
}

/// Execute a CLI command
#[tauri::command]
pub async fn cli_execute(
    state: State<'_, WalletState>,
    command: String,
) -> Result<CliResult> {
    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let parts: Vec<&str> = command.trim().split_whitespace().collect();
    if parts.is_empty() {
        return Ok(CliResult {
            command,
            output: "".to_string(),
            is_error: false,
            timestamp: now,
        });
    }

    let cmd = parts[0];
    let args = &parts[1..];

    let (output, is_error) = match cmd {
        "help" => (
            "Available commands:\n\
             help            - Show this help message\n\
             balance         - Show wallet balance\n\
             address         - Show wallet address\n\
             send <to> <amt> - Send SYN to address\n\
             history         - Show transaction history\n\
             status          - Show node status\n\
             peers           - Show connected peers\n\
             mining          - Show mining status\n\
             clear           - Clear screen".to_string(),
            false
        ),
        "balance" => {
            if !state.is_unlocked().await {
                ("Error: Wallet is locked".to_string(), true)
            } else {
                ("Balance: 10,000.00 SYN (simulated)".to_string(), false)
            }
        },
        "address" => {
            if !state.is_unlocked().await {
                ("Error: Wallet is locked".to_string(), true)
            } else {
                ("synor1q2w3e4r5t6y7u8i9o0p...".to_string(), false)
            }
        },
        "send" => {
            if args.len() < 2 {
                ("Usage: send <address> <amount>".to_string(), true)
            } else if !state.is_unlocked().await {
                ("Error: Wallet is locked".to_string(), true)
            } else {
                (format!("Sending {} SYN to {}... (simulated)", args[1], args[0]), false)
            }
        },
        "history" => {
            if !state.is_unlocked().await {
                ("Error: Wallet is locked".to_string(), true)
            } else {
                ("No transactions found (simulated)".to_string(), false)
            }
        },
        "status" => ("Node: Connected | Block: 123456 | Peers: 8".to_string(), false),
        "peers" => ("Connected to 8 peers (simulated)".to_string(), false),
        "mining" => ("Mining: Inactive".to_string(), false),
        "clear" => ("CLEAR".to_string(), false),
        _ => (format!("Unknown command: {}. Type 'help' for available commands.", cmd), true),
    };

    Ok(CliResult {
        command,
        output,
        is_error,
        timestamp: now,
    })
}

/// Get CLI command history
#[tauri::command]
pub async fn cli_get_history() -> Result<Vec<String>> {
    // Would store command history in a persistent store
    Ok(vec![])
}

// ============================================================================
// Phase 14: Custom RPC Profiles Commands
// ============================================================================

/// RPC profile
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RpcProfile {
    pub id: String,
    pub name: String,
    pub http_url: String,
    pub ws_url: Option<String>,
    pub is_active: bool,
    pub is_default: bool,
    pub priority: u32,  // For failover order
    pub latency_ms: Option<u32>,
    pub last_checked: Option<i64>,
    pub is_healthy: bool,
}

// In-memory storage for RPC profiles
static RPC_PROFILES: Lazy<Arc<Mutex<HashMap<String, RpcProfile>>>> = Lazy::new(|| {
    let mut profiles = HashMap::new();
    profiles.insert("default".to_string(), RpcProfile {
        id: "default".to_string(),
        name: "Default Mainnet".to_string(),
        http_url: "https://rpc.synor.io".to_string(),
        ws_url: Some("wss://rpc.synor.io/ws".to_string()),
        is_active: true,
        is_default: true,
        priority: 1,
        latency_ms: Some(45),
        last_checked: None,
        is_healthy: true,
    });
    Arc::new(Mutex::new(profiles))
});

/// Create an RPC profile
#[tauri::command]
pub async fn rpc_profile_create(
    name: String,
    http_url: String,
    ws_url: Option<String>,
) -> Result<RpcProfile> {
    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let profile_id = format!("rpc-{:x}", now);

    let mut profiles = RPC_PROFILES.lock().await;
    let priority = profiles.len() as u32 + 1;

    let profile = RpcProfile {
        id: profile_id.clone(),
        name,
        http_url,
        ws_url,
        is_active: false,
        is_default: false,
        priority,
        latency_ms: None,
        last_checked: None,
        is_healthy: true,
    };

    profiles.insert(profile_id, profile.clone());
    Ok(profile)
}

/// List all RPC profiles
#[tauri::command]
pub async fn rpc_profile_list() -> Result<Vec<RpcProfile>> {
    let profiles = RPC_PROFILES.lock().await;
    let mut result: Vec<RpcProfile> = profiles.values().cloned().collect();
    result.sort_by(|a, b| a.priority.cmp(&b.priority));
    Ok(result)
}

/// Set active RPC profile
#[tauri::command]
pub async fn rpc_profile_set_active(
    profile_id: String,
) -> Result<RpcProfile> {
    let mut profiles = RPC_PROFILES.lock().await;

    // First, deactivate all
    for p in profiles.values_mut() {
        p.is_active = false;
    }

    // Then activate the selected one
    let profile = profiles.get_mut(&profile_id)
        .ok_or_else(|| Error::NotFound(format!("Profile {} not found", profile_id)))?;

    profile.is_active = true;
    Ok(profile.clone())
}

/// Delete an RPC profile
#[tauri::command]
pub async fn rpc_profile_delete(
    profile_id: String,
) -> Result<()> {
    let mut profiles = RPC_PROFILES.lock().await;

    let profile = profiles.get(&profile_id)
        .ok_or_else(|| Error::NotFound(format!("Profile {} not found", profile_id)))?;

    if profile.is_default {
        return Err(Error::Validation("Cannot delete default profile".to_string()));
    }

    profiles.remove(&profile_id);
    Ok(())
}

/// Test RPC profile connectivity
#[tauri::command]
pub async fn rpc_profile_test(
    profile_id: String,
) -> Result<RpcProfile> {
    let mut profiles = RPC_PROFILES.lock().await;
    let profile = profiles.get_mut(&profile_id)
        .ok_or_else(|| Error::NotFound(format!("Profile {} not found", profile_id)))?;

    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    // Simulate latency check
    profile.latency_ms = Some(((now % 100) + 20) as u32);
    profile.last_checked = Some(now);
    profile.is_healthy = true;

    Ok(profile.clone())
}

// ============================================================================
// Phase 15: Transaction Builder Commands
// ============================================================================

/// Transaction output
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TxOutput {
    pub address: String,
    pub amount: u64,
}

/// Built transaction (unsigned)
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BuiltTransaction {
    pub id: String,
    pub inputs: Vec<serde_json::Value>,
    pub outputs: Vec<TxOutput>,
    pub fee: u64,
    pub size_bytes: u32,
    pub locktime: u64,
    pub hex: String,  // Unsigned transaction hex
}

/// Build a custom transaction
#[tauri::command]
pub async fn tx_builder_create(
    state: State<'_, WalletState>,
    outputs: Vec<TxOutput>,
    fee_rate: f64,
    locktime: Option<u64>,
) -> Result<BuiltTransaction> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    if outputs.is_empty() {
        return Err(Error::Validation("At least one output required".to_string()));
    }

    for output in &outputs {
        if output.amount == 0 {
            return Err(Error::Validation("Output amount must be greater than 0".to_string()));
        }
    }

    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs() as i64;

    let tx_id = format!("tx-{:x}", now);

    // Estimate size and fee
    let size_bytes = (outputs.len() as u32 * 34) + 150; // Simplified estimate
    let fee = (size_bytes as f64 * fee_rate) as u64;

    Ok(BuiltTransaction {
        id: tx_id,
        inputs: vec![], // Would be selected UTXOs
        outputs,
        fee,
        size_bytes,
        locktime: locktime.unwrap_or(0),
        hex: "".to_string(), // Would be actual unsigned tx hex
    })
}

/// Sign a built transaction
#[tauri::command]
pub async fn tx_builder_sign(
    state: State<'_, WalletState>,
    tx_hex: String,
) -> Result<String> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let _tx_hex = tx_hex;
    // TODO: Actually sign the transaction
    Ok("signed-tx-hex".to_string())
}

/// Broadcast a signed transaction
#[tauri::command]
pub async fn tx_builder_broadcast(
    app_state: State<'_, AppState>,
    signed_tx_hex: String,
) -> Result<String> {
    let mode = app_state.node_manager.connection_mode().await;
    if matches!(mode, ConnectionMode::Disconnected) {
        return Err(Error::NotConnected);
    }

    let _signed_tx_hex = signed_tx_hex;
    // TODO: Actually broadcast the transaction
    Ok("tx-id-here".to_string())
}

/// Decode a transaction
#[tauri::command]
pub async fn tx_builder_decode(
    tx_hex: String,
) -> Result<serde_json::Value> {
    let _tx_hex = tx_hex;
    // TODO: Decode transaction
    Ok(serde_json::json!({
        "version": 1,
        "inputs": [],
        "outputs": [],
        "locktime": 0
    }))
}

// ============================================================================
// Phase 16: Plugin System Commands
// ============================================================================

/// Plugin info
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginInfo {
    pub id: String,
    pub name: String,
    pub description: String,
    pub version: String,
    pub author: String,
    pub homepage: Option<String>,
    pub permissions: Vec<String>,
    pub is_enabled: bool,
    pub is_installed: bool,
}

// In-memory storage for installed plugins
static INSTALLED_PLUGINS: Lazy<Arc<Mutex<HashMap<String, PluginInfo>>>> = Lazy::new(|| {
    Arc::new(Mutex::new(HashMap::new()))
});

/// List available plugins from marketplace
#[tauri::command]
pub async fn plugin_list_available() -> Result<Vec<PluginInfo>> {
    // Would fetch from plugin marketplace
    Ok(vec![
        PluginInfo {
            id: "defi-dashboard".to_string(),
            name: "DeFi Dashboard".to_string(),
            description: "Track your DeFi positions across protocols".to_string(),
            version: "1.0.0".to_string(),
            author: "Synor Team".to_string(),
            homepage: Some("https://synor.io/plugins/defi".to_string()),
            permissions: vec!["read:balance".to_string(), "read:transactions".to_string()],
            is_enabled: false,
            is_installed: false,
        },
        PluginInfo {
            id: "nft-gallery".to_string(),
            name: "NFT Gallery".to_string(),
            description: "Beautiful gallery view for your NFT collection".to_string(),
            version: "1.2.0".to_string(),
            author: "Community".to_string(),
            homepage: None,
            permissions: vec!["read:nfts".to_string()],
            is_enabled: false,
            is_installed: false,
        },
    ])
}

/// List installed plugins
#[tauri::command]
pub async fn plugin_list_installed() -> Result<Vec<PluginInfo>> {
    let plugins = INSTALLED_PLUGINS.lock().await;
    Ok(plugins.values().cloned().collect())
}

/// Install a plugin
#[tauri::command]
pub async fn plugin_install(
    state: State<'_, WalletState>,
    plugin_id: String,
) -> Result<PluginInfo> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    // Would fetch plugin from marketplace and install
    let plugin = PluginInfo {
        id: plugin_id.clone(),
        name: format!("Plugin {}", plugin_id),
        description: "Description".to_string(),
        version: "1.0.0".to_string(),
        author: "Unknown".to_string(),
        homepage: None,
        permissions: vec![],
        is_enabled: true,
        is_installed: true,
    };

    let mut plugins = INSTALLED_PLUGINS.lock().await;
    plugins.insert(plugin_id, plugin.clone());

    Ok(plugin)
}

/// Uninstall a plugin
#[tauri::command]
pub async fn plugin_uninstall(
    state: State<'_, WalletState>,
    plugin_id: String,
) -> Result<()> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut plugins = INSTALLED_PLUGINS.lock().await;
    plugins.remove(&plugin_id)
        .ok_or_else(|| Error::NotFound(format!("Plugin {} not found", plugin_id)))?;

    Ok(())
}

/// Enable/disable a plugin
#[tauri::command]
pub async fn plugin_toggle(
    state: State<'_, WalletState>,
    plugin_id: String,
    enabled: bool,
) -> Result<PluginInfo> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let mut plugins = INSTALLED_PLUGINS.lock().await;
    let plugin = plugins.get_mut(&plugin_id)
        .ok_or_else(|| Error::NotFound(format!("Plugin {} not found", plugin_id)))?;

    plugin.is_enabled = enabled;
    Ok(plugin.clone())
}

/// Get plugin settings
#[tauri::command]
pub async fn plugin_get_settings(
    plugin_id: String,
) -> Result<serde_json::Value> {
    let _plugin_id = plugin_id;
    // Would fetch plugin-specific settings
    Ok(serde_json::json!({}))
}

/// Update plugin settings
#[tauri::command]
pub async fn plugin_set_settings(
    state: State<'_, WalletState>,
    plugin_id: String,
    settings: serde_json::Value,
) -> Result<()> {
    if !state.is_unlocked().await {
        return Err(Error::WalletLocked);
    }

    let (_plugin_id, _settings) = (plugin_id, settings);
    // Would save plugin settings
    Ok(())
}