//! 客户端

use log::*;
use spin::{Mutex, RwLock};
use std::collections::BTreeMap;
use std::thread;
use unmp::link::{ErrorKind, Link};
use unmp::net;
use websocket::OwnedMessage;

static LINKS: Mutex<BTreeMap<String, Link>> = Mutex::new(BTreeMap::new());
static DRIVERS: RwLock<BTreeMap<Link, Driver>> = RwLock::new(BTreeMap::new());

struct Driver {
    socket: Mutex<websocket::sender::Writer<std::net::TcpStream>>,
}
fn sendto(link: Link, buf: &[u8]) -> Result<(), ErrorKind> {
    trace!("websocket_client send: {:02X?}.", buf);
    if let Some(driver) = DRIVERS.read().get(&link) {
        match driver
            .socket
            .lock()
            .send_message(&OwnedMessage::Binary(buf.into()))
        {
            Ok(_) => {
                return Ok(());
            }
            Err(_) => {
                warn!("websocket_client send error.");
                return Err(ErrorKind::TimedOut);
            }
        };
    } else {
        return Err(ErrorKind::NotConnected);
    }
}

/// 创建一个链路实例，并连接到指定地址端口
pub fn start(url: &str) -> Link {
    let identifier = format!("{}", url);
    if let Some(link) = LINKS.lock().get(&identifier) {
        return *link;
    }

    let client = websocket::client::ClientBuilder::new(url)
        .unwrap()
        .add_protocol("unmp")
        .connect_insecure()
        .unwrap();
    let (mut receiver, sender) = client.split().unwrap();
    let driver = Driver {
        socket: Mutex::new(sender),
    };
    let link = Link::new(sendto);
    info!("websocket_client new {}({}).", link, identifier);
    LINKS.lock().insert(identifier.clone(), link);
    DRIVERS.write().insert(link, driver);

    thread::spawn(move || {
        for message in receiver.incoming_messages() {
            match message {
                Ok(m) => match m {
                    OwnedMessage::Binary(buf) => {
                        trace!("websocket_client recv: {:02X?}.", buf);

                        // 接收数据帧
                        thread::spawn(move || {
                            net::when_recv(link, &buf);
                        });
                    }
                    _ => {}
                },
                Err(e) => {
                    warn!("websocket_client recv error: {:?}", e);
                    LINKS.lock().remove(&identifier);
                    DRIVERS.write().remove(&link);
                    info!("websocket_client rm {}.", link);
                    link.destroy();
                    return;
                }
            };
        }
    });
    return link;
}