/*

loop {
    let _ = list_transaction_crdt::send(count, bft_crdt, &mut ws, &keys).await;

    let msg = ws.receive().await?;

    // deserialize the received websocket Frame into a string
    let msg = msg.into_text().unwrap().0;

    // deserialize the message into a Transaction struct
    let incoming_operation: SignedOp = serde_json::from_str(&msg).unwrap();

    let author = general_purpose::STANDARD.encode(&incoming_operation.author());
    println!("Received  from {:?}", author);

    bft_crdt.apply(incoming_operation.clone());

    count = count + 1;
    interval.tick().await;
}

*/

use async_trait::async_trait;
use bft_json_crdt::json_crdt::BaseCrdt;
use ezsockets::ClientConfig;
use fastcrypto::ed25519::Ed25519KeyPair;
use std::io::BufRead;

use crate::list_transaction_crdt::CrdtList;

struct Client {}

#[async_trait]
impl ezsockets::ClientExt for Client {
    type Call = ();

    async fn on_text(&mut self, text: String) -> Result<(), ezsockets::Error> {
        tracing::info!("received message: {text}");
        Ok(())
    }

    async fn on_binary(&mut self, bytes: Vec<u8>) -> Result<(), ezsockets::Error> {
        tracing::info!("received bytes: {bytes:?}");
        Ok(())
    }

    async fn on_call(&mut self, call: Self::Call) -> Result<(), ezsockets::Error> {
        let () = call;
        Ok(())
    }
}

pub(crate) async fn start(keys: Ed25519KeyPair, bft_crdt: &mut BaseCrdt<CrdtList>) {
    tracing_subscriber::fmt::init();
    let config = ClientConfig::new("ws://localhost:8080/websocket");
    let (handle, future) = ezsockets::connect(|_client| Client {}, config).await;
    tokio::spawn(async move {
        future.await.unwrap();
    });
    let stdin = std::io::stdin();
    let lines = stdin.lock().lines();
    for line in lines {
        let line = line.unwrap();
        tracing::info!("sending {line}");
        handle.text(line).unwrap();
    }
}