rust_template 0.1.0

use rpi_embedded::uart::{Uart,Parity};
//use std::time::Duration;
use std::string::String;

pub enum Settings { 
    Baudgps,
    Baudarduino,
    Data,
    Stopbit,
    
}

impl Settings{
    pub fn get_baud(&self) -> u32{
        let value : u32;
        match self{
            Settings::Baudgps => {value = 9600}
            Settings::Baudarduino => {value = 115_200}
            Settings::Data =>{value = 8}
            Settings::Stopbit =>{value = 1} 

        }
        value
        }

}
struct GPS{
    pub longitude: String, 
    pub latitude: String, 
    pub altitude: String,
    pub time: String,
    pub satellites: String,
    pub indicator: String
}

impl GPS{
    pub fn new() -> Self{
        let mut _out = Self{
            longitude: "".to_string(), //string
            latitude: "".to_string(),
            altitude: "".to_string(),
            time:"".to_string(),
            satellites: "".to_string(),
            indicator:"".to_string(),
        };
        _out
    
    }

    pub fn spliting(&mut self,string_read:String){
        let reading = string_read.split(',');
        let read_vec: Vec<&str> = reading.collect();
        //println!("{}",read_vec[0]);
        self.indicator = read_vec[0].to_string();
        if read_vec[0] == "$GPGGA"{
            self.gps_system(read_vec);
            self.gps_print();
            }

    }
    pub fn  gps_system(&mut self,read_vec: Vec<&str>){ //takes a value from the list and converts it to string for latitude ,longitude ,altidute, satellite and time 
        self.latitude = read_vec[2].to_string() + "" + &read_vec[3].to_string();
        self.longitude = read_vec[4].to_string()+ "" + &read_vec[5].to_string();
        self.altitude = read_vec[9].to_string() + "" + &read_vec[10].to_string();
        self.time = read_vec[1].to_string();
        self.satellites = read_vec[7].to_string();

    }


    pub fn gps_print(&mut self){//function to print
        let print_str=format! (
        "\n
        Time: {}h{}m{}s \n
        Latitude: {} \n
        Longitude: {} \n
        Altitude: {} \n
        Number of Satellites: {} \n",&self.time[0..2],&self.time[2..4],&self.time[4..6],self.latitude,self.longitude,self.altitude,self.satellites);
        println!("Useful data: {}",print_str);
    }
}

fn main(){
    let mut tracking = GPS::new();


        let mut uart = Uart::new(Settings::Baudgps.get_baud(), Parity::None,Settings::Data.get_baud() as u8,Settings::Stopbit.get_baud() as u8).expect("Initializing failed!"); //115_200
        loop{
        //uart.set_read_mode(1, Duration::default()).expect("read mode fail");
        let string_read = uart.read_line().expect("GPS reading failed");
        tracking.spliting(string_read);
        }
    }


#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_string_indication(){
        let mut track = GPS::new();

        //let new_baud = Settings::Baudgps;
        //track.set_baud_rate(&new_baud);
        track.spliting("$GPGGA,112503.101,6507.4485,N,02255.5355,W,1,04,2.26,17.7,M,60.6,M,,*44".to_string());

        assert_eq!(track.indicator,"$GPGGA");
    }


    #[test]
    fn test_lattitude_direction(){
        let mut track = GPS::new();

        track.spliting("$GPGGA,112503.101,6507.4485,N,02255.5355,W,1,04,2.26,17.7,M,60.6,M,,*44".to_string());
        
        assert_eq!(track.latitude[9..10],"N".to_string());
    }

    #[test]
    fn test_longitude_direction(){
        let mut track = GPS::new();

        //let new_baud = Settings::Baudgps;
        //track.set_baud_rate(&new_baud);
        track.spliting("$GPGGA,112503.101,6507.4485,N,02255.5355,W,1,04,2.26,17.7,M,60.6,M,,*44".to_string());
        
        assert_eq!(track.longitude[10..11],"W".to_string());
    }

    #[test]
    fn test_longitude_length(){
        let mut track = GPS::new();

        //let new_baud = Settings::Baudgps;
        //track.set_baud_rate(&new_baud);
        track.spliting("$GPGGA,112503.101,6507.4485,N,02255.5355,W,1,04,2.26,17.7,M,60.6,M,,*44".to_string());
        
        assert_eq!(track.longitude.len(),11 as usize); //11 because 10numbers + direction
    }

    #[test]
    fn test_latitude_length(){
        let mut track = GPS::new();

        //let new_baud = Settings::Baudgps;
        //track.set_baud_rate(&new_baud);
        track.spliting("$GPGGA,112503.101,6507.4485,N,02255.5355,W,1,04,2.26,17.7,M,60.6,M,,*44".to_string());
        
        assert_eq!(track.latitude.len(),10 as usize);
    }
    #[test]
    fn test_altitude_length(){
        let mut track = GPS::new();

        //let new_baud = Settings::Baudgps;
        //track.set_baud_rate(&new_baud);
        track.spliting("$GPGGA,112503.101,6507.4485,N,02255.5355,W,1,04,2.26,17.7,M,60.6,M,,*44".to_string());
        
        assert_eq!(track.altitude.len(),5 as usize);
    }
    #[test]
    #[should_panic]
    fn test_if_panic(){
        let mut track = GPS::new();

        //let new_baud = Settings::Baudgps;
        //track.set_baud_rate(&new_baud);
        track.spliting("$GPGGA,112503.101,6507.4485,N,02255.5355,W,1,04,2.26,17.7,M,60.6,M,,*44".to_string());
        
        assert_eq!(track.latitude.len(),15 as usize);
    }
}