/*!
 * \file Galileo_Navigation_Message.cc
 * \brief  Implementation of a Galileo NAV Data message decoder as described in Galileo ICD
 * \author Mara Branzanti 2013. mara.branzanti(at)gmail.com
 * \author Javier Arribas, 2013. jarribas(at)cttc.es
 *
 * -------------------------------------------------------------------------
 *
 * Copyright (C) 2010-2013  (see AUTHORS file for a list of contributors)
 *
 * GNSS-SDR is a software defined Global Navigation
 *          Satellite Systems receiver
 *
 * This file is part of GNSS-SDR.
 *
 * GNSS-SDR is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * at your option) any later version.
 *
 * GNSS-SDR is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
 *
 * -------------------------------------------------------------------------
 */

#include "galileo_navigation_message.h"
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/crc.hpp>      // for boost::crc_basic, boost::crc_optimal
#include <boost/dynamic_bitset.hpp>
#include <glog/log_severity.h>
#include <glog/logging.h>

#include <iostream>
#include <cstring>
#include <string>

typedef boost::crc_optimal<24, 0x1864CFBu, 0x0, 0x0, false, false> CRC_Galileo_INAV_type;


void Galileo_Navigation_Message::reset()
{
	 flag_even_word = 0;
	 Page_type_time_stamp = 0;

	 flag_CRC_test = false;
	 flag_all_ephemeris = false; // flag indicating that all words containing ephemeris have been received
	 flag_ephemeris_1 = false;    // flag indicating that ephemeris 1/4 (word 1) have been received
	 flag_ephemeris_2 = false;    // flag indicating that ephemeris 2/4 (word 2) have been received
	 flag_ephemeris_3 = false;    // flag indicating that ephemeris 3/4 (word 3) have been received
	 flag_ephemeris_4 = false;    // flag indicating that ephemeris 4/4 (word 4) have been received

	 flag_iono_and_GST = false;   // flag indicating that ionospheric parameters (word 5) have been received
	 flag_utc_model = false;      // flag indicating that utc model parameters (word 6) have been received

	 flag_all_almanac = false;	  // flag indicating that all almanac have been received
	 flag_almanac_1 = false;      // flag indicating that almanac 1/4 (word 7) have been received
	 flag_almanac_2 = false;      // flag indicating that almanac 2/4 (word 8) have been received
	 flag_almanac_3 = false;      // flag indicating that almanac 3/4 (word 9) have been received
	 flag_almanac_4 = false;      // flag indicating that almanac 4/4 (word 10) have been received

	 flag_TOW_5 = 0;
	 flag_TOW_set = false;

	 IOD_ephemeris = 0;
	 /*Word type 1: Ephemeris (1/4)*/
	 IOD_nav_1 = 0;
	 t0e_1 = 0;
	 M0_1 = 0;
	 e_1 = 0;
	 A_1 = 0;

	 /*Word type 2: Ephemeris (2/4)*/
	 IOD_nav_2 = 0;  // IOD_nav page 2
	 OMEGA_0_2 = 0; // Longitude of ascending node of orbital plane at weekly epoch [semi-circles]
	 i_0_2 = 0;     // Inclination angle at reference time  [semi-circles]
	 omega_2 = 0;   // Argument of perigee [semi-circles]
	 iDot_2 = 0;    // Rate of inclination angle [semi-circles/sec]


	 /*Word type 3: Ephemeris (3/4) and SISA*/
	 IOD_nav_3 = 0;  		//
	 OMEGA_dot_3 = 0;		// Rate of right ascension [semi-circles/sec]
	 delta_n_3 = 0;		    // Mean motion difference from computed value  [semi-circles/sec]
	 C_uc_3 = 0;			// Amplitude of the cosine harmonic correction term to the argument of latitude [radians]
	 C_us_3 = 0;			// Amplitude of the sine harmonic correction term to the argument of latitude [radians]
	 C_rc_3 = 0;			// Amplitude of the cosine harmonic correction term to the orbit radius [meters]
	 C_rs_3 = 0;			// Amplitude of the sine harmonic correction term to the orbit radius [meters]
	 SISA_3 = 0;			//


	 /*Word type 4: Ephemeris (4/4) and Clock correction parameters*/
	 IOD_nav_4 = 0;		//
	 SV_ID_PRN_4 = 0;	//
	 C_ic_4 = 0;		// Amplitude of the cosine harmonic correction 	term to the angle of inclination [radians]
	 C_is_4 = 0;		// Amplitude of the sine harmonic correction term to the angle of inclination [radians]
	 /*Clock correction parameters*/
	 t0c_4 = 0;			//
	 af0_4 = 0;			//
	 af1_4 = 0;			//
	 af2_4 = 0;			//
	 spare_4 = 0;

	 /*Word type 5: Ionospheric correction, BGD, signal health and data validity status and GST*/
	 /*Ionospheric correction*/
	 /*Az*/
	 ai0_5 = 0;		//
	 ai1_5 = 0;		//
	 ai2_5 = 0;		//
	 /*Ionospheric disturbance flag*/
	 Region1_flag_5 = 0;	//Region1_flag_5;
	 Region2_flag_5 = 0;	//
	 Region3_flag_5 = 0;	//
	 Region4_flag_5 = 0;	//
	 Region5_flag_5 = 0;	//
	 BGD_E1E5a_5 = 0;	//
	 BGD_E1E5b_5 = 0;	//
	 E5b_HS_5 = 0;		//
	 E1B_HS_5 = 0;		//
	 E5b_DVS_5 = 0;	//
	 E1B_DVS_5 = 0;	//
	/*GST*/
	 WN_5 = 0;
	 TOW_5 = 0;
	 spare_5 = 0;

	 /*Word type 6: GST-UTC conversion parameters*/
	 A0_6 = 0;
	 A1_6 = 0;
	 Delta_tLS_6 = 0;
	 t0t_6 = 0;
	 WNot_6 = 0;
	 WN_LSF_6 = 0;
	 DN_6 = 0;
	 Delta_tLSF_6 = 0;
	 TOW_6 = 0;

	 /*Word type 7: Almanac for SVID1 (1/2), almanac reference time and almanac reference week number*/
	 IOD_a_7 = 0;
	 WN_a_7 = 0;
	 t0a_7 = 0;
	 SVID1_7 = 0;
	 DELTA_A_7 = 0;
	 e_7 = 0;
	 omega_7 = 0;
	 delta_i_7 = 0;
	 Omega0_7 = 0;
	 Omega_dot_7 = 0;
	 M0_7 = 0;

	/*Word type 8: Almanac for SVID1 (2/2) and SVID2 (1/2)*/
	IOD_a_8 = 0;
	af0_8 = 0;
	af1_8 = 0;
	E5b_HS_8 = 0;
	E1B_HS_8 = 0;
	SVID2_8 = 0;
	DELTA_A_8 = 0;
	e_8 = 0;
	omega_8 = 0;
	delta_i_8 = 0;
	Omega0_8 = 0;
	Omega_dot_8 = 0;

	/*Word type 9: Almanac for SVID2 (2/2) and SVID3 (1/2)*/

	IOD_a_9 = 0;
	WN_a_9 = 0;
	t0a_9 = 0;
	M0_9 = 0;
	af0_9 = 0;
	af1_9 = 0;
	E5b_HS_9 = 0;
	E1B_HS_9 = 0;
	SVID3_9 = 0;
	DELTA_A_9 = 0;
	e_9 = 0;
	omega_9 = 0;
	delta_i_9 = 0;

	/*Word type 10: Almanac for SVID3 (2/2) and GST-GPS conversion parameters*/

	IOD_a_10 = 0;
	Omega0_10 = 0;
	Omega_dot_10 = 0;
	M0_10 = 0;
	af0_10 = 0;
	af1_10 = 0;
	E5b_HS_10 = 0;
	E1B_HS_10 = 0;
	//GST-GPS
	A_0G_10 = 0;
	A_1G_10 = 0;
	t_0G_10 = 0;
	WN_0G_10 = 0;

	/*Word type 0: I/NAV Spare Word*/

	Time_0 = 0;
	WN_0 = 0;
	TOW_0 = 0;

}


Galileo_Navigation_Message::Galileo_Navigation_Message()
{
    reset();
}


