use std::{thread, time};

use crate::error::PeachConfigError;
use peach_lib::sbot::init_sbot;

static MAX_NUM_ATTEMPTS: u8 = 10;

/// Utility function to wait for a successful whoami call with sbot
/// After each attempt to call whoami it waits 2 seconds,
/// and if after MAX_NUM_ATTEMPTS (10) there is no successful whoami call
/// it returns an Error. Otherwise it returns Ok(sbot_id).
pub async fn wait_for_sbot() -> Result<String, PeachConfigError> {
    let mut num_attempts = 0;
    let mut whoami = None;

    while num_attempts < MAX_NUM_ATTEMPTS {
        let mut sbot = None;

        let sbot_res = init_sbot().await;
        match sbot_res {
            Ok(sbot_instance) => {
                sbot = Some(sbot_instance);
            }
            Err(err) => {
                eprintln!("failed to connect to sbot: {:?}", err);
            }
        }

        if sbot.is_some() {
            let sbot_id_res = sbot.unwrap().whoami().await;
            match sbot_id_res {
                Ok(sbot_id) => {
                    whoami = Some(sbot_id);
                    break;
                }
                Err(err) => {
                    eprintln!("whoami failed: {:?}", err);
                }
            }
        }

        println!("trying to connect to sbot again {:?}", num_attempts);
        num_attempts += 1;

        let sleep_duration = time::Duration::from_secs(2);
        thread::sleep(sleep_duration);
    }

    whoami.ok_or(PeachConfigError::WaitForSbotError {
        message: "Failed to find sbot_id after 10 attempts".to_string(),
    })
}