extern crate reqwest;
extern crate rand;
extern crate ws;
extern crate mnml;
extern crate serde_cbor;

use std::thread;

use serde_cbor::{from_slice, to_vec};

use rand::distributions::Alphanumeric;
use rand::{thread_rng, Rng};
use reqwest::header;
use std::iter;
use ws::{connect, CloseCode, Message, Handler, Sender, Result, Request, Response};

use mnml::rpc::{RpcRequest};
use mnml::{setup_logger};

struct Bot {
    out: Sender,
    token: String,
}

impl Handler for Bot {
    fn build_request(&mut self, url: &url::Url) -> Result<Request> {
        let mut req = Request::from_url(url)?;

        let token = format!("x-auth-token={:}", self.token);
        println!("{:?}", token);

        req.headers_mut().push(("Cookie".to_string(), Vec::from(token)));

        Ok(req)
    }

    fn on_open(&mut self, _: ws::Handshake) -> ws::Result<()> {
        println!("websocket connected");

        let pvp_q = to_vec(&RpcRequest::InstanceQueue {}).unwrap();
        self.out.send(Message::Binary(pvp_q)).unwrap();

        Ok(())
    }
}

fn main() {
    setup_logger().unwrap();

    let mut clients = vec![];

    for i in 0..1000 {
        clients.push(thread::Builder::new().name(i.to_string()).spawn(|| {
            let mut rng = thread_rng();
            let name: String = iter::repeat(()).map(|()| rng.sample(Alphanumeric)).take(12).collect();
            let password: String = iter::repeat(()).map(|()| rng.sample(Alphanumeric)).take(12).collect();

            let mut headers = header::HeaderMap::new();
            headers.insert(header::CONTENT_TYPE, header::HeaderValue::from_static("application/json"));

            let client = reqwest::Client::builder()
                .cookie_store(true)
                .default_headers(headers)
                .build()
                .unwrap();

            let register_body = format!("{{ \"name\": {:?}, \"password\": {:?}, \"code\": \"grep842\" }}", name, password);
            println!("{:?}", register_body);
            let account = client.post("https://sixtysix.pro/api/account/register")
                .body(register_body)
                .send()
                .unwrap();

            println!("{:?}", account.headers().get("set-cookie"));

            let ws = thread::Builder::new().name(name).spawn(move || {
                connect("wss://sixtysix.pro/api/ws", |out| {

                    let token_cookie = account.cookies()
                        .find(|c| c.name() == "x-auth-token")
                        .unwrap();

                    Bot {
                        out: out,
                        token: token_cookie.value().to_string(),
                    }
                }).unwrap()
            }).unwrap();
            ws.join().unwrap();
        }).unwrap());
    }

    for client in clients {
        let _ = client.join();
    }
}