use crate::discovery::model::Peer;
use crate::event::AppEvent;
use crate::transfer::model::Transfer;

pub async fn create_event_stream(sink: crate::frb_generated::StreamSink<AppEvent>) {
    let mut rx = get_appstate().await.event_tx.subscribe();
    tokio::spawn(async move {
        while let Ok(event) = rx.recv().await {
            let _ = sink.add(event);
        }
    });
}

use crate::get_appstate;

pub async fn get_save_path() -> String {
    get_appstate().await.config.get_save_path()
}

pub async fn set_save_path(save_path: String) {
    get_appstate().await.config.set_save_path(save_path);
}

pub async fn set_hostname(hostname: String) {
    get_appstate().await.config.set_hostname(hostname);
}

pub async fn get_hostname() -> String {
    get_appstate().await.config.get_hostname()
}

pub async fn get_auto_accept() -> bool {
    get_appstate().await.config.get_auto_accept()
}

pub async fn set_auto_accept(auto_accept: bool) {
    get_appstate().await.config.set_auto_accept(auto_accept);
}

pub async fn get_save_history() -> bool {
    get_appstate().await.config.get_save_history()
}

pub async fn set_save_history(save_history: bool) {
    get_appstate().await.config.set_save_history(save_history);
}

pub async fn get_enable_tls() -> bool {
    get_appstate().await.config.get_enable_tls()
}

pub async fn set_enable_tls(enable_tls: bool) {
    get_appstate().await.config.set_enable_tls(enable_tls);
}

pub async fn get_peers() -> Result<Vec<Peer>, String> {
    Ok(get_appstate().await.discovery.get_peers().await)
}

pub async fn send_file(target: Peer, target_ip: &str, file_path: &str) -> Result<(), String> {
    let sender = get_appstate().await.discovery.get_self().await;
    match get_appstate()
        .await
        .transfer
        .send_file(target, target_ip, sender, file_path)
        .await
    {
        Ok(_) => Ok(()),
        Err(e) => Err(e.to_string()),
    }
}

pub async fn send_text(target: Peer, target_ip: &str, text: &str) -> Result<(), String> {
    let sender = get_appstate().await.discovery.get_self().await;
    match get_appstate()
        .await
        .transfer
        .send_text(target, target_ip, sender, text)
        .await
    {
        Ok(_) => Ok(()),
        Err(e) => Err(e.to_string()),
    }
}

pub async fn send_folder(target: Peer, target_ip: &str, folder_path: &str) -> Result<(), String> {
    let sender = get_appstate().await.discovery.get_self().await;
    match get_appstate()
        .await
        .transfer
        .send_folder(target, target_ip, sender, folder_path)
        .await
    {
        Ok(_) => Ok(()),
        Err(e) => Err(e.to_string()),
    }
}

pub async fn get_transfers() -> Vec<Transfer> {
    get_appstate().await.transfer.get_transfers()
}

pub async fn resolve_pending_request(id: &str, accept: bool, path: &str) {
    get_appstate()
        .await
        .transfer
        .make_decision(id, accept, path);
}

pub async fn cancel_transfer(id: &str) {
    get_appstate().await.transfer.cancel(id);
}

pub async fn delete_transfer(id: &str) {
    get_appstate().await.transfer.delete(id);
}

pub async fn clear_transfers() {
    get_appstate().await.transfer.clear_transfers();
}

pub async fn is_trusted(peer_id: &str) -> bool {
    get_appstate().await.trust.is_trusted(peer_id)
}

pub async fn trust_peer(peer_id: &str) -> Result<(), String> {
    if let Some(peer) = get_appstate().await.discovery.get_peer(peer_id).await {
        get_appstate().await.trust.trust(peer_id, &peer.public_key);
    }
    Ok(())
}

pub async fn untrust_peer(peer_id: &str) {
    get_appstate().await.trust.untrust(peer_id);
}