use bft_crdt_derive::add_crdt_fields;
use bft_json_crdt::json_crdt::SignedOp;
use bft_json_crdt::keypair::KeyPair;
use bft_json_crdt::{
    json_crdt::{BaseCrdt, CrdtNode, IntoCrdtNode},
    keypair::{make_keypair, ED25519_PUBLIC_KEY_LENGTH},
    list_crdt::ListCrdt,
    op::ROOT_ID,
};
use serde::{Deserialize, Serialize};
use tokio::time::{self};
use websockets::WebSocket;

/// Starts a websocket and periodically sends a BFT-CRDT message to the websocket server
pub(crate) async fn start() -> Result<(), websockets::WebSocketError> {
    println!("connecting to websocket at ws://127.0.0.1:8080/");
    let mut ws = WebSocket::connect("ws://127.0.0.1:8080/").await?;

    // set up a new BFT-CRDT
    let keys = make_keypair();
    let mut bft_crdt = BaseCrdt::<ListExample>::new(&keys);
    println!("Generated a new CRDT with public key: {}", keys.public());

    // generate a placeholder transaction
    let transaction = generate_transaction();

    let json = convert_to_json(&transaction).unwrap();

    // next job is to keep adding to this guy
    let signed_op = bft_crdt.doc.list.insert(ROOT_ID, json.clone()).sign(&keys);
    println!("SignedOp before send is: {:?}", signed_op);

    let mut interval = every_two_seconds();
    loop {
        interval.tick().await;
        println!("Sending: {:?}", signed_op);
        ws.send_text(serde_json::to_string(&signed_op).unwrap())
            .await?;

        let msg = ws.receive().await?;
        println!("Received: {:?}", msg);

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

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

        // TODO:  bft_crdt.apply() changes in here when we receive socket input from other nodes
        bft_crdt.apply(operation);
        println!("New crdt state is: {}", bft_crdt.doc.view())
    }
}

fn every_two_seconds() -> time::Interval {
    time::interval(time::Duration::from_secs(2))
}

#[add_crdt_fields]
#[derive(Clone, CrdtNode, Serialize, Deserialize)]
struct ListExample {
    list: ListCrdt<Transaction>, // switch to Transaction as soon as char is working
}

/// A fake Transaction struct we can use as a simulated payload
#[add_crdt_fields]
#[derive(Clone, CrdtNode, Serialize, Deserialize)]
struct Transaction {
    from: String,
    to: String,
    amount: f64,
}

fn generate_transaction() -> Transaction {
    Transaction {
        from: "Alice".to_string(),
        to: "Bob".to_string(),
        amount: 100.0,
        path: vec![],
        id: [0; ED25519_PUBLIC_KEY_LENGTH],
    }
}

fn convert_to_json(transaction: &Transaction) -> serde_json::Result<String> {
    let json = serde_json::to_string(&transaction).unwrap();
    Ok(json)
}