bool Galileo_Navigation_Message::CRC_test(std::bitset<GALILEO_DATA_FRAME_BITS> bits,boost::uint32_t checksum)
{

	CRC_Galileo_INAV_type CRC_Galileo;

    boost::uint32_t crc_computed;
    // Galileo INAV frame for CRC is not an integer multiple of bytes
    // it needs to be filled with zeroes at the start of the frame.
    // This operation is done in the transformation from bits to bytes
    // using boost::dynamic_bitset.
    // ToDo: Use boost::dynamic_bitset for all the bitset operations in this class

    boost::dynamic_bitset<unsigned char> frame_bits(std::string(bits.to_string()));

    std::vector<unsigned char> bytes;
    boost::to_block_range(frame_bits, std::back_inserter(bytes));
    std::reverse(bytes.begin(),bytes.end());


    CRC_Galileo.process_bytes( bytes.data(), GALILEO_DATA_FRAME_BYTES );

    crc_computed=CRC_Galileo.checksum();
    if (checksum==crc_computed){
    	return true;
    }else{
    	return false;
    }


}
unsigned long int Galileo_Navigation_Message::read_navigation_unsigned(std::bitset<GALILEO_DATA_JK_BITS> bits, const std::vector<std::pair<int,int> > parameter)
{
    unsigned long int value = 0;
    int num_of_slices = parameter.size();
    for (int i=0; i<num_of_slices; i++)
        {
            for (int j=0; j<parameter[i].second; j++)
                {
                    value <<= 1; //shift left
                    if (bits[GALILEO_DATA_JK_BITS - parameter[i].first - j] == 1)
                        {
                            value += 1; // insert the bit
                        }
                }
        }
    return value;
}



unsigned long int Galileo_Navigation_Message::read_page_type_unsigned(std::bitset<GALILEO_PAGE_TYPE_BITS> bits, const std::vector<std::pair<int,int> > parameter)
{
    unsigned long int value = 0;
    int num_of_slices = parameter.size();
    for (int i=0; i<num_of_slices; i++)
        {
            for (int j=0; j<parameter[i].second; j++)
                {
                    value <<= 1; //shift left
                    if (bits[GALILEO_PAGE_TYPE_BITS - parameter[i].first - j] == 1)
                        {
                            value += 1; // insert the bit
                        }
                }
        }
    return value;
}



signed long int Galileo_Navigation_Message::read_navigation_signed(std::bitset<GALILEO_DATA_JK_BITS> bits, const std::vector<std::pair<int,int> > parameter)
{
    signed long int value = 0;
    int num_of_slices = parameter.size();
    // Discriminate between 64 bits and 32 bits compiler
    int long_int_size_bytes = sizeof(signed long int);
    if (long_int_size_bytes == 8) // if a long int takes 8 bytes, we are in a 64 bits system
        {
            // read the MSB and perform the sign extension
            if (bits[GALILEO_DATA_JK_BITS - parameter[0].first] == 1)
                {
                    value ^= 0xFFFFFFFFFFFFFFFF; //64 bits variable
                }
            else
                {
                    value &= 0;
                }

            for (int i=0; i<num_of_slices; i++)
                {
                    for (int j=0; j<parameter[i].second; j++)
                        {
                            value <<= 1; //shift left
                            value &= 0xFFFFFFFFFFFFFFFE; //reset the corresponding bit (for the 64 bits variable)
                            if (bits[GALILEO_DATA_JK_BITS - parameter[i].first - j] == 1)
                                {
                                    value += 1; // insert the bit
                                }
                        }
                }
        }
    else  // we assume we are in a 32 bits system
        {
            // read the MSB and perform the sign extension
            if (bits[GALILEO_DATA_JK_BITS - parameter[0].first] == 1)
                {
                    value ^= 0xFFFFFFFF;
                }
            else
                {
                    value &= 0;
                }

            for (int i=0; i<num_of_slices; i++)
                {
                    for (int j=0; j<parameter[i].second; j++)
                        {
                            value <<= 1; //shift left
                            value &= 0xFFFFFFFE; //reset the corresponding bit
                            if (bits[GALILEO_DATA_JK_BITS - parameter[i].first - j] == 1)
                                {
                                    value += 1; // insert the bit
                                }
                        }
                }
        }
    return value;
}

bool Galileo_Navigation_Message::read_navigation_bool(std::bitset<GALILEO_DATA_JK_BITS> bits, const std::vector<std::pair<int,int> > parameter)
{
    bool value;

    if (bits[GALILEO_DATA_JK_BITS - parameter[0].first] == 1)
        {
            value = true;
        }
    else
        {
            value = false;
        }
    return value;
}

/*void Galileo_Navigation_Message::print_galileo_word_bytes(unsigned int GPS_word)
{
    std::cout << " Word =";
    std::cout << std::bitset<32>(GPS_word);
    std::cout << std::endl;
}*/


void Galileo_Navigation_Message::split_page(std::string page_string, int flag_even_word){

	// ToDo: Clean all the tests and create an independent google test code for the telemetry decoder.
	//char correct_tail[7]="011110"; //the viterbi decoder output change the tail to this value (why?)
	//char correct_tail[7]="000000";

	int Page_type=0;
	//std::cout << "Start decoding Galileo I/NAV " << std::endl;

	if(page_string.at(0)=='1')// if page is odd
	{
		//std::cout<< "page_string.at(0) split page="<<page_string.at(0) << std::endl;
		std::string page_Odd = page_string; //chiamo la stringa sembre page_Odd
		//std::cout<<"Page odd string in split page"<< std::endl << page_Odd << std::endl;

		if (flag_even_word==1)/*Under this condition An odd page has been received but the previous even page is kept in memory and it is considered to join pages*/
				{
					//std::cout<<"previous page even "<< std::endl << page_Even << std::endl;
					std::string page_INAV_even = page_Even;
					//std::cout << "page inav solo even" << page_INAV_even << std::endl;
					std::string page_INAV = page_INAV_even + page_Odd; //Join pages: Even+Odd=INAV page
					//std::cout << "page inav eve +odd " << page_INAV<< std::endl;
					std::string Even_bit = page_INAV.substr (0,1);
					//std::cout << "Even bit = " << Even_bit << endl;
					std::string Page_type_even = page_INAV.substr (1,1);
					//std::cout << "Page type even = " << Page_type_even << endl;
					std::string nominal = "0";

					//if (Page_type_even.compare(nominal) != 0)
					//		std::cout << "Alert frame "<< std::endl;
					//else std::cout << "Nominal Page" << std::endl;

					std::string Data_k = page_INAV.substr (2,112);
					//std::cout << "Data_k " << endl << Data_k << endl;
					std::string Odd_bit = page_INAV.substr (114,1);
					std::string Page_type_Odd = page_INAV.substr (115,1);
					//std::cout << "Page_type_Odd: " << Page_type_Odd << endl;
					std::string Data_j = page_INAV.substr (116,16);
					//std::cout << "Data_j: " << Data_j << endl;

					std::string Reserved_1 = page_INAV.substr (132,40);
					std::string SAR = page_INAV.substr (172,22);
					std::string Spare = page_INAV.substr (194,2);
					std::string CRC_data = page_INAV.substr (196,24);
					std::string Reserved_2 = page_INAV.substr (220,8);
					std::string Tail_odd = page_INAV.substr (228,6);

					//************ CRC checksum control *******/
					std::stringstream TLM_word_for_CRC_stream;

					TLM_word_for_CRC_stream<<page_INAV;
					std::string TLM_word_for_CRC;
					TLM_word_for_CRC=TLM_word_for_CRC_stream.str().substr(0,GALILEO_DATA_FRAME_BITS);

					//std::cout<<"Complete word for CRC test: "<<TLM_word_for_CRC<<std::endl;
					std::bitset<GALILEO_DATA_FRAME_BITS> TLM_word_for_CRC_bits(TLM_word_for_CRC);
					std::bitset<24> checksum(CRC_data);

					//if (Tail_odd.compare(correct_tail) != 0)
					//		std::cout << "Tail odd is not correct!" << std::endl;
					//else std::cout<<"Tail odd is correct!"<<std::endl;

					if (CRC_test(TLM_word_for_CRC_bits,checksum.to_ulong())==true)
					{
						flag_CRC_test = true;
						// CRC correct: Decode word
						std::string page_number_bits = Data_k.substr (0,6);
						//std::cout << "Page number bits from Data k" << std::endl << page_number_bits << std::endl;

						std::bitset<GALILEO_PAGE_TYPE_BITS> page_type_bits (page_number_bits); // from string to bitset
						Page_type = (int)read_page_type_unsigned(page_type_bits, type);
						Page_type_time_stamp = Page_type;
						//std::cout << "Page number (first 6 bits of Data k converted to decimal) = " << Page_type << std::endl;
						std::string Data_jk_ephemeris = Data_k + Data_j;
						//std::cout<<"Data j k ephemeris" << endl << Data_jk_ephemeris << endl;

						page_jk_decoder(Data_jk_ephemeris.c_str()); // Corresponding to ephemeris_decode.m in matlab code
/*this block is just to try some function, it must be eliminated
						double t_GST;
						if ((have_new_iono_and_GST() == true) and (flag_all_ephemeris==true))
						{
							std::cout <<"GST and ephemeris parameters have been received, now it is possible to compute satellite position"<< std::endl;
							t_GST = Galileo_System_Time(WN_5, TOW_5);
							std::cout << "Galileo System Time [sec]: " << t_GST << std::endl;
							satellitePosition(t_GST);
							flag_all_ephemeris=false;
						}

						double t_UTC;
						if ((have_new_iono_and_GST() == true) and (have_new_utc_model() == true))
						{
							t_UTC = GST_to_UTC_time(t_GST, WN_5);
							std::cout << "UTC [sec]: " << t_UTC << std::endl;
						}
*/
					}else{
						// CRC wrong.. discard frame
						flag_CRC_test= false;
					}
					//********** end of CRC checksum control ***/
				}

		} /*end if (page_string.at(0)=='1') */

	else{
	page_Even = page_string.substr (0,114);
	//std::cout << "Page even in split page" << std::endl << page_Even << std::endl;
	std::string tail_Even =  page_string.substr (114,6);
	//std::cout << "tail_even_string: " << tail_Even <<std::endl;
	//if (tail_Even.compare(correct_tail) != 0)
	//	 std::cout << "Tail even is not correct!" << std::endl;
	//else std::cout<<"Tail even is correct!"<< std::endl;

	}

}


