use std::io::Write;

use std::net::TcpStream;

use std::io::{BufRead, BufReader};

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}
#[derive(Debug)]
pub enum Errors {
    CanNotConnect,
    NoReply,
    ParseError,
    WriteError,
}

pub struct Hamlib {
    stream: TcpStream,
    buf_read: BufReader<TcpStream>,
}
impl Hamlib {
    pub fn get_freq(&mut self) -> Result<i32, Errors> {
        match write!(&self.stream, "f\n") {
            Ok(_) => (),
            Err(_) => return Err(Errors::WriteError),
        };
        let output = {
            let mut string_res: String = String::new();
            match self.buf_read.read_line(&mut string_res) {
                Ok(_) => (),
                Err(_) => return Err(Errors::NoReply),
            };
            string_res = string_res.trim().to_string();
            match string_res.parse::<i32>() {
                Ok(freq) => freq,
                Err(_) => return Err(Errors::ParseError),
            }
        };
        Ok(output)
    }
    pub fn new(address: String) -> Result<Hamlib, Errors> {
        let stream = match TcpStream::connect(address) {
            Ok(stream) => stream,
            Err(_) => return Err(Errors::CanNotConnect),
        };
        let stream_clone = match stream.try_clone() {
            Ok(stream) => stream,
            Err(_) => return Err(Errors::CanNotConnect),
        };
        let buf = BufReader::new(stream);
        Ok(Hamlib {
            buf_read: buf,
            stream: stream_clone,
        })
    }
}