use crate::{keys, utils};

use bdk::bitcoin::base64;
use bdk::bitcoin::psbt::PartiallySignedTransaction;
use bdk::blockchain::Progress;
use bdk::database::MemoryDatabase;
use bdk::wallet::AddressIndex::{self, New};
use bdk::{blockchain::ElectrumBlockchain, electrum_client, SyncOptions};
use bdk::{FeeRate, SignOptions, TransactionDetails, Wallet};

#[derive(Debug)]
pub struct CustomProgress;

impl Progress for CustomProgress {
    fn update(&self, progress: f32, message: Option<String>) -> Result<(), bdk::Error> {
        println!("Progress: {} - {:?}", progress, message);
        Ok(())
    }
}

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

    // Verify explicitly that the address is derived as expected
    let expected_address = "tb1q88e45m4akrg2y00n4077vn90q8qw0svz7dss6k";
    let derived_address = dave_wallet.get_address(AddressIndex::Peek(0))?.to_string();
    assert_eq!(expected_address, derived_address);

    let blockchain = ElectrumBlockchain::from(electrum_client::Client::new(
        "ssl://electrum.blockstream.info:60002",
    )?);

    println!("Syncing...");
    dave_wallet.sync(&blockchain, SyncOptions::default())?;

    println!(
        "Wallet balance for {} after syncing: {:?} sats on network {}",
        dave_wallet.get_address(bdk::wallet::AddressIndex::Peek(0))?,
        dave_wallet.get_balance()?,
        dave_wallet.network()
    );

    let transactions = dave_wallet.list_transactions(false)?;
    println!("Transaction History: {:?}", transactions);

    let (mut psbt, details) = build_sending_tx(&dave_wallet).expect("psbt fukked");

    println!("Transaction details: {:#?}", details);
    println!("Unsigned PSBT: {}", base64::encode(psbt.serialize()));
    // let mut psbt = Psbt::deserialize(&base64::decode(psbt).unwrap())?;
    let _finalized = dave_wallet.sign(&mut psbt, SignOptions::default())?;

    println!("Finalized: {}", _finalized);

    Ok(())
}

fn build_sending_tx(
    wallet: &Wallet<MemoryDatabase>,
) -> anyhow::Result<(PartiallySignedTransaction, TransactionDetails), anyhow::Error> {
    let send_to = wallet.get_address(New)?;

    let mut builder = wallet.build_tx();
    builder
        .add_recipient(send_to.script_pubkey(), 500)
        .enable_rbf()
        .do_not_spend_change()
        .fee_rate(FeeRate::from_sat_per_vb(5.0));
    Ok(builder.finish()?)
}