bool Galileo_Navigation_Message::have_new_ephemeris() //Check if we have a new ephemeris stored in the galileo navigation class
{
	if ((flag_ephemeris_1 == true) and (flag_ephemeris_2 == true) and (flag_ephemeris_3 == true) and (flag_ephemeris_4 == true) and (flag_iono_and_GST == true))
	{
		//if all ephemeris pages have the same IOD, then they belong to the same block
			if ((IOD_nav_1 == IOD_nav_2) and (IOD_nav_3 == IOD_nav_4) and (IOD_nav_1 == IOD_nav_3))
			{
				std::cout<< "Ephemeris (1, 2, 3, 4) have been received and belong to the same batch"<< std::endl;
				flag_ephemeris_1 = false;// clear the flag
				flag_ephemeris_2 = false;// clear the flag
				flag_ephemeris_3 = false;// clear the flag
				flag_ephemeris_4 = false;// clear the flag
				flag_all_ephemeris = true;
				IOD_ephemeris = IOD_nav_1;
				std::cout << "Batch number: "<< IOD_ephemeris << std::endl;
					return true;
			}else{
				return false;
			}
	 }
	else
		return false;
}


bool Galileo_Navigation_Message::have_new_iono_and_GST() //Check if we have a new iono data set stored in the galileo navigation class
{
	if ((flag_iono_and_GST == true) and (flag_utc_model == true)) //the condition on flag_utc_model is added to have a time stamp for iono
	{
		flag_iono_and_GST=false; // clear the flag
		return true;
	}else
		return false;
}


bool Galileo_Navigation_Message::have_new_utc_model() // Check if we have a new utc data set stored in the galileo navigation class
{
	if (flag_utc_model == true)
	{
		flag_utc_model=false; // clear the flag
		return true;
	}
	else
		return false;
}


bool Galileo_Navigation_Message::have_new_almanac() //Check if we have a new almanac data set stored in the galileo navigation class
{
	if ((flag_almanac_1 == true) and (flag_almanac_2 == true) and (flag_almanac_3 == true) and (flag_almanac_4 == true))
	{
		//std::cout<< "All almanac have been received"<< std::endl;
		flag_almanac_1 = false;
		flag_almanac_2 = false;
		flag_almanac_3 = false;
		flag_almanac_4 = false;
		flag_all_almanac = true;
		return true;
	 }
	else
		return false;
}

Galileo_Ephemeris Galileo_Navigation_Message::get_ephemeris()
{

	Galileo_Ephemeris ephemeris;
	ephemeris.flag_all_ephemeris = flag_all_ephemeris;
	ephemeris.IOD_ephemeris = IOD_ephemeris;
	ephemeris.SV_ID_PRN_4 = SV_ID_PRN_4;
	ephemeris.i_satellite_PRN=SV_ID_PRN_4;
	ephemeris.M0_1 = M0_1;		// Mean anomaly at reference time [semi-circles]
	ephemeris.delta_n_3 = delta_n_3;		// Mean motion difference from computed value  [semi-circles/sec]
	ephemeris.e_1 =	e_1;	// Eccentricity
	ephemeris.A_1 =  A_1; 	// Square root of the semi-major axis [metres^1/2]
	ephemeris.OMEGA_0_2 = OMEGA_0_2;// Longitude of ascending node of orbital plane at weekly epoch [semi-circles]
	ephemeris.i_0_2 = i_0_2;    // Inclination angle at reference time  [semi-circles]
	ephemeris.omega_2 = omega_2;  // Argument of perigee [semi-circles]
	ephemeris.OMEGA_dot_3 =	OMEGA_dot_3;	// Rate of right ascension [semi-circles/sec]
	ephemeris.iDot_2 = iDot_2;   // Rate of inclination angle [semi-circles/sec]
	ephemeris.C_uc_3 = C_uc_3;		// Amplitude of the cosine harmonic correction term to the argument of latitude [radians]
	ephemeris.C_us_3 = C_us_3;			// Amplitude of the sine harmonic correction term to the argument of latitude [radians]
	ephemeris.C_rc_3 = C_rc_3;			// Amplitude of the cosine harmonic correction term to the orbit radius [meters]
	ephemeris.C_rs_3 = C_rs_3;			// Amplitude of the sine harmonic correction term to the orbit radius [meters]
	ephemeris.C_ic_4 = C_ic_4;		// Amplitude of the cosine harmonic correction 	term to the angle of inclination [radians]
	ephemeris.C_is_4 = C_is_4;		// Amplitude of the sine harmonic correction term to the angle of inclination [radians]
	ephemeris.t0e_1 = t0e_1;	// Ephemeris reference time [s]

	/*Clock correction parameters*/
	ephemeris.t0c_4 = t0c_4;			//Clock correction data reference Time of Week [sec]
	ephemeris.af0_4 = af0_4;			//SV clock bias correction coefficient [s]
	ephemeris.af1_4 = af1_4;		//SV clock drift correction coefficient [s/s]
	ephemeris.af2_4 = af2_4;		//SV clock drift rate correction coefficient [s/s^2]

	/*GST*/
	ephemeris.WN_5 = WN_5;//Week number
	ephemeris.TOW_5 = TOW_5;//Time of Week
	return ephemeris;
}


Galileo_Iono Galileo_Navigation_Message::get_iono()
{
	Galileo_Iono iono;
	 /*Ionospheric correction*/
	 /*Az*/
	 iono.ai0_5 = ai0_5;		//Effective Ionisation Level 1st order parameter [sfu]
	 iono.ai1_5 = ai1_5;		//Effective Ionisation Level 2st order parameter [sfu/degree]
	 iono.ai2_5 = ai2_5;		//Effective Ionisation Level 3st order parameter [sfu/degree]

	 /*Ionospheric disturbance flag*/
	 iono.Region1_flag_5 = Region1_flag_5;	// Ionospheric Disturbance Flag for region 1
	 iono.Region2_flag_5 = Region2_flag_5;	// Ionospheric Disturbance Flag for region 2
	 iono.Region3_flag_5 = Region3_flag_5;	// Ionospheric Disturbance Flag for region 3
	 iono.Region4_flag_5 = Region4_flag_5;	// Ionospheric Disturbance Flag for region 4
	 iono.Region5_flag_5 = Region5_flag_5;	// Ionospheric Disturbance Flag for region 5

	 /*GST*/
	 // This is the ONLY page containing the Week Number (WN)
	 iono.TOW_5 = TOW_5;
     iono.WN_5 = WN_5;
	return iono;
}


