use log::{error, warn};
use sha2::Digest;
use sha2::Sha256;
use url::Url;
use crate::apiworker::APIWorkerMessage;
use crate::daemon::ThreadMessageSender;
use crate::nebulaworker::NebulaWorkerMessage;
use crate::socketworker::SocketWorkerMessage;
use crate::timerworker::TimerWorkerMessage;

pub fn sha256(bytes: &[u8]) -> String {
    let mut hasher = Sha256::new();
    hasher.update(bytes);
    let digest = hasher.finalize();
    hex::encode(digest)
}

pub fn check_server_url(server: &str) {
    let api_base = match Url::parse(server) {
        Ok(u) => u,
        Err(e) => {
            error!("Invalid server url `{}`: {}", server, e);
            std::process::exit(1);
        }
    };
    match api_base.scheme() {
        "http" => {
            warn!("HTTP api urls are not reccomended. Please switch to HTTPS if possible.")
        }
        "https" => (),
        _ => {
            error!(
                "Unsupported protocol `{}` (expected one of http, https)",
                api_base.scheme()
            );
            std::process::exit(1);
        }
    }
}

pub fn shutdown(transmitter: &ThreadMessageSender) {
    match transmitter
        .nebula_thread
        .send(NebulaWorkerMessage::Shutdown)
    {
        Ok(_) => (),
        Err(e) => {
            error!(
                    "Error sending shutdown message to nebula worker thread: {}",
                    e
                );
        }
    }
    match transmitter
        .api_thread
        .send(APIWorkerMessage::Shutdown)
    {
        Ok(_) => (),
        Err(e) => {
            error!("Error sending shutdown message to api worker thread: {}", e);
        }
    }
    match transmitter
        .socket_thread
        .send(SocketWorkerMessage::Shutdown)
    {
        Ok(_) => (),
        Err(e) => {
            error!(
                    "Error sending shutdown message to socket worker thread: {}",
                    e
                );
        }
    }
    match transmitter
        .timer_thread
        .send(TimerWorkerMessage::Shutdown)
    {
        Ok(_) => (),
        Err(e) => {
            error!(
                    "Error sending shutdown message to timer worker thread: {}",
                    e
                );
        }
    }
}