/*!
 * \file Galileo_Navigation_Message.cc
  * \brief  Implementation of a Galileo I/NAV Data message
 *         as described in Galileo OS SIS ICD Issue 1.1 (Sept. 2010)
 * \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::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
                        }
                    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)
{
    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;

    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;
        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;
        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;
        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;
        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;
        flag_ephemeris_1 = true;
        DLOG(INFO) << "flag_tow_set" << flag_TOW_set;
        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;
        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 ;
        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 ;
        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;
        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;
        flag_ephemeris_2 = true;
        DLOG(INFO) << "flag_tow_set" << flag_TOW_set;
        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 ;
        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 ;
        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 ;
        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;
        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;
        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;
        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;
        SISA_3 = (double)read_navigation_unsigned(data_jk_bits, SISA_3_bit);
        DLOG(INFO) << "SISA_3= " << SISA_3;
        flag_ephemeris_3 = true;
        DLOG(INFO) << "flag_tow_set" << flag_TOW_set;
        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 ;
        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 ;
        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;
        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;
        /*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;
        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;
        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;
        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;
        spare_4 = (double)read_navigation_unsigned(data_jk_bits, spare_4_bit);
        DLOG(INFO) << "spare_4 = " << spare_4;
        flag_ephemeris_4 = true;
        DLOG(INFO) << "flag_tow_set" << flag_TOW_set;
        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;
        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;
        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;
        /*Ionospheric disturbance flag*/
        Region1_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region1_5_bit);
        DLOG(INFO) << "Region1_flag_5= " << Region1_flag_5;
        Region2_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region2_5_bit);
        DLOG(INFO) << "Region2_flag_5= " << Region2_flag_5;
        Region3_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region3_5_bit);
        DLOG(INFO) << "Region3_flag_5= " << Region3_flag_5;
        Region4_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region4_5_bit);
        DLOG(INFO) << "Region4_flag_5= " << Region4_flag_5;
        Region5_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region5_5_bit);
        DLOG(INFO) << "Region5_flag_5= " << Region5_flag_5;
        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;
        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;
        E5b_HS_5 = (double)read_navigation_unsigned(data_jk_bits, E5b_HS_5_bit);
        DLOG(INFO) << "E5b_HS_5= " << E5b_HS_5;
        E1B_HS_5 = (double)read_navigation_unsigned(data_jk_bits, E1B_HS_5_bit);
        DLOG(INFO) << "E1B_HS_5= " << E1B_HS_5;
        E5b_DVS_5 = (double)read_navigation_unsigned(data_jk_bits, E5b_DVS_5_bit);
        DLOG(INFO) << "E5b_DVS_5= " << E5b_DVS_5;
        E1B_DVS_5 = (double)read_navigation_unsigned(data_jk_bits, E1B_DVS_5_bit);
        DLOG(INFO) << "E1B_DVS_5= " << E1B_DVS_5;
        /*GST*/
        WN_5 = (double)read_navigation_unsigned(data_jk_bits, WN_5_bit);
        DLOG(INFO) << "WN_5= " << WN_5;
        TOW_5 = (double)read_navigation_unsigned(data_jk_bits, TOW_5_bit);
        DLOG(INFO) << "TOW_5= " << TOW_5;
        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;
        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;
        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;
        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;
        Delta_tLS_6 = (double)read_navigation_signed(data_jk_bits, Delta_tLS_6_bit);
        DLOG(INFO) << "Delta_tLS_6= " << Delta_tLS_6;
        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;
        WNot_6 = (double)read_navigation_unsigned(data_jk_bits, WNot_6_bit);
        DLOG(INFO) << "WNot_6= " << WNot_6;
        WN_LSF_6 = (double)read_navigation_unsigned(data_jk_bits, WN_LSF_6_bit);
        DLOG(INFO) << "WN_LSF_6= " << WN_LSF_6;
        DN_6 = (double)read_navigation_unsigned(data_jk_bits, DN_6_bit);
        DLOG(INFO) << "DN_6= " << DN_6;
        Delta_tLSF_6 = (double)read_navigation_signed(data_jk_bits, Delta_tLSF_6_bit);
        DLOG(INFO) << "Delta_tLSF_6= " << Delta_tLSF_6;
        TOW_6 = (double)read_navigation_unsigned(data_jk_bits, TOW_6_bit);
        DLOG(INFO) << "TOW_6= " << TOW_6;
        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;
        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;
        WN_a_7 = (double)read_navigation_unsigned(data_jk_bits, WN_a_7_bit);
        DLOG(INFO) << "WN_a_7= " << WN_a_7;
        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;
        SVID1_7 = (double)read_navigation_unsigned(data_jk_bits, SVID1_7_bit);
        DLOG(INFO) << "SVID1_7= " << SVID1_7;
        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;
        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;
        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;
        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;
        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;
        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;
        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;
        flag_almanac_1 = true;
        DLOG(INFO) << "flag_tow_set"<< flag_TOW_set;
        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;
        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;
        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;
        E5b_HS_8 = (double)read_navigation_unsigned(data_jk_bits, E5b_HS_8_bit);
        DLOG(INFO) << "E5b_HS_8= " << E5b_HS_8;
        E1B_HS_8 = (double)read_navigation_unsigned(data_jk_bits, E1B_HS_8_bit);
        DLOG(INFO) << "E1B_HS_8= " << E1B_HS_8;
        SVID2_8 = (double)read_navigation_unsigned(data_jk_bits, SVID2_8_bit);
        DLOG(INFO) << "SVID2_8= " << SVID2_8;
        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;
        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;
        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;
        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;
        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;
        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;
        flag_almanac_2 = true;
        DLOG(INFO) << "flag_tow_set" << flag_TOW_set;
        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;
        WN_a_9 = (double)read_navigation_unsigned(data_jk_bits, WN_a_9_bit);
        DLOG(INFO) << "WN_a_9= " << WN_a_9;
        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;
        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;
        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;
        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;
        E1B_HS_9 = (double)read_navigation_unsigned(data_jk_bits, E1B_HS_9_bit);
        DLOG(INFO) << "E1B_HS_9= " << E1B_HS_9;
        E1B_HS_9 = (double)read_navigation_unsigned(data_jk_bits, E1B_HS_9_bit);
        DLOG(INFO) << "E1B_HS_9= " << E1B_HS_9;
        SVID3_9 = (double)read_navigation_unsigned(data_jk_bits,SVID3_9_bit);
        DLOG(INFO) << "SVID3_9= " << SVID3_9;
        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;
        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;
        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;
        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;
        flag_almanac_3 = true;
        DLOG(INFO) << "flag_tow_set" << flag_TOW_set;
        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;
        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;
        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 ;
        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;
        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;
        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;
        E5b_HS_10 = (double)read_navigation_unsigned(data_jk_bits, E5b_HS_10_bit);
        DLOG(INFO) << "E5b_HS_10= " << E5b_HS_10;
        E1B_HS_10 = (double)read_navigation_unsigned(data_jk_bits, E1B_HS_10_bit);
        DLOG(INFO) << "E1B_HS_10= " << E1B_HS_10;
        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;
        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;
        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;
        WN_0G_10 = (double)read_navigation_unsigned(data_jk_bits, WN_0G_10_bit);
        DLOG(INFO) << "WN_0G_10= " << WN_0G_10;
        flag_almanac_4 = true;
        DLOG(INFO) << "flag_tow_set" << flag_TOW_set;
        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;
        WN_0 = (double)read_navigation_unsigned(data_jk_bits, WN_0_bit);
        DLOG(INFO) << "WN_0= " << WN_0;
        TOW_0 = (double)read_navigation_unsigned(data_jk_bits, TOW_0_bit);
        DLOG(INFO) << "TOW_0= " << TOW_0;
        DLOG(INFO) << "flag_tow_set" << flag_TOW_set;
        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;
//
//}
//
//
//