Galileo_Utc_Model Galileo_Navigation_Message::get_utc_model()
{
	Galileo_Utc_Model utc_model;
	//Gal_utc_model.valid = flag_utc_model_valid;
	/*Word type 6: GST-UTC conversion parameters*/
	utc_model.A0_6 = A0_6;
	utc_model.A1_6 = A1_6;
	utc_model.Delta_tLS_6 = Delta_tLS_6;
	utc_model.t0t_6 = t0t_6;
	utc_model.WNot_6 = WNot_6;
	utc_model.WN_LSF_6 = WN_LSF_6;
	utc_model.DN_6 = DN_6;
	utc_model.Delta_tLSF_6 = Delta_tLSF_6;
    utc_model.flag_utc_model = flag_utc_model;
	/*GST*/
	//utc_model.WN_5 = WN_5; //Week number
	//utc_model.TOW_5 = WN_5; //Time of Week
	return utc_model;
}


Galileo_Almanac Galileo_Navigation_Message::get_almanac()
{
	Galileo_Almanac almanac;
	/*Word type 7: Almanac for SVID1 (1/2), almanac reference time and almanac reference week number*/
	    almanac.IOD_a_7 = IOD_a_7;
		almanac.WN_a_7 = WN_a_7;
		almanac.t0a_7 = t0a_7;
		almanac.SVID1_7 = SVID1_7;
		almanac.DELTA_A_7 = DELTA_A_7;
		almanac.e_7 = e_7;
		almanac.omega_7 = omega_7;
		almanac.delta_i_7 = delta_i_7;
		almanac.Omega0_7 = Omega0_7;
		almanac.Omega_dot_7 = Omega_dot_7;
		almanac.M0_7 = M0_7;

		/*Word type 8: Almanac for SVID1 (2/2) and SVID2 (1/2)*/
		almanac.IOD_a_8 = IOD_a_8;
		almanac.af0_8 = af0_8;
		almanac.af1_8 = af1_8;
		almanac.E5b_HS_8 = E5b_HS_8;
		almanac.E1B_HS_8 = E1B_HS_8;
		almanac.SVID2_8 = SVID2_8;
		almanac.DELTA_A_8 = DELTA_A_8;
		almanac.e_8 = e_8;
		almanac.omega_8 = omega_8;
		almanac.delta_i_8 = delta_i_8;
		almanac.Omega0_8 = Omega0_8;
		almanac.Omega_dot_8 = Omega_dot_8;

		/*Word type 9: Almanac for SVID2 (2/2) and SVID3 (1/2)*/
		almanac.IOD_a_9 = IOD_a_9;
		almanac.WN_a_9 = WN_a_9;
		almanac.t0a_9 = t0a_9;
		almanac.M0_9 = M0_9;
		almanac.af0_9 = af0_9;
		almanac.af1_9 = af1_9;
		almanac.E5b_HS_9 = E5b_HS_9;
		almanac.E1B_HS_9 = E1B_HS_9;
		almanac.SVID3_9 = SVID3_9;
		almanac.DELTA_A_9 = DELTA_A_9;
		almanac.e_9 = e_9;
		almanac.omega_9 = omega_9;
		almanac.delta_i_9 = delta_i_9;


		/*Word type 10: Almanac for SVID3 (2/2)*/
		almanac.IOD_a_10 = IOD_a_10;
		almanac.Omega0_10 = Omega0_10;
		almanac.Omega_dot_10 = Omega_dot_10;
		almanac.M0_10 = M0_10;
		almanac.af0_10 = af0_10;
		almanac.af1_10 = af1_10;
		almanac.E5b_HS_10 = E5b_HS_10;
		almanac.E1B_HS_10 = E1B_HS_10;
	return almanac;
}


