/*

use kuska_handshake::async_std::BoxStream;
use kuska_sodiumoxide::crypto::sign::ed25519;
use kuska_ssb::discovery;
use kuska_ssb::keystore;
use kuska_ssb::keystore::OwnedIdentity;
*/
use std::fmt::Debug;

use async_std::io::Read;

use kuska_ssb::api::dto::WhoAmIOut;
use kuska_ssb::feed::Feed;
use kuska_ssb::rpc::{RecvMsg, RequestNo, RpcReader};

use crate::error::GolgiError;

pub fn getsubset_res_parse(body: &[u8]) -> Result<String, GolgiError> {
    // TODO: cleanup with proper error handling etc.
    Ok(std::str::from_utf8(body).unwrap().to_string())
}

pub fn feed_res_parse(body: &[u8]) -> Result<Feed, GolgiError> {
    Ok(Feed::from_slice(body)?)
}

//pub fn publish_res_parse(body: &[u8]) -> Result<PublishOut, GolgiError> {
pub fn publish_res_parse(body: &[u8]) -> Result<String, GolgiError> {
    //Ok(serde_json::from_slice(body)?)
    // TODO: cleanup with proper error handling etc.
    Ok(std::str::from_utf8(body).unwrap().to_string())
}

pub fn whoami_res_parse(body: &[u8]) -> Result<WhoAmIOut, GolgiError> {
    Ok(serde_json::from_slice(body)?)
}

pub async fn get_async<'a, R, T, F>(
    rpc_reader: &mut RpcReader<R>,
    req_no: RequestNo,
    f: F,
) -> Result<T, GolgiError>
where
    R: Read + Unpin,
    F: Fn(&[u8]) -> Result<T, GolgiError>,
    T: Debug,
{
    loop {
        let (id, msg) = rpc_reader.recv().await?;
        if id == req_no {
            match msg {
                RecvMsg::RpcResponse(_type, body) => {
                    return f(&body).map_err(|err| err);
                }
                RecvMsg::ErrorResponse(message) => {
                    return Err(GolgiError::Sbot(message));
                }
                _ => {}
            }
        }
    }
}

pub async fn print_source_until_eof<'a, R, T, F>(
    rpc_reader: &mut RpcReader<R>,
    req_no: RequestNo,
    f: F,
) -> Result<(), GolgiError>
where
    R: Read + Unpin,
    F: Fn(&[u8]) -> Result<T, GolgiError>,
    T: Debug + serde::Deserialize<'a>,
{
    loop {
        let (id, msg) = rpc_reader.recv().await?;
        if id == req_no {
            match msg {
                RecvMsg::RpcResponse(_type, body) => {
                    let display = f(&body)?;
                    println!("{:?}", display);
                }
                RecvMsg::ErrorResponse(message) => {
                    return Err(GolgiError::Sbot(message));
                }
                RecvMsg::CancelStreamRespose() => break,
                _ => {}
            }
        }
    }
    Ok(())
}