use std::time::{Duration,SystemTime};
use std::thread::sleep;

#[derive(Default)]
pub struct Atpack{
    porthandle:Option<Box<dyn serialport::SerialPort>>
}

impl Atpack {
    pub fn new()->Self{
        Self{..Default::default()}
    }
    pub fn open(&mut self,compath:&str,boud:u32)->bool{
        if let Ok(port) = serialport::new(compath, boud)
        .timeout(std::time::Duration::from_millis(20)).open(){
            self.porthandle = Some(port);
            return true;
        };
        false
    }
    pub fn send(){
        
    }
    pub fn query(&mut self,msg:&str)->Option<String>{
        if let Some(hand) =&mut self.porthandle{
            if let Err(_) = hand.write(msg.as_bytes()){
                return None;
            };
            let mut buff = [0;1024];
            if let Ok(_) = hand.read(&mut buff){
                if let Ok(data) = std::str::from_utf8(&buff[..]){
                    return Some(data.into());
                }
            };
        };
        None
    }
    pub fn send_and_recv_confirm_single_key(&mut self,at_send:&str,at_recv:&str)->Result<String,String>{
        let mut tmpdata = String::new();
        if let Some(getdata) = self.query(at_send){
            if let Some(_) = getdata.find(at_recv){
                return Ok(getdata);
            }
            tmpdata = getdata;
        }
        Err(tmpdata)
    }
    pub fn send_and_recv_confirm_single_key_split_while(&mut self,at_send:&str,at_recv:&str,time_s:u64)->Result<String,String>{
        let marktime = SystemTime::now();
        let mut errmsg = String::new();
        loop{
            if let Some(data) = self.query(at_send){
                let cc:Vec<&str> = data.split(",").collect();
                for idx in cc{
                    if let Some(_) = idx.find(at_recv){
                        return Ok(data);
                    }
                }
                errmsg = data;
            }
            if let Ok(tt) = marktime.elapsed(){
                if tt>Duration::from_secs(time_s){
                    return Err(errmsg);
                }
            };
            sleep(Duration::from_secs(1));
        }
    }
}


#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        let mut aat = Atpack::new();
        if aat.open("COM63", 115200){
            if let Ok(dd) = aat.send_and_recv_confirm_single_key("AT\r\n", "OK"){
                println!("{}",dd);
            };
            if let Ok(dd) = aat.send_and_recv_confirm_single_key_split_while("AT\r\n", "OK", 30){
                println!("{}",dd);
            }
        }
    }
}