int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
{
	//DLOG(INFO) << "--------------------------------------------------------------------------" << std::endl;
	//DLOG(INFO)<< "Entered in function Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)" << std::endl;

    int page_number = 0;

    std::string data_jk_string = data_jk;
    std::bitset<GALILEO_DATA_JK_BITS> data_jk_bits (data_jk_string);

    //DLOG(INFO) << "Data_jk_bits (bitset)  "<< endl << data_jk_bits << endl;

    page_number = (int)read_navigation_unsigned(data_jk_bits, PAGE_TYPE_bit);
    DLOG(INFO) << "Page number = " << page_number << std::endl;

    switch (page_number)
        {
    case 1: /*Word type 1: Ephemeris (1/4)*/
        		IOD_nav_1=(int)read_navigation_unsigned(data_jk_bits, IOD_nav_1_bit);
        		DLOG(INFO)<<"IOD_nav_1= "<< IOD_nav_1 <<std::endl;

        		t0e_1=(double)read_navigation_unsigned(data_jk_bits, T0E_1_bit);
        		t0e_1 = t0e_1 * t0e_1_LSB;
        		DLOG(INFO) << "t0e_1= " << t0e_1 <<std::endl;

        		M0_1 = (double)read_navigation_signed(data_jk_bits, M0_1_bit);
        		M0_1 =  M0_1 * M0_1_LSB;
        		DLOG(INFO) << "M0_1= " << M0_1<<std::endl;

        		e_1 = (double)read_navigation_unsigned(data_jk_bits, e_1_bit);
        		e_1 = e_1 * e_1_LSB;
        		DLOG(INFO) << "e_1= " << e_1 <<std::endl;

        		A_1 = (double)read_navigation_unsigned(data_jk_bits, A_1_bit);
        		A_1 = A_1 * A_1_LSB_gal;
        		DLOG(INFO) << "A_1= " << A_1 <<std::endl;
        		flag_ephemeris_1 = true;
        		DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
        		break;
        	case 2:  /*Word type 2: Ephemeris (2/4)*/
        		IOD_nav_2 = (int)read_navigation_unsigned(data_jk_bits, IOD_nav_2_bit);
        		DLOG(INFO)<<"IOD_nav_2= "<< IOD_nav_2 <<std::endl;

        		OMEGA_0_2 = (double)read_navigation_signed(data_jk_bits, OMEGA_0_2_bit);
        		OMEGA_0_2 = OMEGA_0_2 * OMEGA_0_2_LSB;
        		DLOG(INFO)<<"OMEGA_0_2= "<< OMEGA_0_2 <<std::endl;
        		i_0_2 = (double)read_navigation_signed(data_jk_bits, i_0_2_bit);
        		i_0_2 = i_0_2 * i_0_2_LSB;
        		DLOG(INFO)<<"i_0_2= "<< i_0_2 <<std::endl;
        		omega_2 = (double)read_navigation_signed(data_jk_bits, omega_2_bit);
        		omega_2 = omega_2 * omega_2_LSB;
        		DLOG(INFO)<<"omega_2= "<< omega_2 <<std::endl;
        		iDot_2 = (double)read_navigation_signed(data_jk_bits, iDot_2_bit);
        		iDot_2 = iDot_2 * iDot_2_LSB;
        		DLOG(INFO)<<"iDot_2= "<< iDot_2 <<std::endl;
        		flag_ephemeris_2 = true;
        		DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
        		break;
        	case 3:  /*Word type 3: Ephemeris (3/4) and SISA*/
        		IOD_nav_3 = (int)read_navigation_unsigned(data_jk_bits, IOD_nav_3_bit);
        		DLOG(INFO)<<"IOD_nav_3= "<< IOD_nav_3 <<std::endl;
        		OMEGA_dot_3 = (double)read_navigation_signed(data_jk_bits, OMEGA_dot_3_bit);
        		OMEGA_dot_3 = OMEGA_dot_3 * OMEGA_dot_3_LSB;
        		DLOG(INFO)<<"OMEGA_dot_3= "<< OMEGA_dot_3 <<std::endl;
        		delta_n_3 = (double)read_navigation_signed(data_jk_bits, delta_n_3_bit);
        		delta_n_3 = delta_n_3 * delta_n_3_LSB;
        		DLOG(INFO)<<"delta_n_3= "<< delta_n_3 <<std::endl;
        		C_uc_3 = (double)read_navigation_signed(data_jk_bits, C_uc_3_bit);
        		C_uc_3 = C_uc_3 * C_uc_3_LSB;
        		DLOG(INFO)<<"C_uc_3= "<< C_uc_3 <<std::endl;
        		C_us_3 = (double)read_navigation_signed(data_jk_bits, C_us_3_bit);
        		C_us_3 = C_us_3 * C_us_3_LSB;
        		DLOG(INFO)<<"C_us_3= "<< C_us_3 <<std::endl;
        		C_rc_3 = (double)read_navigation_signed(data_jk_bits, C_rc_3_bit);
        		C_rc_3 = C_rc_3 * C_rc_3_LSB;
        		DLOG(INFO)<<"C_rc_3= "<< C_rc_3 <<std::endl;
        		C_rs_3 = (double)read_navigation_signed(data_jk_bits, C_rs_3_bit);
        		C_rs_3 = C_rs_3 * C_rs_3_LSB;
        		DLOG(INFO)<<"C_rs_3= "<< C_rs_3 <<std::endl;
        		SISA_3 = (double)read_navigation_unsigned(data_jk_bits, SISA_3_bit);
        		DLOG(INFO)<<"SISA_3= "<< SISA_3 <<std::endl;
        		flag_ephemeris_3 = true;
        		DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
        		break;

        	case 4: /* Word type 4: Ephemeris (4/4) and Clock correction parameters*/
        		IOD_nav_4 = (int)read_navigation_unsigned(data_jk_bits, IOD_nav_4_bit);
        		DLOG(INFO)<<"IOD_nav_4= "<< IOD_nav_4 <<std::endl;
        		SV_ID_PRN_4 = (int)read_navigation_unsigned(data_jk_bits, SV_ID_PRN_4_bit);
        		DLOG(INFO)<<"SV_ID_PRN_4= "<< SV_ID_PRN_4 <<std::endl;
        		C_ic_4 = (double)read_navigation_signed(data_jk_bits, C_ic_4_bit);
        		C_ic_4 = C_ic_4 * C_ic_4_LSB;
        		DLOG(INFO)<<"C_ic_4= "<< C_ic_4 <<std::endl;
        		C_is_4 = (double)read_navigation_signed(data_jk_bits, C_is_4_bit);
        		C_is_4 = C_is_4 * C_is_4_LSB;
        		DLOG(INFO)<<"C_is_4= "<< C_is_4 <<std::endl;
        		/*Clock correction parameters*/
        		t0c_4 = (double)read_navigation_unsigned(data_jk_bits, t0c_4_bit);
        		t0c_4 = t0c_4 * t0c_4_LSB;
        		DLOG(INFO)<<"t0c_4= "<< t0c_4 <<std::endl;
        		af0_4 = (double)read_navigation_signed(data_jk_bits, af0_4_bit);
        		af0_4 = af0_4 * af0_4_LSB;
        		DLOG(INFO)<<"af0_4 = "<< af0_4  <<std::endl;
        		af1_4 = (double)read_navigation_signed(data_jk_bits, af1_4_bit);
        		af1_4 = af1_4 * af1_4_LSB;
        		DLOG(INFO)<<"af1_4 = "<< af1_4  <<std::endl;
        		af2_4 = (double)read_navigation_signed(data_jk_bits, af2_4_bit);
        		af2_4 = af2_4 * af2_4_LSB;
        		DLOG(INFO)<<"af2_4 = "<< af2_4  <<std::endl;
        		spare_4 = (double)read_navigation_unsigned(data_jk_bits, spare_4_bit);
        		DLOG(INFO)<<"spare_4 = "<< spare_4  <<std::endl;
        		flag_ephemeris_4 = true;
        		DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
        		break;

        	case 5: /*Word type 5: Ionospheric correction, BGD, signal health and data validity status and GST*/
        		 /*Ionospheric correction*/
        		 /*Az*/
        		ai0_5 = (double)read_navigation_unsigned(data_jk_bits, ai0_5_bit);
        		ai0_5 = ai0_5 * ai0_5_LSB;
        		DLOG(INFO)<<"ai0_5= "<< ai0_5 <<std::endl;
        		ai1_5 = (double)read_navigation_signed(data_jk_bits, ai1_5_bit);
        		ai1_5 = ai1_5 * ai1_5_LSB;
        		DLOG(INFO)<<"ai1_5= "<< ai1_5 <<std::endl;
        		ai2_5 = (double)read_navigation_signed(data_jk_bits, ai2_5_bit);
        		ai2_5 = ai2_5 * ai2_5_LSB;
        		DLOG(INFO)<<"ai2_5= "<< ai2_5 <<std::endl;
        		/*Ionospheric disturbance flag*/
        		Region1_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region1_5_bit);
        		DLOG(INFO)<<"Region1_flag_5= "<< Region1_flag_5 <<std::endl;
        		Region2_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region2_5_bit);
        		DLOG(INFO)<<"Region2_flag_5= "<< Region2_flag_5 <<std::endl;
        		Region3_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region3_5_bit);
        		DLOG(INFO)<<"Region3_flag_5= "<< Region3_flag_5 <<std::endl;
        		Region4_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region4_5_bit);
        		DLOG(INFO)<<"Region4_flag_5= "<< Region4_flag_5 <<std::endl;
        		Region5_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region5_5_bit);
        		DLOG(INFO)<<"Region5_flag_5= "<< Region5_flag_5 <<std::endl;
        		BGD_E1E5a_5 = (double)read_navigation_signed(data_jk_bits, BGD_E1E5a_5_bit);
        		BGD_E1E5a_5 = BGD_E1E5a_5 * BGD_E1E5a_5_LSB;
        		DLOG(INFO)<<"BGD_E1E5a_5= "<< BGD_E1E5a_5 <<std::endl;
        		BGD_E1E5b_5 = (double)read_navigation_signed(data_jk_bits, BGD_E1E5b_5_bit);
        		BGD_E1E5b_5 = BGD_E1E5b_5 * BGD_E1E5b_5_LSB;
        		DLOG(INFO)<<"BGD_E1E5b_5= "<< BGD_E1E5b_5 <<std::endl;
        		E5b_HS_5 = (double)read_navigation_unsigned(data_jk_bits, E5b_HS_5_bit);
        		DLOG(INFO)<<"E5b_HS_5= "<< E5b_HS_5 <<std::endl;
        		E1B_HS_5 = (double)read_navigation_unsigned(data_jk_bits, E1B_HS_5_bit);
        		DLOG(INFO)<<"E1B_HS_5= "<< E1B_HS_5 <<std::endl;
        		E5b_DVS_5 = (double)read_navigation_unsigned(data_jk_bits, E5b_DVS_5_bit);
        		DLOG(INFO)<<"E5b_DVS_5= "<< E5b_DVS_5 <<std::endl;
        		E1B_DVS_5 = (double)read_navigation_unsigned(data_jk_bits, E1B_DVS_5_bit);
        		DLOG(INFO)<<"E1B_DVS_5= "<< E1B_DVS_5 <<std::endl;
        		/*GST*/
        		WN_5 = (double)read_navigation_unsigned(data_jk_bits, WN_5_bit);
        		DLOG(INFO)<<"WN_5= "<< WN_5 <<std::endl;
        		TOW_5 = (double)read_navigation_unsigned(data_jk_bits, TOW_5_bit);
        		DLOG(INFO)<<"TOW_5= "<< TOW_5 <<std::endl;
        		flag_TOW_5 = true; //set to false externally
        		spare_5 = (double)read_navigation_unsigned(data_jk_bits, spare_5_bit);
        		DLOG(INFO)<<"spare_5= "<< spare_5 <<std::endl;
        		flag_iono_and_GST = true; //set to false externally
        		flag_TOW_set = true; //set to false externally
        		DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
        		break;

        	case 6: /*Word type 6: GST-UTC conversion parameters*/
        	    A0_6= (double)read_navigation_signed(data_jk_bits, A0_6_bit);
        	    A0_6= A0_6 * A0_6_LSB;
        	    DLOG(INFO) << "A0_6= " << A0_6 << std::endl;

        	    A1_6= (double)read_navigation_signed(data_jk_bits, A1_6_bit);
        	    A1_6= A1_6 * A1_6_LSB;
        	    DLOG(INFO) << "A1_6= " << A1_6 << std::endl;

        	    Delta_tLS_6= (double)read_navigation_signed(data_jk_bits, Delta_tLS_6_bit);
        	    DLOG(INFO) << "Delta_tLS_6= " << Delta_tLS_6 << std::endl;

        	    t0t_6= (double)read_navigation_unsigned(data_jk_bits, t0t_6_bit);
        	    t0t_6= t0t_6 * t0t_6_LSB;
        	    DLOG(INFO) << "t0t_6= " << t0t_6 << std::endl;

        	    WNot_6= (double)read_navigation_unsigned(data_jk_bits, WNot_6_bit);
        	    DLOG(INFO) << "WNot_6= " << WNot_6 << std::endl;

        	    WN_LSF_6= (double)read_navigation_unsigned(data_jk_bits, WN_LSF_6_bit);
        	    DLOG(INFO) << "WN_LSF_6= " << WN_LSF_6 << std::endl;

        	    DN_6= (double)read_navigation_unsigned(data_jk_bits, DN_6_bit);
        	    DLOG(INFO) << "DN_6= " << DN_6 << std::endl;

        	    Delta_tLSF_6= (double)read_navigation_signed(data_jk_bits, Delta_tLSF_6_bit);
        	    DLOG(INFO) << "Delta_tLSF_6= " << Delta_tLSF_6 << std::endl;

        	    TOW_6= (double)read_navigation_unsigned(data_jk_bits, TOW_6_bit);
        	    DLOG(INFO) << "TOW_6= " << TOW_6 << std::endl;
        	    flag_TOW_6 = true; //set to false externally
        	    flag_utc_model = true; //set to false externally
        	    flag_TOW_set = true; //set to false externally
        	    DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
        	    break;

         case 7: /*Word type 7: Almanac for SVID1 (1/2), almanac reference time and almanac reference week number*/

        	    IOD_a_7= (double)read_navigation_unsigned(data_jk_bits, IOD_a_7_bit);
        	    DLOG(INFO) << "IOD_a_7= " << IOD_a_7 << std::endl;

        	    WN_a_7= (double)read_navigation_unsigned(data_jk_bits, WN_a_7_bit);
        	    DLOG(INFO) << "WN_a_7= " << WN_a_7 << std::endl;

        	    t0a_7= (double)read_navigation_unsigned(data_jk_bits, t0a_7_bit);
        	    t0a_7= t0a_7 * t0a_7_LSB;
        	    DLOG(INFO) << "t0a_7= " << t0a_7 << std::endl;

        	    SVID1_7= (double)read_navigation_unsigned(data_jk_bits, SVID1_7_bit);
        	    DLOG(INFO) << "SVID1_7= " << SVID1_7 << std::endl;

        	    DELTA_A_7= (double)read_navigation_signed(data_jk_bits, DELTA_A_7_bit);
        	    DELTA_A_7= DELTA_A_7 * DELTA_A_7_LSB;
        	    DLOG(INFO) << "DELTA_A_7= " << DELTA_A_7 << std::endl;

        	    e_7= (double)read_navigation_unsigned(data_jk_bits, e_7_bit);
        	    e_7= e_7 * e_7_LSB;
        	    DLOG(INFO) << "e_7= " << e_7 << std::endl;

        	    omega_7= (double)read_navigation_signed(data_jk_bits, omega_7_bit);
        	    omega_7= omega_7 * omega_7_LSB;
        	    DLOG(INFO) << "omega_7= " << omega_7 << std::endl;

        	    delta_i_7= (double)read_navigation_signed(data_jk_bits, delta_i_7_bit);
        	    delta_i_7= delta_i_7 * delta_i_7_LSB;
        	    DLOG(INFO) << "delta_i_7= " << delta_i_7 << std::endl;

        	    Omega0_7= (double)read_navigation_signed(data_jk_bits, Omega0_7_bit);
        	    Omega0_7= Omega0_7 * Omega0_7_LSB;
        	    DLOG(INFO) << "Omega0_7= " << Omega0_7 << std::endl;

        	    Omega_dot_7= (double)read_navigation_signed(data_jk_bits, Omega_dot_7_bit);
        	    Omega_dot_7= Omega_dot_7 * Omega_dot_7_LSB;
        	    DLOG(INFO) << "Omega_dot_7= " << Omega_dot_7 << std::endl;

        	    M0_7= (double)read_navigation_signed(data_jk_bits, M0_7_bit);
        	    M0_7= M0_7 * M0_7_LSB;
        	    DLOG(INFO) << "M0_7= " << M0_7 << std::endl;
        	    flag_almanac_1 = true;
        	    DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
        	    break;

        case 8: /*Word type 8: Almanac for SVID1 (2/2) and SVID2 (1/2)*/

        		IOD_a_8= (double)read_navigation_signed(data_jk_bits, IOD_a_8_bit);
        		DLOG(INFO) << "IOD_a_8= " << IOD_a_8 << std::endl;

        		af0_8= (double)read_navigation_signed(data_jk_bits, af0_8_bit);
        		af0_8= af0_8 * af0_8_LSB;
        		DLOG(INFO) << "af0_8= " << af0_8 << std::endl;

        	    af1_8= (double)read_navigation_signed(data_jk_bits, af1_8_bit);
        	    af1_8= af1_8 * af1_8_LSB;
        	    DLOG(INFO) << "af1_8= " << af1_8 << std::endl;

        	    E5b_HS_8= (double)read_navigation_unsigned(data_jk_bits, E5b_HS_8_bit);
        	    DLOG(INFO) << "E5b_HS_8= " << E5b_HS_8 << std::endl;

        	    E1B_HS_8= (double)read_navigation_unsigned(data_jk_bits, E1B_HS_8_bit);
        	    DLOG(INFO) << "E1B_HS_8= " << E1B_HS_8 << std::endl;

        	    SVID2_8= (double)read_navigation_unsigned(data_jk_bits, SVID2_8_bit);
        	    DLOG(INFO) << "SVID2_8= " << SVID2_8 << std::endl;

        	    DELTA_A_8= (double)read_navigation_signed(data_jk_bits, DELTA_A_8_bit);
        	    DELTA_A_8= DELTA_A_8 * DELTA_A_8_LSB;
        	    DLOG(INFO) << "DELTA_A_8= " << DELTA_A_8 << std::endl;

        	    e_8= (double)read_navigation_unsigned(data_jk_bits, e_8_bit);
        	    e_8= e_8 * e_8_LSB;
        	    DLOG(INFO) << "e_8= " << e_8 << std::endl;

        	    omega_8= (double)read_navigation_signed(data_jk_bits, omega_8_bit);
        	    omega_8= omega_8 * omega_8_LSB;
        	    DLOG(INFO) << "omega_8= " << omega_8 << std::endl;

        	    delta_i_8= (double)read_navigation_signed(data_jk_bits, delta_i_8_bit);
        	    delta_i_8= delta_i_8 * delta_i_8_LSB;
        	    DLOG(INFO) << "delta_i_8= " << delta_i_8 << std::endl;

        	    Omega0_8= (double)read_navigation_signed(data_jk_bits, Omega0_8_bit);
        	    Omega0_8= Omega0_8 * Omega0_8_LSB;
        	    DLOG(INFO) << "Omega0_8= " << Omega0_8 << std::endl;

        	    Omega_dot_8= (double)read_navigation_signed(data_jk_bits, Omega_dot_8_bit);
        	    Omega_dot_8= Omega_dot_8 * Omega_dot_8_LSB;
        	    DLOG(INFO) << "Omega_dot_8= " << Omega_dot_8 << std::endl;
        	    flag_almanac_2 = true;
        	    DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
        	    break;

        	case 9: /*Word type 9: Almanac for SVID2 (2/2) and SVID3 (1/2)*/

        	    IOD_a_9= (double)read_navigation_unsigned(data_jk_bits, IOD_a_9_bit);
        	    DLOG(INFO) << "IOD_a_9= " << IOD_a_9 << std::endl;

        	    WN_a_9= (double)read_navigation_unsigned(data_jk_bits, WN_a_9_bit);
        	    DLOG(INFO) << "WN_a_9= " << WN_a_9 << std::endl;

        	    t0a_9= (double)read_navigation_unsigned(data_jk_bits, t0a_9_bit);
        	    t0a_9= t0a_9 * t0a_9_LSB;
        	    DLOG(INFO) << "t0a_9= " << t0a_9 << std::endl;

        	    M0_9= (double)read_navigation_signed(data_jk_bits, M0_9_bit);
        	    M0_9= M0_9 * M0_9_LSB;
        	    DLOG(INFO) << "M0_9= " << M0_9 << std::endl;

        	    af0_9= (double)read_navigation_signed(data_jk_bits, af0_9_bit);
        	    af0_9= af0_9 * af0_9_LSB;
        	    DLOG(INFO) << "af0_9= " << af0_9 << std::endl;

        	    af1_9= (double)read_navigation_signed(data_jk_bits, af1_9_bit);
        	    af1_9= af1_9 * af1_9_LSB;
        	    DLOG(INFO) << "af1_9= " << af1_9 << std::endl;

        	    E1B_HS_9= (double)read_navigation_unsigned(data_jk_bits, E1B_HS_9_bit);
        	    DLOG(INFO) << "E1B_HS_9= " << E1B_HS_9 << std::endl;

        	    E1B_HS_9= (double)read_navigation_unsigned(data_jk_bits, E1B_HS_9_bit);
        	    DLOG(INFO) << "E1B_HS_9= " << E1B_HS_9 << std::endl;

        	    SVID3_9= (double)read_navigation_unsigned(data_jk_bits,SVID3_9_bit);
        	    DLOG(INFO) << "SVID3_9= " << SVID3_9 << std::endl;


        	    DELTA_A_9= (double)read_navigation_signed(data_jk_bits, DELTA_A_9_bit);
        	    DELTA_A_9= DELTA_A_9 * DELTA_A_9_LSB;
        	    DLOG(INFO) << "DELTA_A_9= " << DELTA_A_9 << std::endl;

        	    e_9= (double)read_navigation_unsigned(data_jk_bits, e_9_bit);
        	    e_9= e_9 * e_9_LSB;
        	    DLOG(INFO) << "e_9= " << e_9 << std::endl;

        	    omega_9= (double)read_navigation_signed(data_jk_bits, omega_9_bit);
        	    omega_9= omega_9 * omega_9_LSB;
        	    DLOG(INFO) << "omega_9= " << omega_9 << std::endl;

        	    delta_i_9= (double)read_navigation_signed(data_jk_bits, delta_i_9_bit);
        	    delta_i_9= delta_i_9 * delta_i_9_LSB;
        	    DLOG(INFO) << "delta_i_9= " << delta_i_9 << std::endl;
        	    flag_almanac_3 = true;
        	    DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
        	    break;

        case 10: /*Word type 10: Almanac for SVID3 (2/2) and GST-GPS conversion parameters*/

        	    IOD_a_10= (double)read_navigation_unsigned(data_jk_bits, IOD_a_10_bit);
        	    DLOG(INFO) << "IOD_a_10= " << IOD_a_10 << std::endl;

        	    Omega0_10= (double)read_navigation_signed(data_jk_bits, Omega0_10_bit);
        	    Omega0_10= Omega0_10 * Omega0_10_LSB;
        	    DLOG(INFO) << "Omega0_10= " << Omega0_10 << std::endl;

        	    Omega_dot_10= (double)read_navigation_signed(data_jk_bits, Omega_dot_10_bit);
        	    Omega_dot_10= Omega_dot_10 * Omega_dot_10_LSB;
        	    DLOG(INFO) << "Omega_dot_10= " << Omega_dot_10 << std::endl;

        	    M0_10= (double)read_navigation_signed(data_jk_bits, M0_10_bit);
        	    M0_10= M0_10 * M0_10_LSB;
        	    DLOG(INFO) << "M0_10= " << M0_10 << std::endl;

        	    af0_10= (double)read_navigation_signed(data_jk_bits, af0_10_bit);
        	    af0_10= af0_10 * af0_10_LSB;
        	    DLOG(INFO) << "af0_10= " << af0_10 << std::endl;

        	    af1_10= (double)read_navigation_signed(data_jk_bits, af1_10_bit);
        	    af1_10= af1_10 * af1_10_LSB;
        	    DLOG(INFO) << "af1_10= " << af1_10 << std::endl;

        	    E5b_HS_10= (double)read_navigation_unsigned(data_jk_bits, E5b_HS_10_bit);
        	    DLOG(INFO) << "E5b_HS_10= " << E5b_HS_10 << std::endl;

        	    E1B_HS_10= (double)read_navigation_unsigned(data_jk_bits, E1B_HS_10_bit);
        	    DLOG(INFO) << "E1B_HS_10= " << E1B_HS_10 << std::endl;

        	    A_0G_10= (double)read_navigation_signed(data_jk_bits, A_0G_10_bit);
        	    A_0G_10= A_0G_10 * A_0G_10_LSB;
        	    DLOG(INFO) << "A_0G_10= " << A_0G_10 << std::endl;

        	    A_1G_10= (double)read_navigation_signed(data_jk_bits, A_1G_10_bit);
        	    A_1G_10= A_1G_10 * A_1G_10_LSB;
        	    DLOG(INFO) << "A_1G_10= " << A_1G_10 << std::endl;

        	    t_0G_10= (double)read_navigation_unsigned(data_jk_bits, t_0G_10_bit);
        	    t_0G_10= t_0G_10 * t_0G_10_LSB;
        	    DLOG(INFO) << "t_0G_10= " << t_0G_10 << std::endl;

        	    WN_0G_10= (double)read_navigation_unsigned(data_jk_bits, WN_0G_10_bit);
        	    DLOG(INFO) << "WN_0G_10= " << WN_0G_10 << std::endl;
        	    flag_almanac_4 = true;
        	    DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
        	    break;

       case 0: /*Word type 0: I/NAV Spare Word*/
        	    Time_0= (double)read_navigation_unsigned(data_jk_bits, Time_0_bit);
        	    DLOG(INFO) << "Time_0= " << Time_0 << std::endl;

         	    WN_0= (double)read_navigation_unsigned(data_jk_bits, WN_0_bit);
         	    DLOG(INFO) << "WN_0= " << WN_0 << std::endl;

         	    TOW_0= (double)read_navigation_unsigned(data_jk_bits, TOW_0_bit);
          	    DLOG(INFO) << "TOW_0= " << TOW_0 << std::endl;
          	  DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;

          	 break;
        }

   return page_number;
}



