use std::io::prelude::*;
use std::io::BufReader;
use std::fs::File;
use chrono::{DateTime, Utc};
use nmea_parser::*;

#[derive(Debug)]
pub struct ParseResult {
    pub lat: f64,
    pub lon: f64,
    pub timestamp: DateTime<Utc>,
    pub speed: f64,
}

pub struct GpsParser {
    gps_file: String,
}

impl GpsParser {
    pub fn new(gps_device: &str) -> GpsParser{
        GpsParser {
            gps_file: format!("{}",gps_device),
        }
    }

    pub fn parse_nmea(&mut self) -> Result<ParseResult, ParseError> {
        let f = match File::open(&self.gps_file) {
            Ok(f) => f,
            Err(error) => panic!("Error: {error:?}"),
        };
        let mut reader = BufReader::new(f);
        let mut line = String::new();
        let mut parser = NmeaParser::new();
        let mut res = ParseResult {
            lat: 0.0,
            lon: 0.0,
            timestamp: Utc::now(),
            speed: 0.0,
        };

        let mut parsing_complete = false;
        let mut parsed_gga:bool = false;
        let mut parsed_vtg:bool = false;
        while !parsing_complete {
                let len = match reader.read_line(&mut line) {
                Ok(len) => len,
                Err(_) => 0,
            };
            if len > 1 {
                match parser.parse_sentence(&line)? {
                    ParsedMessage::Gga(gga) => {
                        parsed_gga = true;
                        res.lat = gga.latitude.unwrap();
                        res.lon = gga.longitude.unwrap();
                        res.timestamp = gga.timestamp.unwrap();
                    },
                    ParsedMessage::Vtg(vtg) => {
                        parsed_vtg = true;
                        res.speed = vtg.sog_kph.unwrap();
                    },
                    _ => {
                    }
                }
            }
            if parsed_gga && parsed_vtg {
                parsing_complete = true;
            }
            line.clear();
        }
        Ok(res)
    }
}