use std::io::Write;

use bdk::{bitcoin::Script, KeychainKind};
use bdk_esplora::esplora_client;

use crate::{keys, utils};

pub async fn run() -> Result<(), anyhow::Error> {
    let dave = utils::home(&"dave".to_string());
    let sammy = utils::home(&"sammy".to_string());

    // Load mnemonics from disk
    let dave_wallet = keys::bitcoin::load_from_file(&dave).unwrap();
    let sammy_wallet = keys::bitcoin::load_from_file(&sammy).unwrap();

    let dave_address = dave_wallet.get_address(bdk::wallet::AddressIndex::New)?;
    println!("Dave address: {:?}", dave_address);

    let sammy_address = sammy_wallet.get_address(bdk::wallet::AddressIndex::New)?;
    println!("Sammy address: {:?}", sammy_address);

    print!("Syncing...");
    let client = esplora_client::Builder::new("http://signet.bitcoindevkit.net").build_async()?;

    fn generate_inspect(kind: KeychainKind) -> impl FnMut(u32, &Script) + Send + Sync + 'static {
        let mut once = Some(());
        let mut stdout = std::io::stdout();
        move |spk_i, _| {
            match once.take() {
                Some(_) => print!("\nScanning keychain [{:?}]", kind),
                None => print!(" {:<3}", spk_i),
            };
            stdout.flush().expect("must flush");
        }
    }

    // let request = dave_wallet
    //     .start_full_scan()
    //     .inspect_spks_for_all_keychains({
    //         let mut once = BTreeSet::<KeychainKind>::new();
    //         move |keychain, spk_i, _| {
    //             match once.insert(keychain) {
    //                 true => print!("\nScanning keychain [{:?}]", keychain),
    //                 false => print!(" {:<3}", spk_i),
    //             }
    //             std::io::stdout().flush().expect("must flush")
    //         }
    //     })
    //     .inspect_spks_for_keychain(
    //         KeychainKind::External,
    //         generate_inspect(KeychainKind::External),
    //     )
    //     .inspect_spks_for_keychain(
    //         KeychainKind::Internal,
    //         generate_inspect(KeychainKind::Internal),
    //     );

    // let mut update = client
    //     .full_scan(request, STOP_GAP, PARALLEL_REQUESTS)
    //     .await?;
    // let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_secs();
    // let _ = update.graph_update.update_last_seen_unconfirmed(now);

    // wallet.apply_update(update)?;
    // if let Some(changeset) = wallet.take_staged() {
    //     db.write(&changeset)?;
    // }

    let dave_balance = dave_wallet.get_balance()?;
    println!("Wallet balance before syncing: {} sats", dave_balance);

    let sammy_balance = sammy_wallet.get_balance()?;
    println!("Wallet balance before syncing: {} sats", sammy_balance);

    Ok(())
}