//void Galileo_Navigation_Message::satellitePosition(double transmitTime) //when this function in used, the input must be the transmitted time (t) in second computed by Galileo_System_Time (above function)
//{
//
//    double tk;  // Time from ephemeris reference epoch
//    //double t;   // Galileo System Time (ICD, paragraph 5.1.2)
//    double a;   // Semi-major axis
//    double n;   // Corrected mean motion
//    double n0;  // Computed mean motion
//    double M;   // Mean anomaly
//    double E;   //Eccentric Anomaly (to be solved by iteration)
//    double E_old;
//    double dE;
//    double nu; //True anomaly
//    double phi; //argument of Latitude
//    double u;   // Correct argument of latitude
//    double r;  // Correct radius
//    double i;
//    double Omega;
//
//    // Find Galileo satellite's position ----------------------------------------------
//
//    // Restore semi-major axis
//    a = A_1*A_1;
//
//    // Computed mean motion
//    n0 = sqrt(GALILEO_GM / (a*a*a));
//
//    // Time from ephemeris reference epoch
//    //tk = check_t(transmitTime - d_Toe); this is tk for GPS; for Galileo it is different
//    //t = WN_5*86400*7 + TOW_5; //WN_5*86400*7 are the second from the origin of the Galileo time
//    tk = transmitTime - t0e_1;
//
//    // Corrected mean motion
//    n = n0 + delta_n_3;
//
//    // Mean anomaly
//    M = M0_1 + n * tk;
//
//    // Reduce mean anomaly to between 0 and 2pi
//    M = fmod((M + 2* GALILEO_PI), (2* GALILEO_PI));
//
//    // Initial guess of eccentric anomaly
//    E = M;
//
//    // --- Iteratively compute eccentric anomaly ----------------------------
//    for (int ii = 1; ii<20; ii++)
//        {
//            E_old   = E;
//            E       = M + e_1 * sin(E);
//            dE      = fmod(E - E_old, 2*GALILEO_PI);
//            if (fabs(dE) < 1e-12)
//                {
//                    //Necessary precision is reached, exit from the loop
//                    break;
//                }
//        }
//
//    // Compute the true anomaly
//
//    double tmp_Y = sqrt(1.0 - e_1 * e_1) * sin(E);
//    double tmp_X = cos(E) - e_1;
//    nu = atan2(tmp_Y, tmp_X);
//
//    // Compute angle phi (argument of Latitude)
//    phi = nu + omega_2;
//
//    // Reduce phi to between 0 and 2*pi rad
//    phi = fmod((phi), (2*GALILEO_PI));
//
//    // Correct argument of latitude
//    u = phi + C_uc_3 * cos(2*phi) +  C_us_3 * sin(2*phi);
//
//    // Correct radius
//    r = a * (1 - e_1*cos(E)) +  C_rc_3 * cos(2*phi) +  C_rs_3 * sin(2*phi);
//
//    // Correct inclination
//    i = i_0_2 + iDot_2 * tk + C_ic_4 * cos(2*phi) + C_is_4 * sin(2*phi);
//
//    // Compute the angle between the ascending node and the Greenwich meridian
//    Omega = OMEGA_0_2 + (OMEGA_dot_3 - GALILEO_OMEGA_EARTH_DOT)*tk - GALILEO_OMEGA_EARTH_DOT * t0e_1;
//
//    // Reduce to between 0 and 2*pi rad
//    Omega = fmod((Omega + 2*GALILEO_PI), (2*GALILEO_PI));
//
//    // --- Compute satellite coordinates in Earth-fixed coordinates
//    galileo_satpos_X = cos(u) * r * cos(Omega) - sin(u) * r * cos(i) * sin(Omega);
//    galileo_satpos_Y = cos(u) * r * sin(Omega) + sin(u) * r * cos(i) * cos(Omega); //***********************NOTE: in GALILEO ICD this expression is not correct because it has minus (- sin(u) * r * cos(i) * cos(Omega)) instead of plus
//    galileo_satpos_Z = sin(u) * r * sin(i);
//
//    std::cout << "Galileo satellite position X [m]: " << galileo_satpos_X << std::endl;
//    std::cout << "Galileo satellite position Y [m]: " << galileo_satpos_Y << std::endl;
//    std::cout << "Galileo satellite position Z [m]: " << galileo_satpos_Z << std::endl;
//    double vector_position = sqrt(galileo_satpos_X*galileo_satpos_X + galileo_satpos_Y*galileo_satpos_Y + galileo_satpos_Z*galileo_satpos_Z);
//    std::cout << "Vector Earth Center-Satellite [Km]: " << vector_position/1000 << std::endl;
//
//    // Satellite's velocity. Can be useful for Vector Tracking loops
//    double Omega_dot = OMEGA_dot_3 - GALILEO_OMEGA_EARTH_DOT;
//    galileo_satvel_X = - Omega_dot * (cos(u) * r + sin(u) * r * cos(i)) + galileo_satpos_X * cos(Omega) - galileo_satpos_Y * cos(i) * sin(Omega);
//    galileo_satvel_Y = Omega_dot * (cos(u) * r * cos(Omega) - sin(u) * r * cos(i) * sin(Omega)) + galileo_satpos_X * sin(Omega) + galileo_satpos_Y * cos(i) * cos(Omega);
//    galileo_satvel_Z = galileo_satpos_Y * sin(i);
//
//}
//
//
//double Galileo_Navigation_Message::Galileo_System_Time(double WN, double TOW){
//	/* GALIELO SYSTEM TIME, ICD 5.1.2
//	 * input parameter:
//	 * WN: The Week Number is an integer counter that gives the sequential week number
//	   from the origin of the Galileo time. It covers 4096 weeks (about 78 years).
//	   Then the counter is reset to zero to cover additional period modulo 4096
//
//	   TOW: The Time of Week is defined as the number of seconds that have occurred since
//	   the transition from the previous week. The TOW covers an entire week from 0 to
//	   604799 seconds and is reset to zero at the end of each week
//
//	   WN and TOW are received in page 5
//
//	   output:
//	   t: it is the transmitted time in Galileo System Time (expressed in seconds)
//
//	   The GST start epoch shall be 00:00 UT on Sunday 22nd August 1999 (midnight between 21st and 22nd August).
//	   At the start epoch, GST shall be ahead of UTC by thirteen (13)
//	   leap seconds. Since the next leap second was inserted at 01.01.2006, this implies that
//       as of 01.01.2006 GST is ahead of UTC by fourteen (14) leap seconds.
//
//       The epoch denoted in the navigation messages by TOW and WN
//	   will be measured relative to the leading edge of the first chip of the
//	   first code sequence of the first page symbol. The transmission timing of the navigation
//	   message provided through the TOW is synchronised to each satellite’s version of Galileo System Time (GST).
//	 *
//	 */
//	double t=0;
//	double sec_in_day = 86400;
//	double day_in_week = 7;
//	t = WN * sec_in_day * day_in_week + TOW; // second from the origin of the Galileo time
//
//	return t;
//
//}
//
//
//
//double Galileo_Navigation_Message::sv_clock_drift(double transmitTime){
//	/* Satellite Time Correction Algorithm, ICD 5.1.4
//	 *
//	 */
//    double dt;
//    dt = transmitTime - t0c_4;
//    Galileo_satClkDrift = af0_4 + af1_4*dt + (af2_4 * dt)*(af2_4 * dt) + Galileo_dtr;
//    return Galileo_satClkDrift;
//}
//
//// compute the relativistic correction term
//double Galileo_Navigation_Message::sv_clock_relativistic_term(double transmitTime) //Satellite Time Correction Algorithm, ICD 5.1.4
//{
//    double tk;
//    double a;
//    double n;
//    double n0;
//    double E;
//    double E_old;
//    double dE;
//    double M;
//
//      // Restore semi-major axis
//      a = A_1*A_1;
//
//      n0 = sqrt(GALILEO_GM / (a*a*a));
//
//      // Time from ephemeris reference epoch
//      //tk = check_t(transmitTime - d_Toe); this is tk for GPS; for Galileo it is different
//      //t = WN_5*86400*7 + TOW_5; //WN_5*86400*7 are the second from the origin of the Galileo time
//      tk = transmitTime - t0e_1;
//
//      // Corrected mean motion
//      n = n0 + delta_n_3;
//
//      // Mean anomaly
//      M = M0_1 + n * tk;
//
//      // Reduce mean anomaly to between 0 and 2pi
//      M = fmod((M + 2* GALILEO_PI), (2* GALILEO_PI));
//
//      // Initial guess of eccentric anomaly
//      E = M;
//
//      // --- Iteratively compute eccentric anomaly ----------------------------
//      for (int ii = 1; ii<20; ii++)
//          {
//              E_old   = E;
//              E       = M + e_1 * sin(E);
//              dE      = fmod(E - E_old, 2*GALILEO_PI);
//              if (fabs(dE) < 1e-12)
//                  {
//                      //Necessary precision is reached, exit from the loop
//                       break;
//                   }
//           }
//
//
//    // Compute relativistic correction term
//    Galileo_dtr = GALILEO_F * e_1* A_1 * sin(E);
//    return Galileo_dtr;
//}

