use tokio::sync::mpsc::UnboundedSender;
use color_eyre::Result;
use subxt::{backend::{legacy::rpc_methods::SystemHealth, rpc::RpcClient}, rpc_params};

use crate::{action::Action, types::PeerInformation};

pub async fn get_node_name(
    action_tx: &UnboundedSender<Action>,
    rpc_client: &RpcClient,
) -> Result<()> {
    let maybe_node_name = rpc_client
        .request("system_name", rpc_params![])
        .await
        .ok();
    action_tx.send(Action::SetNodeName(maybe_node_name))?;
    Ok(())
}

pub async fn get_system_health(
    action_tx: &UnboundedSender<Action>,
    rpc_client: &RpcClient,
) -> Result<()> {
    let (maybe_peers, is_syncing, should_have_peers) = rpc_client
        .request("system_health", rpc_params![])
        .await
        .ok()
        .map_or((None, false, false), |health: SystemHealth| (
                Some(health.peers),
                health.is_syncing,
                health.should_have_peers,
        ));
    action_tx.send(Action::SetSystemHealth(
            maybe_peers, 
            is_syncing, 
            should_have_peers))?;
    Ok(())
}

pub async fn get_genesis_hash(
    action_tx: &UnboundedSender<Action>,
    rpc_client: &RpcClient,
) -> Result<()> {
    let params = rpc_params![0u32];
    let maybe_genesis_hash = rpc_client
        .request("chain_getBlockHash", params)
        .await
        .ok();
    action_tx.send(Action::SetGenesisHash(maybe_genesis_hash))?;
    Ok(())
}

pub async fn get_chain_name(
    action_tx: &UnboundedSender<Action>,
    rpc_client: &RpcClient,
) -> Result<()> {
    let maybe_chain_name = rpc_client
        .request("system_chain", rpc_params![])
        .await
        .ok();
    action_tx.send(Action::SetChainName(maybe_chain_name))?;
    Ok(())
}

pub async fn get_system_version(
    action_tx: &UnboundedSender<Action>,
    rpc_client: &RpcClient,
) -> Result<()> {
    let maybe_system_version = rpc_client
        .request("system_version", rpc_params![])
        .await
        .ok();
    action_tx.send(Action::SetChainVersion(maybe_system_version))?;
    Ok(())
}

pub async fn get_pending_extrinsics(
    action_tx: &UnboundedSender<Action>,
    rpc_client: &RpcClient,
) -> Result<()> {
    let pending_extrinsics: Vec<String> = rpc_client
        .request("author_pendingExtrinsics", rpc_params![])
        .await
        .unwrap_or_default();
    action_tx.send(Action::SetPendingExtrinsicsLength(pending_extrinsics.len()))?;
    Ok(())
}

pub async fn get_connected_peers(
    action_tx: &UnboundedSender<Action>,
    rpc_client: &RpcClient,
) -> Result<()> {
    let connected_peers: Vec<PeerInformation> = rpc_client
        .request("system_peers", rpc_params![])
        .await
        .unwrap_or_default();
    action_tx.send(Action::SetConnectedPeers(connected_peers))?;
    Ok(())
}

pub async fn get_listen_addresses(
    action_tx: &UnboundedSender<Action>,
    rpc_client: &RpcClient,
) -> Result<()> {
    let listen_addresses: Vec<String> = rpc_client
        .request("system_localListenAddresses", rpc_params![])
        .await
        .unwrap_or_default();
    action_tx.send(Action::SetListenAddresses(listen_addresses))?;
    Ok(())
}

pub async fn get_local_identity(
    action_tx: &UnboundedSender<Action>,
    rpc_client: &RpcClient,
) -> Result<()> {
    let local_peer_id: String = rpc_client
        .request("system_localPeerId", rpc_params![])
        .await
        .unwrap_or_default();
    action_tx.send(Action::SetLocalIdentity(local_peer_id))?;
    Ok(())
}

pub async fn rotate_keys(
    action_tx: &UnboundedSender<Action>,
    rpc_client: &RpcClient,
) -> Result<()> {
    let rotated_keys: String = rpc_client
        .request("author_rotateKeys", rpc_params![])
        .await
        .unwrap_or_default();
    action_tx.send(Action::StoreRotatedKeys(rotated_keys))?;
    Ok(())
}