use serde_json;
use std::thread;
use tungstenite::{connect, Message};
use url::Url;
use watch;

/// Its very nice bot
///
/// # Example
///
/// ```
/// println!("yes");
/// ```
fn main() {
    let (tx1, mut rx1) = watch::channel(1.0);
    let (tx2, mut rx2) = watch::channel(1.0);
    let (tx3, mut rx3) = watch::channel(1.0);
    let (tx4, mut rx4) = watch::channel(1.0);
    let (txblz, mut rxblz) = watch::channel(1.0);
    let (txbake, mut rxbake) = watch::channel(1.0);
    let mut maxim = 0.0;

    thread::spawn(move || {
        let (mut socket, response) =
            connect(Url::parse("wss://stream.binance.com:9443/ws/blzusdt@aggTrade").unwrap())
                .expect("Failed to connect Binance");
        println!("Connecting to the server!");
        println!("Response HTTP Code {}", response.status());

        loop {
            let msg = socket.read().expect("Error read msg");
            let msg = match msg {
                tungstenite::Message::Text(s) => s,
                _ => {
                    println!("EEEEEEE");
                    continue;
                }
            };
            let msg_parsed: serde_json::Value = serde_json::from_str(&msg).expect("Failed to json");
            let msg_ask = msg_parsed["p"].as_str().expect("ask");
            // let msg_qty = msg_parsed["A"].as_str().expect("byd");
            let msg_ask: f64 = msg_ask.parse().expect("byby");
            // let msg_qty: f64 = msg_qty.parse().expect("baba");
            txblz.send(msg_ask);
        }
    });


    thread::spawn(move || {
        let (mut socket, response) =
            connect(Url::parse("wss://stream.binance.com:9443/ws/bakeusdt@aggTrade").unwrap())
                .expect("Failed to connect Binance");
        println!("Connecting to the server!");
        println!("Response HTTP Code {}", response.status());

        loop {
            let msg = socket.read().expect("Error read msg");
            let msg = match msg {
                tungstenite::Message::Text(s) => s,
                _ => {
                    println!("EEEEEEE");
                    continue;
                }
            };
            let msg_parsed: serde_json::Value = serde_json::from_str(&msg).expect("Failed to json");
            let msg_ask = msg_parsed["p"].as_str().expect("ask");
            // let msg_qty = msg_parsed["A"].as_str().expect("byd");
            let msg_ask: f64 = msg_ask.parse().expect("byby");
            // let msg_qty: f64 = msg_qty.parse().expect("baba");
            txbake.send(msg_ask);
        }
    });


    thread::spawn(move || {
        let (mut socket, response) =
            connect(Url::parse("wss://stream.binance.com:9443/ws/blzbtc@aggTrade").unwrap())
                .expect("Failed to connect Binance");
        println!("Connecting to the server!");
        println!("Response HTTP Code {}", response.status());

        loop {
            let msg = socket.read().expect("Error read msg");
            let msg = match msg {
                tungstenite::Message::Text(s) => s,
                _ => {
                    println!("EEEEEEE");
                    continue;
                }
            };
            let msg_parsed: serde_json::Value = serde_json::from_str(&msg).expect("Failed to json");
            let msg_ask = msg_parsed["p"].as_str().expect("ask");
            // let msg_qty = msg_parsed["A"].as_str().expect("byd");
            let msg_ask: f64 = msg_ask.parse().expect("byby");
            // let msg_qty: f64 = msg_qty.parse().expect("baba");
            tx3.send(msg_ask);
        }
    });


    thread::spawn(move || {
        let (mut socket, response) =
            connect(Url::parse("wss://stream.binance.com:9443/ws/bakebtc@aggTrade").unwrap())
                .expect("Failed to connect Binance");
        println!("Connecting to the server!");
        println!("Response HTTP Code {}", response.status());

        loop {
            let msg = socket.read().expect("Error read msg");
            let msg = match msg {
                tungstenite::Message::Text(s) => s,
                _ => {
                    println!("EEEEEEE");
                    continue;
                }
            };
            let msg_parsed: serde_json::Value = serde_json::from_str(&msg).expect("Failed to json");
            let msg_ask = msg_parsed["p"].as_str().expect("ask");
            // let msg_qty = msg_parsed["A"].as_str().expect("byd");
            let msg_ask: f64 = msg_ask.parse().expect("byby");
            // let msg_qty: f64 = msg_qty.parse().expect("baba");
            tx4.send(msg_ask);
        }
    });


    thread::spawn(move || {
        let (mut socket, response) =
            connect(Url::parse("wss://stream.binance.com:9443/ws/btcusdt@aggTrade").unwrap())
                .expect("Failed to connect Binance");
        println!("Connecting to the server!");
        println!("Response HTTP Code {}", response.status());

        loop {
            let msg = socket.read().expect("Error read msg");
            let msg = match msg {
                tungstenite::Message::Text(s) => s,
                _ => {
                    println!("EEEEEEE");
                    continue;
                }
            };
            let msg_parsed: serde_json::Value = serde_json::from_str(&msg).expect("Failed to json");
            let msg_ask = msg_parsed["p"].as_str().expect("ask");
            // let msg_qty = msg_parsed["A"].as_str().expect("byd");
            let msg_ask: f64 = msg_ask.parse().expect("byby");
            // let msg_qty: f64 = msg_qty.parse().expect("baba");
            tx1.send(msg_ask);
        }
    });

    thread::spawn(move || {
        let (mut socket, response) =
            connect(Url::parse("wss://stream.binance.com:9443/ws/maticbtc@aggTrade").unwrap())
                .expect("Failed to connect Binance");
        println!("Connecting to the server!");
        println!("Response HTTP Code {}", response.status());

        loop {
            let msg = socket.read().expect("Error read msg");
            let msg = match msg {
                tungstenite::Message::Text(s) => s,
                _ => {
                    println!("EEEEEEE");
                    continue;
                }
            };
            let msg_parsed: serde_json::Value = serde_json::from_str(&msg).expect("Failed to json");
            let msg_ask = msg_parsed["p"].as_str().expect("ask");
            // let msg_qty = msg_parsed["A"].as_str().expect("byd");
            let msg_ask: f64 = msg_ask.parse().expect("byby");
            // let msg_qty: f64 = msg_qty.parse().expect("baba");
            tx2.send(msg_ask);
        }
    });

    let (mut socket, response) =
        connect(Url::parse("wss://stream.binance.com:9443/ws/maticusdt@aggTrade").unwrap())
            .expect("Failed to connect Binance");
    println!("Connecting to the server!");
    println!("Response HTTP Code {}", response.status());

    loop {
        let msg = socket.read().expect("Error read msg");
        let msg = match msg {
            tungstenite::Message::Text(s) => s,
            _ => {
                println!("EEEEEEE");
                continue;
            }
        };
        let msg_parsed: serde_json::Value = serde_json::from_str(&msg).expect("Failed to json");
        let msg_ask = msg_parsed["p"].as_str().expect("ask");
        // let msg_qty = msg_parsed["A"].as_str().expect("byd");
        let msg_ask: f64 = msg_ask.parse().expect("byby");
        // let msg_qty: f64 = msg_qty.parse().expect("baba");
        let btc = rx1.get();
        let matic = rx2.get();
        let blz = rx3.get();
        let bake = rx4.get();
        println!("{} {} {} {} {}", btc, matic, msg_ask, blz, bake);
        let fee = 0.9992;
        let res = (((((1000.0 * fee) / btc) * fee) / matic) * fee) * msg_ask;
        // 26158 0.00002083 0.5446
        let res_b = (((((1000.0 * fee) / msg_ask) * fee) * matic) * fee) * btc;
        let res_3 = (((((1000.0 * fee) / btc) * fee) / blz) * fee) * rxblz.get();
        let res_3_b = (((((1000.0 * fee) / rxblz.get()) * fee) * blz) * fee) * btc;
        let res_4 = (((((1000.0 * fee) / btc) * fee) / bake) * fee) * rxbake.get();
        let res_4_b = (((((1000.0 * fee) / rxbake.get()) * fee) * bake) * fee) * btc;
        if res > maxim && res < 1100.0{
            maxim = res;
        }
        if res_b > maxim && res_b < 1100.0{
            maxim = res_b;
        }
        if res_3 > maxim && res_3 < 1100.0{
            maxim = res_3;
        }
        if res_4 > maxim && res_4 < 1100.0{
            maxim = res_4;
        }
        if res_3_b > maxim && res_3_b < 1100.0{
            maxim = res_3_b;
        }
        if res_4_b > maxim && res_4_b < 1100.0{
            maxim = res_4_b;
        }
        println!("{} {} {} {} {} {} {}", res, res_b, res_3, res_3_b, res_4, res_4_b, maxim);
    }
}