//double Galileo_Navigation_Message::GST_to_UTC_time(double t_e, int WN) //t_e is GST (WN+TOW) in second
//{
//	double t_Utc;
//		double t_Utc_daytime;
//		double Delta_t_Utc =  Delta_tLS_6 + A0_6 + A1_6 * (t_e - t0t_6 + 604800 * (double)(WN - WNot_6));
//
//		// Determine if the effectivity time of the leap second event is in the past
//		int  weeksToLeapSecondEvent = WN_LSF_6 - WN;
//
//		if ((weeksToLeapSecondEvent) >= 0) // is not in the past
//		{
//			//Detect if the effectivity time and user's time is within six hours  = 6 * 60 *60 = 21600 s
//			int secondOfLeapSecondEvent = DN_6 * 24 * 60 * 60;
//			if (weeksToLeapSecondEvent > 0)
//			{
//				t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400);
//			}
//			else //we are in the same week than the leap second event
//			{
//				if  (abs(t_e - secondOfLeapSecondEvent) > 21600)
//				{
//					/* 5.1.7a
//					 * Whenever the leap second adjusted time indicated by the WN_LSF and the DN values
//					 * is not in the past (relative to the user's present time), and the user's
//					 * present time does not fall in the time span which starts at six hours prior
//					 * to the effective time and ends at six hours after the effective time,
//					 * the GST/Utc relationship is given by
//					 */
//					t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400);
//				}
//				else
//				{
//					/* 5.1.7b
//					 * Whenever the user's current time falls within the time span of six hours
//					 * prior to the leap second adjustment to six hours after the adjustment time, ,
//					 * the effective time is computed according to the following equations:
//					 */
//
//					int W = fmod(t_e - Delta_t_Utc - 43200, 86400) + 43200;
//					t_Utc_daytime = fmod(W, 86400 + Delta_tLSF_6 - Delta_tLS_6);
//					//implement something to handle a leap second event!
//				}
//				if ( (t_e - secondOfLeapSecondEvent) > 21600)
//				{
//					Delta_t_Utc = Delta_tLSF_6 + A0_6 + A1_6 * (t_e - t0t_6 + 604800*(double)(WN - WNot_6));
//					t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400);
//				}
//			}
//		}
//		else // the effectivity time is in the past
//		{
//			/* 5.1.7c
//			 * Whenever the leap second adjustment time, as indicated by the WN_LSF and DN values,
//			 * is in the past (relative to the user’s current time) and the user’s present time does not
//			 * fall in the time span which starts six hours prior to the leap second adjustment time and
//			 * ends six hours after the adjustment time, the effective time is computed according to
//			 * the following equation:
//			 */
//			Delta_t_Utc = Delta_tLSF_6 + A0_6 + A1_6 * (t_e - t0t_6 + 604800 * (double)(WN - WNot_6));
//			t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400);
//		}
//
//		double secondsOfWeekBeforeToday = 43200 * floor(t_e / 43200);
//		t_Utc = secondsOfWeekBeforeToday + t_Utc_daytime;
//		return t_Utc;
//
//}
//
//
//