use std::net::SocketAddr;
use std::sync::{Arc, Mutex};
use std::thread;
use std::str;
use std::io::{Error, ErrorKind};

use byteorder::{ByteOrder, LittleEndian};

pub mod client;
pub mod server;
pub mod message;

use self::server::Conns;
use self::client::{Manager, Session};
use self::message::{Message, MsgHandler};


#[derive(Debug)]
pub struct P2PManager {
    conns: Arc<Mutex<Conns>>,
    capacity: usize,
    sessions: Vec<Option<Manager>>, 
    listening_ip: Option<String>
}
impl P2PManager {
    // fn checkErr(res: Result<T, E>) ->
    pub fn new(cap: usize) -> P2PManager {
        let mut sessions = Vec::new();
        for _i in 0..cap {
            sessions.push(None);
        }
        P2PManager {
            conns: Arc::new(Mutex::new(Conns::new(cap))),
            capacity: cap,
            sessions: sessions,
            listening_ip: None,
        }
    }
    pub fn set_listen_addr(&mut self, addr: String) -> Result<(), &'static str> {
        
        self.listening_ip = Some(addr);
        Ok(())
    }
    pub fn listen_addr(&mut self) -> Result<String, &'static str> {
        
        match self.listening_ip.clone() {
            Some(addr) => Ok(addr),
            None => Err("No listening port"),
        }
    }
    /**
     * 在子线程中运行服务器模式，使用时需要主线程 loop{}
     */
    pub fn server_run(&mut self, addr: &str) {
        let conns_clone = self.conns.clone();
        let addr = addr.to_string().parse::<SocketAddr>().unwrap();
        thread::spawn(move || {
            server::server_run(conns_clone, addr);
        });
    }
    /**
     * 将发送的内容传至对应的写缓存，子线程循环将缓存内容发送至socket
     */
    pub fn server_write(&mut self, client: SocketAddr, vec: Vec<u8>) 
                        -> Result<usize, &'static str> {
        let conns_write = self.conns.clone();
        let len = vec.len();
        // let err: &'static str  = format!("Can not find {:?}", client).as_str();
        let index = match conns_write.lock().unwrap().find(client){
            Ok(n) => n,
            Err(_e) => return Err("No this client"),
        };
        
        
        // 对 vec进行封装
        let mut cmd = vec![1u8;1];
        let mut message = self.encode(&mut cmd, vec).unwrap();
        let message = message.to_vec();
        Conns::write(conns_write, index, message);
        Ok(len)
    }
    /**
     * 从对应的读缓存中读取相应内容，子线程将socket中的内容传至缓存中
     */
    pub fn server_read(&mut self, client: SocketAddr)
                       -> Result<Option<Vec<u8>>, &'static str> {
        let conns_read = self.conns.clone();
        let index = match conns_read.lock().unwrap().find(client){
            Ok(n) => n,
            Err(_e) => return Err("No this client"),
        };
        Conns::read(conns_read, index)
    }
    /**
     * 查看所有连接的对象 client模式没有加入
     */
    pub fn server_table(&mut self) -> Result<Vec<SocketAddr>, &'static str> {
        let table = self.conns.clone();
        Conns::table(table)
    }
    pub fn server_conn_table(&mut self) -> Result<Vec<Vec<u8>>, &'static str> {
        let conns_table = self.conns.clone();
        Conns::conn_table(conns_table)
    }
    // 更新能连接的端口
    pub fn server_update_conn_table(&mut self, client: SocketAddr, 
                                   conn_addr: Vec<u8>) -> Result<(), &'static str> {
        let conns_update = self.conns.clone();
        // 获取到client的Conn
        let index = conns_update.lock().unwrap().find(client).unwrap();
        // 修改conn中的conn_addr字段
        Conns::update(conns_update, index, conn_addr);
        Ok(())
    }
    pub fn server_remove(&mut self, client: SocketAddr) -> Result<(), &'static str> {
        let conns_remove = self.conns.clone();
        let conns_dis = self.conns.clone();
        let index = conns_remove.lock().unwrap().find(client).unwrap();
        let mut cmd = vec![0u8;2];
        let mut message = self.encode(&mut cmd, Vec::new()).unwrap();
        let message = message.to_vec();
        Conns::write(conns_remove, index, message);
        Conns::remove(conns_dis, index);
        Ok(())
    }
    // pub fn server_disconn(&mut self, client: SocketAddr) -> Result<bool, &'static str> {
    //     let conns_dis = self.conns.clone();
    //     let index = conns_dis.lock().unwrap().find(client).unwrap();
    //     Conns::remove(conns_dis, index)
    // }
    /**
     * client模式下与peer建立连接
     */
    pub fn create_session(&mut self, addr: &str) -> Result<(), Error> {
        // 判断是否满了
        let len = self.sessions.len();
        let mut local = len + 1;
        for index in 0..len {
            if self.sessions[index].is_none() {
                local = index;
                break;
            }
        }
        if local == len + 1 {
            return Err(Error::new(ErrorKind::Other, "Can't connect to more nodes"));
        }
        // 创建manager 以及session
        let manager = Manager::new(addr);
        let shutdown = manager.shutdown.clone();
        let sender = manager.sender.clone();
        let receiver = manager.receiver.clone();
        let addr = manager.addr.clone();
        let result = Session::new(local, addr, shutdown, sender, receiver); // Result<(), &str>
        match result {
            Ok(()) => {
                self.sessions[local] = Some(manager);
                return Ok(());
            },
            Err(e)   => return Err(e),
        };
    }
    pub fn client_dis(&mut self, addr: &str) -> Result<(), &'static str> {
        let index = match self.find_session(addr) {
            Some(n) => n,
            None => return Err("Can not find session"),
        };
        
        // self.session(index).unwrap().shutdown();
        self.close_seesion(index).unwrap();
        // println!("要断开的服务器位置 {:?}", index);
        Ok(())
    }
    fn close_seesion(&mut self, index: usize) -> Result<bool, &'static str> {
        self.sessions.push(None);
        let manager = self.sessions.swap_remove(index);

        manager.unwrap().shutdown()
    }
    /**
     * 查看client模式下 是否与 peer 建立连接
     */
    fn find_session(&mut self, addr: &str) -> Option<usize> {
        let addr = addr.parse::<SocketAddr>().expect("Wrong host:port");
        let len = self.sessions.len();

        for index in 0..len {
            if self.sessions[index].is_none() {
                continue;
            } else if self.sessions[index].as_ref().unwrap().addr.eq(&addr) {
                return Some(index);
            }
        }
        return None;
    }
    /**
     * 从对应的读缓存获取信息 要对无效信息进行删除 读取一次有效的信息，无效信息为空
     */
    pub fn client_read(&mut self, addr: &str) 
                       -> Result<Option<Vec<u8>>, &'static str> {
        let index = match self.find_session(addr) {
            Some(n) => n,
            None => return Err("Can not find session"),
        };
        let r_cache = self.sessions[index].as_ref().unwrap().sender.clone();
        
        // 如果长度小于6 证明连长度都没有传过来
        let len = r_cache.lock().unwrap().len();
        // if len > 0 {
        //     println!("client从读缓存读取内容 {:?}", r_cache.lock().unwrap()[1]);
        // }
        
        if len < 5 {
            return Ok(None); // 长度肯定不够
        } else {
            // 复制获取 1，2，3，4 的信息，转换成长度，继续？错误？空？
            let mut len_tem = Vec::new();
            
            for i in 1..5 {
                len_tem.push(r_cache.lock().unwrap()[i].clone());
            }
            // println!("len_tem is {:?}", len_tem);
            
            let msg_len = LittleEndian::read_u32(len_tem.as_ref()) as usize;
            // println!("msg_len is {}", msg_len);
            if msg_len > len - 5 {
                // 内容不足 
                return Ok(None);
            } else {
                
                // len 字段 过长，过短，需要对 len 最最大值作处理，否则可能无限等待
                let mut vec = Vec::new();
                let end = r_cache.lock().unwrap()[msg_len+4].clone();
                // 翻转 
                r_cache.lock().unwrap().reverse();
                if end != 0x7A {
                    r_cache.lock().unwrap().pop().unwrap();
                    loop {
                        if r_cache.lock().unwrap()[0] != 0x55 {
                            r_cache.lock().unwrap().pop().unwrap();
                        } else {
                            r_cache.lock().unwrap().reverse();
                            return self.client_read(addr); // 可能死锁
                            // break;
                        }
                    }
                } 
                
                for _i in 0..msg_len + 5 {
                    vec.push(r_cache.lock().unwrap().pop().unwrap());
                }
                r_cache.lock().unwrap().reverse();
                let vec = self.decode(&mut vec).unwrap();
                return Ok(Some(vec));
            }
        }
    }
    /**
     * 从将内容传至对应的写缓存中
     */
    pub fn client_write(&mut self, addr: &str, vec: Vec<u8>) -> Result<Option<usize>, &'static str> {
        let vec_len = vec.len();
        
        let index = match self.find_session(addr) {
            Some(n) => n,
            None => return Err("Can not find session"),
        };
        let w_cache = self.sessions[index].as_ref().unwrap().receiver.clone();
        // 对 vec进行封装
        let mut cmd = vec![1u8;1];
        let mut message = self.encode(&mut cmd, vec).unwrap();
        let message = message.to_vec();
        // println!("client 将写 {:?}", message);
        w_cache.lock().unwrap().push(message);
        return Ok(Some(vec_len));
    }
}

impl MsgHandler for P2PManager {
    fn decode(&self, recv: &mut Vec<u8>) -> Result<Vec<u8>, &'static str> {
        // 先查看第一个字节
        recv.reverse();
        assert_eq!(recv.pop().unwrap(), 0x55);
        let mut len = Vec::new();
        for _i in 0..4 {
            len.push(recv.pop().unwrap());
        }
        let msg_len = LittleEndian::read_u32(len.as_ref()) as usize;
        let mut message = Vec::new();
        for i in 0..msg_len - 1 {
            if i < 2 {
                recv.pop().unwrap();
                continue;
            }
            message.push(recv.pop().unwrap());
        }
        assert_eq!(recv.pop().unwrap(), 0x7A);
        message.reverse();
        Ok(message)
    }
    fn encode(&self, cmd: &mut Vec<u8>, data: Vec<u8>) -> Result<Message, &'static str> {
        Ok(Message::new(cmd, data).unwrap())
    }
}