use uba::{generate, retrieve_full, AddressType};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Your seed phrase (use a secure one in production!)
    let seed = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
    
    // Nostr relay URLs
    let relays = vec![
        "wss://relay.damus.io".to_string(),
        "wss://nos.lol".to_string(),
    ];
    
    // Generate a UBA with multi-layer addresses
    let uba = generate(seed, Some("my-wallet"), &relays).await?;
    println!("UBA: {}", uba);
    
    // Retrieve all addresses across all layers
    let addresses = retrieve_full(&uba, &relays).await?;
    
    // Access specific layer addresses
    if let Some(btc_addresses) = addresses.get_addresses(&AddressType::P2WPKH) {
        println!("Bitcoin SegWit: {:?}", btc_addresses);
    }
    if let Some(liquid_addresses) = addresses.get_addresses(&AddressType::Liquid) {
        println!("Liquid: {:?}", liquid_addresses);
    }
    if let Some(lightning_ids) = addresses.get_addresses(&AddressType::Lightning) {
        println!("Lightning Node IDs: {:?}", lightning_ids);
    }
    if let Some(nostr_pubkeys) = addresses.get_addresses(&AddressType::Nostr) {
        println!("Nostr Public Keys: {:?}", nostr_pubkeys);
    }
    
    Ok(())
}

use uba::{generate_with_config, retrieve_with_config, UbaConfig, derive_encryption_key, generate_random_key};

// Generate UBA with passphrase-derived encryption
let mut config = UbaConfig::default();
let encryption_key = derive_encryption_key("my-secret-passphrase", None);
config.set_encryption_key(encryption_key);

let uba = generate_with_config(seed, Some("encrypted-wallet"), &[], config.clone()).await?;

// Retrieve with the same encryption key
let addresses = retrieve_with_config(&uba, &[], config).await?;

// Or use a random encryption key
let mut config2 = UbaConfig::default();
let random_key = generate_random_key();
config2.set_encryption_key(random_key);
println!("Save this key: {}", hex::encode(random_key));

use uba::{default_public_relays, UbaConfig};

// Use default public relays (automatic)
let config = UbaConfig::default();
let uba = generate_with_config(seed, None, &[], config).await?;

// View available public relays
println!("Public relays: {:?}", default_public_relays());

// Use custom relays
let mut config = UbaConfig::default();
config.set_custom_relays(vec![
    "wss://my-relay.com".to_string(),
    "wss://relay.damus.io".to_string(),
]);

// Add to default relays
let mut config = UbaConfig::default();
config.add_custom_relay("wss://my-personal-relay.com".to_string());

use uba::{UbaConfig, AddressType};

let mut config = UbaConfig::default();

// Set specific counts per address type
config.set_address_count(AddressType::P2WPKH, 10);
config.set_address_count(AddressType::Liquid, 5);
config.set_address_count(AddressType::Lightning, 3);

// Set all Bitcoin L1 types at once
config.set_bitcoin_l1_counts(8);

// Set all types to the same count
config.set_all_counts(7);

let uba = generate_with_config(seed, None, &[], config).await?;

use uba::{generate, generate_with_config, UbaConfig, Network};

// Simple generation (includes all layers)
let uba = generate(seed, Some("wallet-label"), &relay_urls).await?;

// With custom configuration
let mut config = UbaConfig::default();
config.network = Network::Testnet;
config.max_addresses_per_type = 10;
config.encrypt_data = true;

let uba = generate_with_config(seed, Some("wallet-label"), &relay_urls, config).await?;

use uba::{retrieve, retrieve_full, AddressType};

// Get all addresses as a flat vector
let addresses = retrieve(&uba, &relay_urls).await?;

// Get full structured data with layer separation
let bitcoin_addresses = retrieve_full(&uba, &relay_urls).await?;

// Access specific layers
if let Some(btc_legacy) = bitcoin_addresses.get_addresses(&AddressType::P2PKH) {
    println!("Bitcoin Legacy: {:?}", btc_legacy);
}
if let Some(liquid_addrs) = bitcoin_addresses.get_addresses(&AddressType::Liquid) {
    println!("Liquid Sidechain: {:?}", liquid_addrs);
}
if let Some(ln_nodes) = bitcoin_addresses.get_addresses(&AddressType::Lightning) {
    println!("Lightning Network: {:?}", ln_nodes);
}

use uba::{AddressGenerator, UbaConfig, AddressType};

let config = UbaConfig::default();
let generator = AddressGenerator::new(config);

// Generate addresses without publishing to relays
let addresses = generator.generate_addresses(seed, Some("offline".to_string()))?;

println!("Total addresses: {}", addresses.len());
for addr_type in [AddressType::P2WPKH, AddressType::Liquid, AddressType::Lightning, AddressType::Nostr] {
    if let Some(addrs) = addresses.get_addresses(&addr_type) {
        println!("{:?}: {} addresses", addr_type, addrs.len());
    }
}

use uba::{update_uba, UbaConfig, AddressType};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let original_event_id = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
    let seed = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
    let relays = vec!["wss://relay.damus.io".to_string()];
    
    let mut config = UbaConfig::default();
    // Update configuration - disable Lightning for this update
    config.set_address_type_enabled(AddressType::Lightning, false);
    config.set_bitcoin_l1_counts(5); // Increase Bitcoin L1 addresses to 5 each
    
    let updated_uba = update_uba(original_event_id, seed, &relays, config).await?;
    println!("Updated UBA: {}", updated_uba);
    
    Ok(())
}

let mut config = UbaConfig::default();

// Individual address type control
config.set_address_type_enabled(AddressType::P2WPKH, true);
config.set_address_type_enabled(AddressType::Lightning, false);

// Bulk operations
config.enable_bitcoin_l1();     // Enable P2PKH, P2SH, P2WPKH, P2TR
config.disable_bitcoin_l1();    // Disable all Bitcoin L1 types
config.enable_all_address_types();  // Enable all types
config.disable_all_address_types(); // Disable all types

// Check enabled types
let enabled_types = config.get_enabled_address_types();
println!("Enabled: {:?}", enabled_types);

use uba::{UbaConfig, Network, derive_encryption_key};

let mut config = UbaConfig::default();

// Basic configuration
config.network = Network::Bitcoin;           // Bitcoin network
config.relay_timeout = 10;                   // Relay timeout in seconds
config.max_addresses_per_type = 1;           // Default addresses per type (changed from 5 to 1)

// Encryption configuration (optional)
let encryption_key = derive_encryption_key("my-passphrase", None);
config.set_encryption_key(encryption_key);   // Enable encryption

// Relay configuration
config.set_custom_relays(vec![               // Use custom relays
    "wss://relay.damus.io".to_string(),
    "wss://nos.lol".to_string(),
]);

// Address count configuration
config.set_all_counts(10);                   // 10 addresses per type
config.set_address_count(AddressType::Lightning, 3); // Override Lightning to 3