use bdk::{
    keys::{
        bip39::{Language, Mnemonic, WordCount},
        DerivableKey, ExtendedKey, GeneratableKey, GeneratedKey,
    },
    miniscript,
};

use std::{
    fs::{self, File},
    io::Write,
    path::PathBuf,
};

/// Write the mnemonic to a file in the node's side directory
///
/// TODO: obviously spitting the mnemonic out to the console is not for production
pub(crate) fn write(mnemonic_path: &PathBuf) -> Result<(), std::io::Error> {
    let mnemonic = make_mnemonic();
    let mut file = File::create(mnemonic_path)?;
    println!("mnemonic: {mnemonic}");
    file.write(mnemonic.as_bytes())?;

    Ok(())
}

pub(crate) fn load_from_file(side_dir: &PathBuf) -> anyhow::Result<ExtendedKey> {
    let mnemonic_path = crate::utils::side_paths(side_dir.clone()).1; // TODO: this tuple stinks
    let mnemonic_words = fs::read_to_string(mnemonic_path).expect("couldn't read bitcoin key file");
    println!("Creating extended key from mnemonic: {mnemonic_words}");
    generate_extended_key(mnemonic_words)
}

/// Creates Signet Bitcoin descriptors from a mnemonic
fn generate_extended_key(mnemonic_words: String) -> anyhow::Result<ExtendedKey> {
    let mnemonic = Mnemonic::parse(mnemonic_words).unwrap();

    // Generate the extended key
    let xkey: ExtendedKey = mnemonic
        .into_extended_key()
        .expect("couldn't turn mnemonic into xkey");

    Ok(xkey)
}

fn make_mnemonic() -> String {
    let mnemonic: GeneratedKey<_, miniscript::Segwitv0> =
        Mnemonic::generate((WordCount::Words12, Language::English)).unwrap();
    mnemonic.to_string()
}
