use anyhow;

use std::{
    sync::mpsc::SyncSender,
    thread,
    time::Duration,
    io::Read,
};

use esp_idf_hal::prelude::*;
use esp_idf_hal::serial;

use ublox::*;

use crate::modem::Msg;
use crate::serial::SerialIO;

pub fn main<T: Sync + Send>(
    tx: esp_idf_hal::gpio::Gpio33<T>,
    rx: esp_idf_hal::gpio::Gpio32<T>,
    uart: serial::UART2,
    sender: SyncSender<Msg>,
) -> Result<(), anyhow::Error> {
    let serial_pins = serial::Pins {
        tx,
        rx,
        cts: None,
        rts: None,
    };
    let serial: serial::Serial<serial::UART2, _, _> = serial::Serial::new(
        uart,
        serial_pins,
        serial::config::Config::default().baudrate(Hertz(9600)),
    )?;

    let (tx, rx) = serial.split();
    let mut serial_io = SerialIO::new(tx, rx);
    let mut parser = Parser::default();

    println!("entering GPS sender loop ...");
    loop {
        let mut local_buf = [0; 100];
        println!("reading 100 bytes from serial ...");
        let nbytes = serial_io.read(&mut local_buf)?;
        println!("READ: {}", local_buf.iter().map(|&b| char::from(b)).collect::<String>());
        if nbytes == 0 {
            println!("received 0 bytes, exiting ...");
            break;
        }
        let mut it = parser.consume(&local_buf);

        loop {
            match it.next() {
                Some(Ok(packet)) => {
                    let msg = format!("We've received a &PacketRef, we can handle it ... {:?}", packet);
                    println!("{}", msg);
                    sender.send(Msg::Location(msg))?;
                }
                Some(Err(err)) => {
                    println!("Received a malformed packet {:?}", err);
                }
                None => {
                    println!("The internal buffer is now empty");
                    break;
                }
            }
        }
        thread::sleep(Duration::from_millis(2000));
    }
    println!("exiting GPS sender loop :)");
    Ok(())
}