use std::sync::mpsc::channel;
use std::sync::mpsc::Receiver;
use std::sync::mpsc::Sender;
use std::net::TcpStream;
use std::thread::JoinHandle;
use std::thread::spawn;
use std::net::TcpListener;
/// Async TCP listener wrapper
pub struct Listener {
    stream_receiver: Receiver<TcpStream>,
    ctrl_sender: Sender<i32>,
    ctrl_handle: JoinHandle<()>,
}

impl Listener {
    pub fn new(addr: &str) -> Self {

        let (tx, rx): (Sender<TcpStream>, Receiver<TcpStream>) = channel();
        let (ct_tx, ct_rx): (Sender<i32>, Receiver<i32>) = channel();
        let sens = TcpListener::bind(addr).unwrap();
        let hand = spawn(move || {

            loop {
                let (sock, _) = sens.accept().unwrap();

                // 结束线程，跳出循环
                match ct_rx.try_recv() {
                    Ok(_) => {
                        return;
                    }
                    Err(_) => {
                        tx.send(sock).unwrap();
                    }
                }
            }
        });

        Listener {
            stream_receiver: rx,
            ctrl_sender: ct_tx,
            ctrl_handle: hand,
        }
    }

    /// Blocking method to get a income socket
    pub fn get_stream(&self) -> Option<TcpStream> {
        match self.stream_receiver.recv() {
            Ok(sock) => Some(sock),
            Err(_) => None,
        }
    }

    /// Shutdown listener
    pub fn shutdown(self) {
        self.ctrl_sender.send(0).unwrap();
        TcpStream::connect("192.168.100.21:6666").unwrap();
        self.ctrl_handle.join().unwrap();
    }
}