/*
 * gnss.cpp
 *
 *  Created on: Dec 29, 2014
 *      Author: aras
 */

#include "gnss.h"

namespace te_gnss{

/**
 * \fn configure
 * \brief Realiza la configuracion inicial antes de operar.
 * Establece el baudrate del operacion. Primero autodetecta el baudrate del
 * receptor y luego la cambia ala deseada.
 * Tambien activa las trmas NMEA deseadas.
 * \param gcs estructura de configuracion del receptor gnss
 * \return "true" si se ha configurado correctamente.
 * \see gnss_config_struct
 */
bool configure(gnss_config_struct &gcs) {
	bool r;
	r = activate();
	r = r && set_baudrate(gcs.baudrate);
	r = r && set_position(gcs.lat,gcs.lon);
	return r && activate_nmea_frames(gcs.nmea_mask);
}


/**
 * \fn activate
 * \brief Le da energia de fuente al receptor GNSS a traves de un regulador
 * con pin de "enable".
 * \return '0', si falla. Diferente de '0' ("true")  si se ha configurado
 * correctamente.
 * \see deactivate
 */
bool activate() {
	PORTD |= (1<<PK0);
	return PORTD & (1<<PK0);
}

/**
 * \fn deactivate
 * \brief Le quita energia de fuente al receptor GNSS a traves de un regulador
 * con pin de "enable".
 * \return '0', si falla. Diferente de '0' ("true")  si se ha configurado
 * correctamente.
 * \see activate
 */
bool deactivate() {
	PORTD &= ~(1<<PK0);
	return (~PORTD) & (1<<PK0);
}


/**
 * \fn set_baudrate
 * \brief Autodetecta el baudrate del receptor y luego la cambia al deseado.
 * \param baud El baudrate en 16 bits
 * \return "true" si se ha configurado correctamente.
 */
bool set_baudrate(uint16_t baud){
	if(not scan_baud_success){
		scan_baud_finish = false;
		scan_baudrate();
		while(not scan_baud_finish){}// TODO sleep()
	}
	if(scan_baud_success){
		write_baud(GNSS_PORT,baud);
	}else{
		return false;
	}
	return true;
}

/**
 * \fn wait_to_be_locked
 * \brief Bloquea el flujo del programa hasta que el receptor GNSS se haya
 * "enganchado" (sincronizado con satelites) correctamente.
 * \return "true" si se ha enganchado correctamente. "false" luego de
 * "LOCK_IDX_MAX" intentos o si no se ha configurado el baudrate
 * \see LOCK_IDX_MAX
 * \see scan_lock_func
 */
bool wait_to_be_locked(){
	scan_lock_finish = false;
	scan_lock_success = false;
	if(scan_baud_success){
		lock_idx = 0;
		push(pfunc_pps);
		pfunc_pps = &scan_lock_func;
		while(! scan_lock_finish){}// TODO sleep()
		if(scan_lock_success){
			PORTL != (1<<PL7);
			return true;
		}
	}
	return false;
}

/**
 * \fn get_pps_data
 * \brief Inicia la recoleccion de data del receptor GNSS
 * \param raw "true", si se va a enviar al mbebido  las tramas tal cual.
 * "flase", si se va a enviar las tramas procesadas (informacion relevante,
 * recomendable para operacion normal)
 * \return "true", si inicia corecctamente. "false" si no se ha configurado
 * el baudrate
 * \see get_pps_data_func
 * \see set_baudrate
 */
bool get_pps_data(bool raw){
	if(scan_baud_success){
		is_raw = raw;
		stk_ptr = 0;
		stack[0] = NULL;
		pfunc_pps = &get_pps_data_func;
	}else{
		return false;
	}
	return true;
}

/**
 * \fn set_position
 * \brief Configura la posicion actual en el receptor GNSS. Para receptores
 * nuevos, estos han sido probados en el hemiferio norte muy lejos de la
 * ubicacion donde sera puesto. En este caso el algoritmo de acercamiento
 * progresivo que usan los receptores GNSS puede tomar varios minutos en
 * hallar la posicion correcta (decenas de minutos). Por ello es recomendable
 * configurarles, por lo menos una posicion cercana a su ubicacion final.
 * Esto puede ser critico si se instala en el campo.
 * Los numeros decimales que representan a la latitud y longitud son de punto
 * fijo de la libreria "fixpoint.h" adjunta al codigo fuente.
 * \param lat Latitud de la posicion.
 * \param lon Longitud de la posicion.
 * \return "true", si configura la posicion corecctamente. "false" si no se ha
 * configurado.
 */
bool set_position(fix32 lat, fix32 lon){
	return true; // TODO all
}

/**
 * \fn get_pps_data
 * \brief Inicia la recoleccion de data del receptor GNSS
 * \param raw "true", si se va a enviar al mbebido  las tramas tal cual.
 * "flase", si se va a enviar las tramas procesadas (informacion relevante,
 * recomendable para operacion normal)
 * \return "true", si inicia corecctamente. "false" si no se ha configurado
 * el baudrate
 * \see get_pps_data_func
 * \see set_baudrate
 */
bool activate_nmea_frames(uint16_t pars_mask){
	#ifndef MICROCONTROLLER
	initialize(pars_mask, synt_mask);
	#else
	nmea::initialize(pars_mask);
	#endif
	return true;
}

/**
 * \fn ISR_pps
 * \brief Interrupcion hardware. Se ejecuta cada vez que el receptor GNSS
 * genera un pulso por segundo.
 * Esta solo ejecuta una funcion, cualquiera que sea a la que apunta el
 * puntero a funcion "pfunc_pps"
 * \see pfunc_pps
 */
void ISR_pps(){
	pfunc_pps();
}


/**
 * \fn push
 * \brief Almacena en una pila la funcion apuntada por "pfunc"
 * \param pfunc funcion que sera almacenada en pila
 * \see pop
 */
void push(void (*pfunc)()){
	if(stk_ptr >= 5) return;
	stack[stk_ptr++]=pfunc;
}

/**
 * \fn pop
 * \brief Recupera de la pila la primera funcion y la devuelve en "pfunc"
 * \param pfunc apuntara a la funcion recuperada de la pila.
 * \see push
 */
void pop(void (*pfunc)()){
	if(stk_ptr == 0) return;
	pfunc = stack[--stk_ptr];
	stack[stk_ptr]=NULL;
}


/**
 * \fn scan_baudrate
 * \brief Inicia la funcion de escaneo en el puerto uart conectado al GNSS,
 * con la finalidad de determinar que baudrate esta configurado
 * \see scan_baudrate_func
 */
void scan_baudrate(){
	baud_idx = 0;
	write_baud(GNSS_PORT,BAUDRATE(baud_idx));
	push(pfunc_pps);
	pfunc_pps = &scan_baud_func;
}


/**
 * \fn scan_baudrate_func
 * \brief Escanea el puerto uart conectado al GNSS, con la finalidad de
 * determinar que baudrate esta configurado.
 * \see scan_baudrate
 */
void scan_baud_func(){
	if(is_gnss_frame_valid()){
		pop(pfunc_pps);
		scan_baud_finish = true;
		scan_baud_success = true;
	}else{
		baud_idx++;
		if(baud_idx < BAUD_IDX_MAX){
			write_baud(GNSS_PORT,BAUDRATE(baud_idx));
		}else{
			pop(pfunc_pps);
			scan_baud_finish = true;
			scan_baud_success = false;
		}
	}
}

/**
 * \fn scan_lock_func
 * \brief Escanea las tramas generadas por el receptor GNSS, con la finalidad de
 * determinar si esta enganchado o no.
 * \see wait_to_be_locked
 */
void scan_lock_func(){
	if(is_locked()){
		pop(pfunc_pps);
		scan_lock_finish = true;
		scan_lock_success = true;
	}else{
		lock_idx++;
		if(lock_idx >= LOCK_IDX_MAX){
			pop(pfunc_pps);
			scan_lock_finish = true;
			scan_lock_success = false;
		}
	}

}

/**
 * \fn get_pps_data_func
 * \brief lee y procesa las tramas generadas por el receptor GNSS
 * \see get_pps_data
 */
void get_pps_data_func(){
	char* fr = readline(GNSS_PORT);
	if(!is_raw){
		process_frame(fr);
	}else{
		writeline(RBP_PORT,fr);
	}
}


/**
 * \fn is_gnss_frame_valid
 * \brief Si todos los caracteres de la trama leida son imprimibles, entonces
 * la trama sera considerada valida.
 * Se utiliza para determinar si el baudrate es correcto, ya que de no serlo,
 * habran caracteres no imprimibles por la desincronizacion.
 * \return "true" si la trama es valida; "false" de lo contrario.
 */
bool is_gnss_frame_valid(){
	uint8_t idx;
	char* fr = readline(GNSS_PORT);
	uint8_t sz = strlen(fr);
	for(idx=0;idx<sz;idx++){
		if(!isprint(fr[idx]))
			return false;
	}
	return true;
}


/**
 * \fn is_locked
 * \brief Lee las tramas NMEA y busca en ellas la informacion referente a el
 * enganche del receptor a los satelites.
 * \return "true" si esta enganchado; "false" de lo contrario.
 */
bool is_locked() {
	char* fr = readline(GNSS_PORT);
	if(strstr(fr,",A,")){
		return true;
	}
	return false;
}


/**
 * \fn process_frame
 * \brief Procesa la cadena de tramas en fr. Para lo cual usa el parser de la
 * librteria libnmea++
 * \param fr
 */
void process_frame(const char* fr){

}
// TODO

}