extern crate ws;

use std::cmp::min;
use std::sync::mpsc::{self, Receiver};
use std::thread;

use ws::{connect, listen, CloseCode, Handler, Handshake, Message, Result, Sender};

pub struct Server<'a> {
  pub socket: Sender,
  pub msgs: &'a Receiver<Vec<String>>
}

pub struct Client<F: FnMut(String)> {
  pub socket: Sender,
  pub dispatch: F
}

impl<'a> Handler for Server<'a> {
  fn on_open(&mut self, shake: Handshake) -> Result<()> {
    let resource = shake.request.resource();
    let client_ip = shake.remote_addr();
    println!("Client has connected");
    println!("{:?}\n{:?}", client_ip, resource);
    for m in self.msgs.try_iter() {
      self.socket.send(format!("{:?}", m)).unwrap();
      println!("{:?}", m);
    }

    Ok(())
  }

  fn on_message(&mut self, msg: Message) -> Result<()> {
    println!("Client has sent a message: {:?}", msg);
    Ok(())
  }

  fn on_close(&mut self, code: CloseCode, reason: &str) {
    match code {
      CloseCode::Normal => println!("Client has terminated connection"),
      CloseCode::Away => println!("Client has left"),
      _ => println!("Error: {:?}", reason)
    }
  }
}

impl<F: FnMut(String)> Handler for Client<F> {
  fn on_message(&mut self, msg: Message) -> Result<()> {
    (self.dispatch)(msg.to_string());
    Ok(())
  }

  fn on_close(&mut self, code: CloseCode, reason: &str) {
    match code {
      CloseCode::Normal => println!("Client has terminated connection"),
      CloseCode::Away => println!("Client has left"),
      _ => println!("Error: {:?}", reason)
    }
  }
}

fn main () {
  let s = "adausdt@depth10/btcusdt@depth10/ethusdt@depth10/ltcusdt@depth10".to_string();
  let b = "wss://stream.binance.com:9443/stream?streams=".to_string() + s.as_str();
  let (dispatcher, receiver) = mpsc::channel();
  let (sender, getter) = mpsc::channel();
  let mut msgs: Vec<String> = vec![];

  let s = thread::spawn(move || {
    for msg in receiver {
      msgs.insert(0, msg);
      // sender.send(&msg.clone().to_string()).unwrap();
      sender.send(msgs[0..(min(msgs.len(), 1))].to_vec()).unwrap();
      println!("Messages stored: {:?}", msgs.len());
    }
  });

  let wsc = thread::spawn(move || {
    if let Err(error) = connect(b, |socket| {
      let d = dispatcher.clone();
      Client { socket, dispatch: move |v| d.send(v).unwrap() }
    }) {
      println!("{:?}", error);
    }
  });

  let wss = thread::spawn(move || {
    println!("WebSocket Server Online");
    if let Err(error) = listen("127.0.0.1:4040", |socket| {
      Server { socket, msgs: &getter }
    }) {
      println!("Failed to create Websocket Server: {:?}", error);
    }
  });

  s.join().unwrap();
  wsc.join().unwrap();
  wss.join().unwrap();
}