/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 *       copyright notice, this list of conditions and the following
 *       disclaimer in the documentation and/or other materials provided
 *       with the distribution.
 *     * Neither the name of The Linux Foundation nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#define LOG_TAG "LocSvc_LocationClientApi"

#include <loc_cfg.h>
#include <cmath>
#include <LocationDataTypes.h>
#include <LocationClientApi.h>
#include <LocationClientApiImpl.h>
#include <LocationApiMsg.h>
#include <log_util.h>
#include <loc_log.h>
#include <gps_extended_c.h>

using std::string;

namespace location_client {

bool Geofence::operator==(Geofence& other) {
    return mGeofenceImpl != nullptr && other.mGeofenceImpl != nullptr &&
            mGeofenceImpl == other.mGeofenceImpl;
}

/******************************************************************************
LocationClientApi
******************************************************************************/
LocationClientApi::LocationClientApi(CapabilitiesCb capabitiescb) :
        mApiImpl(new LocationClientApiImpl(capabitiescb)) {
}

LocationClientApi::~LocationClientApi() {
    if (mApiImpl) {
        // two steps processes due to asynchronous message processing
        mApiImpl->destroy();
        // deletion of mApiImpl will be done after messages in the queue are processed
    }
}

bool LocationClientApi::startPositionSession(
        uint32_t intervalInMs,
        uint32_t distanceInMeters,
        LocationCb locationCallback,
        ResponseCb responseCallback) {

    loc_boot_kpi_marker("L - LCA ST-SPS %s %d",
            program_invocation_short_name, intervalInMs);
    //Input parameter check
    if (!locationCallback) {
        LOC_LOGe ("NULL locationCallback");
        return false;
    }

    if (!mApiImpl) {
        LOC_LOGe ("NULL mApiImpl");
        return false;
    }

    // callback functions
    ClientCallbacks cbs = {0};
    cbs.responsecb = responseCallback;
    cbs.locationcb = locationCallback;
    mApiImpl->updateCallbackFunctions(cbs);

    // callback masks
    LocationCallbacks callbacksOption = {0};
    callbacksOption.responseCb = [](::LocationError err, uint32_t id) {};
    // only register for trackingCb if distance is not 0
    if (distanceInMeters != 0) {
        callbacksOption.trackingCb = [](::Location n) {};
    } else {
        // for time based, register gnss location cb
        callbacksOption.gnssLocationInfoCb = [](::GnssLocationInfoNotification n) {};
    }
    mApiImpl->updateCallbacks(callbacksOption);

    // options
    LocationOptions locationOption;
    TrackingOptions trackingOption;
    locationOption.size = sizeof(locationOption);
    locationOption.minInterval = intervalInMs;
    locationOption.minDistance = distanceInMeters;
    trackingOption.setLocationOptions(locationOption);
    mApiImpl->startTracking(trackingOption);
    return true;
}

bool LocationClientApi::startPositionSession(
        uint32_t intervalInMs,
        const GnssReportCbs& gnssReportCallbacks,
        ResponseCb responseCallback) {

    loc_boot_kpi_marker("L - LCA EX-SPS %s %d",
            program_invocation_short_name, intervalInMs);

    if (!mApiImpl) {
        LOC_LOGe ("NULL mApiImpl");
        return false;
    }

    // callback functions
    ClientCallbacks cbs = {0};
    cbs.responsecb = responseCallback;
    cbs.gnssreportcbs = gnssReportCallbacks;
    mApiImpl->updateCallbackFunctions(cbs, REPORT_CB_GNSS_INFO);

    // callback masks
    LocationCallbacks callbacksOption = {0};
    callbacksOption.responseCb = [](::LocationError err, uint32_t id) {};
    if (gnssReportCallbacks.gnssLocationCallback) {
        callbacksOption.gnssLocationInfoCb = [](::GnssLocationInfoNotification n) {};
    }
    if (gnssReportCallbacks.gnssSvCallback) {
        callbacksOption.gnssSvCb = [](::GnssSvNotification n) {};
    }
    if (gnssReportCallbacks.gnssNmeaCallback) {
        callbacksOption.gnssNmeaCb = [](::GnssNmeaNotification n) {};
    }
    if (gnssReportCallbacks.gnssDataCallback) {
       callbacksOption.gnssDataCb = [] (::GnssDataNotification n) {};
    }
    if (gnssReportCallbacks.gnssMeasurementsCallback) {
        callbacksOption.gnssMeasurementsCb = [](::GnssMeasurementsNotification n) {};
    }
    mApiImpl->updateCallbacks(callbacksOption);

    // options
    LocationOptions locationOption;
    TrackingOptions trackingOption;
    locationOption.size = sizeof(locationOption);
    locationOption.minInterval = intervalInMs;
    locationOption.minDistance = 0;
    trackingOption.setLocationOptions(locationOption);
    mApiImpl->startTracking(trackingOption);
    return true;
}

bool LocationClientApi::startPositionSession(
        uint32_t intervalInMs,
        LocReqEngineTypeMask locEngReqMask,
        const EngineReportCbs& engReportCallbacks,
        ResponseCb responseCallback) {

    loc_boot_kpi_marker("L - LCA Fused-SPS %s %d",
            program_invocation_short_name, intervalInMs);
    if (!mApiImpl) {
        LOC_LOGe ("NULL mApiImpl");
        return false;
    }

    // callback functions
    ClientCallbacks cbs = {0};
    cbs.responsecb = responseCallback;
    cbs.engreportcbs = engReportCallbacks;
    mApiImpl->updateCallbackFunctions(cbs, REPORT_CB_ENGINE_INFO);

    // callback masks
    LocationCallbacks callbacksOption = {0};
    callbacksOption.responseCb = [](::LocationError err, uint32_t id) {};

    if (engReportCallbacks.engLocationsCallback) {
        callbacksOption.engineLocationsInfoCb =
                [](uint32_t count, ::GnssLocationInfoNotification* locArr) {};
    }
    if (engReportCallbacks.gnssSvCallback) {
        callbacksOption.gnssSvCb = [](::GnssSvNotification n) {};
    }
    if (engReportCallbacks.gnssNmeaCallback) {
        callbacksOption.gnssNmeaCb = [](::GnssNmeaNotification n) {};
    }
    if (engReportCallbacks.gnssDataCallback) {
       callbacksOption.gnssDataCb = [] (::GnssDataNotification n) {};
    }
    if (engReportCallbacks.gnssMeasurementsCallback) {
        callbacksOption.gnssMeasurementsCb = [](::GnssMeasurementsNotification n) {};
    }
    mApiImpl->updateCallbacks(callbacksOption);

    // options
    LocationOptions locationOption;
    TrackingOptions trackingOption;
    locationOption.size = sizeof(locationOption);
    locationOption.minInterval = intervalInMs;
    locationOption.minDistance = 0;
    locationOption.locReqEngTypeMask =(::LocReqEngineTypeMask)locEngReqMask;
    trackingOption.setLocationOptions(locationOption);

    mApiImpl->startTracking(trackingOption);
    return true;
}

void LocationClientApi::stopPositionSession() {
    if (mApiImpl) {
        mApiImpl->stopTracking(0);
    }
}

bool LocationClientApi::startTripBatchingSession(uint32_t minInterval, uint32_t tripDistance,
        BatchingCb batchingCallback, ResponseCb responseCallback) {
    //Input parameter check
    if (!batchingCallback) {
        LOC_LOGe ("NULL batchingCallback");
        return false;
    }

    if (!mApiImpl) {
        LOC_LOGe ("NULL mApiImpl");
        return false;
    }
    // callback functions
    ClientCallbacks cbs = {0};
    cbs.responsecb = responseCallback;
    cbs.batchingcb = batchingCallback;
    mApiImpl->updateCallbackFunctions(cbs);

    // callback masks
    LocationCallbacks callbacksOption = {0};
    callbacksOption.responseCb = [](::LocationError err, uint32_t id) {};
    callbacksOption.batchingCb = [](size_t count, ::Location* location,
            BatchingOptions batchingOptions) {};
    callbacksOption.batchingStatusCb = [](BatchingStatusInfo batchingStatus,
            std::list<uint32_t>& listOfcompletedTrips) {};
    mApiImpl->updateCallbacks(callbacksOption);

    LocationOptions locOption = {};
    locOption.size = sizeof(locOption);
    locOption.minInterval = minInterval;
    locOption.minDistance = tripDistance;
    locOption.mode = GNSS_SUPL_MODE_STANDALONE;

    BatchingOptions     batchOption = {};
    batchOption.size = sizeof(batchOption);
    batchOption.batchingMode = BATCHING_MODE_TRIP;
    batchOption.setLocationOptions(locOption);
    mApiImpl->startBatching(batchOption);
    return true;
}

bool LocationClientApi::startRoutineBatchingSession(uint32_t minInterval, uint32_t minDistance,
        BatchingCb batchingCallback, ResponseCb responseCallback) {
    //Input parameter check
    if (!batchingCallback) {
        LOC_LOGe ("NULL batchingCallback");
        return false;
    }

    if (!mApiImpl) {
        LOC_LOGe ("NULL mApiImpl");
        return false;
    }
    // callback functions
    ClientCallbacks cbs = {0};
    cbs.responsecb = responseCallback;
    cbs.batchingcb = batchingCallback;
    mApiImpl->updateCallbackFunctions(cbs);

    // callback masks
    LocationCallbacks callbacksOption = {0};
    callbacksOption.responseCb = [](::LocationError err, uint32_t id) {};
    callbacksOption.batchingCb = [](size_t count, ::Location* location,
            BatchingOptions batchingOptions) {};
    mApiImpl->updateCallbacks(callbacksOption);

    LocationOptions locOption = {};
    locOption.size = sizeof(locOption);
    locOption.minInterval = minInterval;
    locOption.minDistance = minDistance;
    locOption.mode = GNSS_SUPL_MODE_STANDALONE;

    BatchingOptions     batchOption = {};
    batchOption.size = sizeof(batchOption);
    batchOption.batchingMode = BATCHING_MODE_ROUTINE;
    batchOption.setLocationOptions(locOption);
    mApiImpl->startBatching(batchOption);
    return true;
}

void LocationClientApi::stopBatchingSession() {
    if (mApiImpl) {
        mApiImpl->stopBatching(0);
    }
}

void LocationClientApi::addGeofences(std::vector<Geofence>& geofences,
        GeofenceBreachCb gfBreachCb,
        CollectiveResponseCb responseCallback) {
    //Input parameter check
    if (!gfBreachCb) {
        LOC_LOGe ("NULL GeofenceBreachCb");
        return;
    }
    if (!mApiImpl) {
        LOC_LOGe ("NULL mApiImpl");
        return;
    }
    // callback functions
    ClientCallbacks cbs = {0};
    cbs.collectivecb = responseCallback;
    cbs.gfbreachcb = gfBreachCb;
    mApiImpl->updateCallbackFunctions(cbs);

    // callback masks
    LocationCallbacks callbacksOption = {0};
    callbacksOption.responseCb = [](LocationError err, uint32_t id) {};
    callbacksOption.collectiveResponseCb = [](size_t, LocationError*, uint32_t*) {};
    callbacksOption.geofenceBreachCb = [](GeofenceBreachNotification geofenceBreachNotification)
            {};
    mApiImpl->updateCallbacks(callbacksOption);
    size_t count = geofences.size();
    mApiImpl->mLastAddedClientIds.clear();
    if (count > 0) {
        GeofenceOption* gfOptions = (GeofenceOption*)malloc(sizeof(GeofenceOption) * count);
        GeofenceInfo* gfInfos = (GeofenceInfo*)malloc(sizeof(GeofenceInfo) * count);

        for (int i=0; i<count; ++i) {
            if (geofences[i].mGeofenceImpl) {
                continue;
            }
            gfOptions[i].breachTypeMask = geofences[i].getBreachType();
            gfOptions[i].responsiveness = geofences[i].getResponsiveness();
            gfOptions[i].dwellTime = geofences[i].getDwellTime();
            gfOptions[i].size = sizeof(gfOptions[i]);
            gfInfos[i].latitude = geofences[i].getLatitude();
            gfInfos[i].longitude = geofences[i].getLongitude();
            gfInfos[i].radius = geofences[i].getRadius();
            gfInfos[i].size = sizeof(gfInfos[i]);
            std::shared_ptr<GeofenceImpl> gfImpl(new GeofenceImpl(&geofences[i]));
            gfImpl->bindGeofence(&geofences[i]);
            mApiImpl->mLastAddedClientIds.push_back(gfImpl->getClientId());
            LOC_LOGd("Geofence LastAddedClientId: %d", gfImpl->getClientId());
            mApiImpl->addGeofenceMap(mApiImpl->mLastAddedClientIds[i], geofences[i]);
        }

        mApiImpl->addGeofences(geofences.size(), reinterpret_cast<GeofenceOption*>(gfOptions),
                reinterpret_cast<GeofenceInfo*>(gfInfos));
    }
}
void LocationClientApi::removeGeofences(std::vector<Geofence>& geofences) {
    if (!mApiImpl) {
        LOC_LOGe ("NULL mApiImpl");
        return;
    }
    size_t count = geofences.size();
    if (count > 0) {
        uint32_t* gfIds = (uint32_t*)malloc(sizeof(uint32_t) * count);
        for (int i=0; i<count; ++i) {
            if (!geofences[i].mGeofenceImpl) {
                LOC_LOGe ("Geofence not added yet");
                free(gfIds);
                return;
            }
            gfIds[i] = geofences[i].mGeofenceImpl->getClientId();
            LOC_LOGd("removeGeofences id : %d", gfIds[i]);
        }
        if (!mApiImpl->checkGeofenceMap(geofences.size(), gfIds)) {
            LOC_LOGe ("Wrong geofence IDs");
            free(gfIds);
            return;
        }
        mApiImpl->removeGeofences(count, gfIds);
    }
}
void LocationClientApi::modifyGeofences(std::vector<Geofence>& geofences) {
    if (!mApiImpl) {
        LOC_LOGe ("NULL mApiImpl");
        return;
    }
    size_t count = geofences.size();
    if (count > 0) {
        GeofenceOption* gfOptions = (GeofenceOption*)malloc(sizeof(GeofenceOption) * count);
        uint32_t* gfIds = (uint32_t*)malloc(sizeof(uint32_t) * count);
        for (int i=0; i<count; ++i) {
            gfOptions[i].breachTypeMask = geofences[i].getBreachType();
            gfOptions[i].responsiveness = geofences[i].getResponsiveness();
            gfOptions[i].dwellTime = geofences[i].getDwellTime();
            gfOptions[i].size = sizeof(gfOptions[i]);
            if (!geofences[i].mGeofenceImpl) {
                LOC_LOGe ("Geofence not added yet");
                free(gfIds);
                free(gfOptions);
                return;
            }
            gfIds[i] = geofences[i].mGeofenceImpl->getClientId();
            LOC_LOGd("modifyGeofences id : %d", gfIds[i]);
        }
        if (!mApiImpl->checkGeofenceMap(geofences.size(), gfIds)) {
            LOC_LOGe ("Wrong geofence IDs");
            free(gfIds);
            free(gfOptions);
            return;
        }
        mApiImpl->modifyGeofences(geofences.size(), const_cast<uint32_t*>(gfIds),
                reinterpret_cast<GeofenceOption*>(gfOptions));
    }
}

void LocationClientApi::pauseGeofences(std::vector<Geofence>& geofences) {
    if (!mApiImpl) {
        LOC_LOGe ("NULL mApiImpl");
        return;
    }
    size_t count = geofences.size();
    if (count > 0) {
        uint32_t* gfIds = (uint32_t*)malloc(sizeof(uint32_t) * count);
        for (int i=0; i<count; ++i) {
            if (!geofences[i].mGeofenceImpl) {
                LOC_LOGe ("Geofence not added yet");
                free(gfIds);
                return;
            }
            gfIds[i] = geofences[i].mGeofenceImpl->getClientId();
            LOC_LOGd("pauseGeofences id : %d", gfIds[i]);
        }
        if (!mApiImpl->checkGeofenceMap(geofences.size(), gfIds)) {
            LOC_LOGe ("Wrong geofence IDs");
            free(gfIds);
            return;
        }
        mApiImpl->pauseGeofences(count, gfIds);
    }
}

void LocationClientApi::resumeGeofences(std::vector<Geofence>& geofences) {
    if (!mApiImpl) {
        LOC_LOGe ("NULL mApiImpl");
        return;
    }
    size_t count = geofences.size();
    if (count > 0) {
        uint32_t* gfIds = (uint32_t*)malloc(sizeof(uint32_t) * count);
        for (int i=0; i<count; ++i) {
            if (!geofences[i].mGeofenceImpl) {
                LOC_LOGe ("Geofence not added yet");
                free(gfIds);
                return;
            }
            gfIds[i] = geofences[i].mGeofenceImpl->getClientId();
            LOC_LOGd("resumeGeofences id : %d", gfIds[i]);
        }
        if (!mApiImpl->checkGeofenceMap(geofences.size(), gfIds)) {
            LOC_LOGe ("Wrong geofence IDs");
            free(gfIds);
            return;
        }
        mApiImpl->resumeGeofences(count, gfIds);
    }
}

void LocationClientApi::updateNetworkAvailability(bool available) {
    if (mApiImpl) {
        mApiImpl->updateNetworkAvailability(available);
    }
}

void LocationClientApi::getGnssEnergyConsumed(
        GnssEnergyConsumedCb gnssEnergyConsumedCallback,
        ResponseCb responseCallback) {

    if (!gnssEnergyConsumedCallback) {
        if (responseCallback) {
            responseCallback(LOCATION_RESPONSE_PARAM_INVALID);
        }
    } else if (mApiImpl) {
        mApiImpl->getGnssEnergyConsumed(gnssEnergyConsumedCallback,
                                        responseCallback);
    } else {
        LOC_LOGe ("NULL mApiImpl");
    }
}

void LocationClientApi::updateLocationSystemInfoListener(
    LocationSystemInfoCb locSystemInfoCallback,
    ResponseCb responseCallback) {

    if (mApiImpl) {
        mApiImpl->updateLocationSystemInfoListener(
            locSystemInfoCallback, responseCallback);
    } else {
        LOC_LOGe ("NULL mApiImpl");
    }
}

uint16_t LocationClientApi::getYearOfHw() {
    if (mApiImpl) {
        return mApiImpl->getYearOfHw();
    } else {
        LOC_LOGe ("NULL mApiImpl");
        return 0;
    }
}

void LocationClientApi::getSingleTerrestrialPosition(
        uint32_t timeoutMsec, TerrestrialTechnologyMask techMask,
        float horQoS, LocationCb terrestrialPositionCallback,
        ResponseCb responseCallback) {

    LOC_LOGd("timeout msec = %u, horQoS = %f,"
             "techMask = 0x%x", timeoutMsec, horQoS, techMask);

    if ((timeoutMsec == 0) || (techMask != TERRESTRIAL_TECH_GTP_WWAN) ||
        (horQoS != 0.0)) {
        LOC_LOGe("invalid parameter: timeout %d, tech mask 0x%x, horQoS %f",
                 timeoutMsec, techMask, horQoS);
        if (responseCallback) {
            responseCallback(LOCATION_RESPONSE_PARAM_INVALID);
        }
    } else if (mApiImpl) {
        mApiImpl->getSingleTerrestrialPos(timeoutMsec, ::TERRESTRIAL_TECH_GTP_WWAN, horQoS,
                                          terrestrialPositionCallback, responseCallback);
    } else {
        LOC_LOGe ("NULL mApiImpl");
    }
}

// ============ below Section implements toString() methods of data structs ==============
static string maskToVals(uint64_t mask, int64_t baseNum) {
    string out;
    while (mask > 0) {
        baseNum += log2(loc_get_least_bit(mask));
        out += baseNum + " ";
    }
    return out;
}

// LocationCapabilitiesMask
DECLARE_TBL(LocationCapabilitiesMask) = {
    {LOCATION_CAPS_TIME_BASED_TRACKING_BIT, "TIME_BASED_TRACKING"},
    {LOCATION_CAPS_TIME_BASED_BATCHING_BIT, "TIME_BASED_BATCHING"},
    {LOCATION_CAPS_DISTANCE_BASED_TRACKING_BIT, "DIST_BASED_TRACKING"},
    {LOCATION_CAPS_DISTANCE_BASED_BATCHING_BIT, "DIST_BASED_BATCHING"},
    {LOCATION_CAPS_GEOFENCE_BIT, "GEOFENCE"},
    {LOCATION_CAPS_OUTDOOR_TRIP_BATCHING_BIT, "OUTDOOR_TRIP_BATCHING"},
    {LOCATION_CAPS_GNSS_MEASUREMENTS_BIT, "GNSS_MEASUREMENTS"},
    {LOCATION_CAPS_CONSTELLATION_ENABLEMENT_BIT, "CONSTELLATION_ENABLE"},
    {LOCATION_CAPS_CARRIER_PHASE_BIT, "CARRIER_PHASE"},
    {LOCATION_CAPS_SV_POLYNOMIAL_BIT, "SV_POLY"},
    {LOCATION_CAPS_QWES_GNSS_SINGLE_FREQUENCY, "GNSS_SINGLE_FREQ"},
    {LOCATION_CAPS_QWES_GNSS_MULTI_FREQUENCY, "GNSS_MULTI_FREQ"},
    {LOCATION_CAPS_QWES_VPE, "VPE"},
    {LOCATION_CAPS_QWES_CV2X_LOCATION_BASIC, "CV2X_LOC_BASIC"},
    {LOCATION_CAPS_QWES_CV2X_LOCATION_PREMIUM, "CV2X_LOC_PREMIUM"},
    {LOCATION_CAPS_QWES_PPE, "PPE"},
    {LOCATION_CAPS_QWES_QDR2, "QDR2"},
    {LOCATION_CAPS_QWES_QDR3, "QDR3"}
};
// GnssSvOptionsMask
DECLARE_TBL(GnssSvOptionsMask) = {
    {GNSS_SV_OPTIONS_HAS_EPHEMER_BIT, "EPH"},
    {GNSS_SV_OPTIONS_HAS_ALMANAC_BIT, "ALM"},
    {GNSS_SV_OPTIONS_USED_IN_FIX_BIT, "USED_IN_FIX"},
    {GNSS_SV_OPTIONS_HAS_CARRIER_FREQUENCY_BIT, "CARRIER_FREQ"},
    {GNSS_SV_OPTIONS_HAS_GNSS_SIGNAL_TYPE_BIT, "SIG_TYPES"}
};
// LocationFlagsMask
DECLARE_TBL(LocationFlagsMask) = {
    {LOCATION_HAS_LAT_LONG_BIT, "LAT_LON"},
    {LOCATION_HAS_ALTITUDE_BIT, "ALT"},
    {LOCATION_HAS_SPEED_BIT, "SPEED"},
    {LOCATION_HAS_BEARING_BIT, "FEARING"},
    {LOCATION_HAS_ACCURACY_BIT, "ACCURACY"},
    {LOCATION_HAS_VERTICAL_ACCURACY_BIT, "VERT_ACCURACY"},
    {LOCATION_HAS_SPEED_ACCURACY_BIT, "SPEED_ACCURACY"},
    {LOCATION_HAS_BEARING_ACCURACY_BIT, "BEARING_ACCURACY"},
    {LOCATION_HAS_BEARING_ACCURACY_BIT, "TS"}
};
// LocationTechnologyMask
DECLARE_TBL(LocationTechnologyMask) = {
    {LOCATION_TECHNOLOGY_GNSS_BIT, "GNSS"},
    {LOCATION_TECHNOLOGY_CELL_BIT, "CELL"},
    {LOCATION_TECHNOLOGY_WIFI_BIT, "WIFI"},
    {LOCATION_TECHNOLOGY_SENSORS_BIT, "SENSOR"},
    {LOCATION_TECHNOLOGY_REFERENCE_LOCATION_BIT, "REF_LOC"},
    {LOCATION_TECHNOLOGY_INJECTED_COARSE_POSITION_BIT, "CPI"},
    {LOCATION_TECHNOLOGY_AFLT_BIT, "AFLT"},
    {LOCATION_TECHNOLOGY_HYBRID_BIT, "HYBRID"},
    {LOCATION_TECHNOLOGY_PPE_BIT, "PPE"}
};
// GnssLocationNavSolutionMask
DECLARE_TBL(GnssLocationNavSolutionMask) = {
    {LOCATION_SBAS_CORRECTION_IONO_BIT, "SBAS_CORR_IONO"},
    {LOCATION_SBAS_CORRECTION_FAST_BIT, "SBAS_CORR_FAST"},
    {LOCATION_SBAS_CORRECTION_LONG_BIT, "SBAS_CORR_LON"},
    {LOCATION_SBAS_INTEGRITY_BIT, "SBAS_INTEGRITY"},
    {LOCATION_NAV_CORRECTION_DGNSS_BIT, "NAV_CORR_DGNSS"},
    {LOCATION_NAV_CORRECTION_RTK_BIT, "NAV_CORR_RTK"},
    {LOCATION_NAV_CORRECTION_PPP_BIT, "NAV_CORR_PPP"},
    {LOCATION_NAV_CORRECTION_RTK_FIXED_BIT, "NAV_CORR_RTK_FIXED"},
    {LOCATION_NAV_CORRECTION_ONLY_SBAS_CORRECTED_SV_USED_BIT,
            "NAV_CORR_ONLY_SBAS_CORRECTED_SV_USED"}
};
// GnssLocationPosDataMask
DECLARE_TBL(GnssLocationPosDataMask) = {
    {LOCATION_NAV_DATA_HAS_LONG_ACCEL_BIT, "LONG_ACCEL"},
    {LOCATION_NAV_DATA_HAS_LAT_ACCEL_BIT, "LAT_ACCEL"},
    {LOCATION_NAV_DATA_HAS_VERT_ACCEL_BIT, "VERT_ACCEL"},
    {LOCATION_NAV_DATA_HAS_YAW_RATE_BIT, "YAW_RATE"},
    {LOCATION_NAV_DATA_HAS_PITCH_BIT, "PITCH"},
    {LOCATION_NAV_DATA_HAS_LONG_ACCEL_UNC_BIT, "LONG_ACCEL_UNC"},
    {LOCATION_NAV_DATA_HAS_LAT_ACCEL_UNC_BIT, "LAT_ACCEL_UNC"},
    {LOCATION_NAV_DATA_HAS_VERT_ACCEL_UNC_BIT, "VERT_ACCEL_UNC"},
    {LOCATION_NAV_DATA_HAS_YAW_RATE_UNC_BIT, "YAW_RATE_UNC"},
    {LOCATION_NAV_DATA_HAS_PITCH_UNC_BIT, "PITCH_UNC"}
};
// GnssSignalTypeMask
DECLARE_TBL(GnssSignalTypeMask) = {
    {GNSS_SIGNAL_GPS_L1CA_BIT, "GPS_L1CA"},
    {GNSS_SIGNAL_GPS_L1C_BIT, "GPS_L1C"},
    {GNSS_SIGNAL_GPS_L2_BIT, "GPS_L2"},
    {GNSS_SIGNAL_GPS_L5_BIT, "GPS_L5"},
    {GNSS_SIGNAL_GLONASS_G1_BIT, "GLO_G1"},
    {GNSS_SIGNAL_GLONASS_G2_BIT, "GLO_G2"},
    {GNSS_SIGNAL_GALILEO_E1_BIT, "GAL_E1"},
    {GNSS_SIGNAL_GALILEO_E5A_BIT, "GAL_E5A"},
    {GNSS_SIGNAL_GALILEO_E5B_BIT, "GAL_E5B"},
    {GNSS_SIGNAL_BEIDOU_B1_BIT, "BDS_B1"},
    {GNSS_SIGNAL_BEIDOU_B2_BIT, "BDS_B2"},
    {GNSS_SIGNAL_QZSS_L1CA_BIT, "QZSS_L1CA"},
    {GNSS_SIGNAL_QZSS_L1S_BIT, "QZSS_L1S"},
    {GNSS_SIGNAL_QZSS_L2_BIT, "QZSS_L2"},
    {GNSS_SIGNAL_QZSS_L2_BIT, "QZSS_L5"},
    {GNSS_SIGNAL_SBAS_L1_BIT, "SBAS_L1"},
    {GNSS_SIGNAL_BEIDOU_B1I_BIT, "BDS_B1I"},
    {GNSS_SIGNAL_BEIDOU_B1C_BIT, "BDS_B1C"},
    {GNSS_SIGNAL_BEIDOU_B2I_BIT, "BDS_B2I"},
    {GNSS_SIGNAL_BEIDOU_B2AI_BIT, "BDS_B2AI"},
    {GNSS_SIGNAL_NAVIC_L5_BIT, "NAVIC_L5"},
    {GNSS_SIGNAL_BEIDOU_B2AQ_BIT, "BDS_B2AQ"}
};
// GnssSignalTypes
DECLARE_TBL(GnssSignalTypes) = {
    {GNSS_SIGNAL_TYPE_GPS_L1CA, "GPS_L1CA"},
    {GNSS_SIGNAL_TYPE_GPS_L1C, "GPS_L1C"},
    {GNSS_SIGNAL_TYPE_GPS_L2C_L, "GPS_L2_L"},
    {GNSS_SIGNAL_TYPE_GPS_L5_Q, "GPS_L5_Q"},
    {GNSS_SIGNAL_TYPE_GLONASS_G1, "GLO_G1"},
    {GNSS_SIGNAL_TYPE_GLONASS_G2, "GLO_G2"},
    {GNSS_SIGNAL_TYPE_GALILEO_E1_C, "GAL_E1_C"},
    {GNSS_SIGNAL_TYPE_GALILEO_E5A_Q, "GAL_E5A_Q"},
    {GNSS_SIGNAL_TYPE_GALILEO_E5B_Q, "GAL_E5B_Q"},
    {GNSS_SIGNAL_TYPE_BEIDOU_B1_I, "BDS_B1_I"},
    {GNSS_SIGNAL_TYPE_BEIDOU_B1C, "BDS_B1C"},
    {GNSS_SIGNAL_TYPE_BEIDOU_B1C, "BDS_B2I"},
    {GNSS_SIGNAL_TYPE_BEIDOU_B2A_I, "BDS_B2AI"},
    {GNSS_SIGNAL_TYPE_QZSS_L1CA, "QZSS_L1CA"},
    {GNSS_SIGNAL_TYPE_QZSS_L1S, "QZSS_L1S"},
    {GNSS_SIGNAL_TYPE_QZSS_L2C_L, "QZSS_L2C_L"},
    {GNSS_SIGNAL_TYPE_QZSS_L5_Q, "QZSS_L5"},
    {GNSS_SIGNAL_TYPE_SBAS_L1_CA, "SBAS_L1_CA"},
    {GNSS_SIGNAL_TYPE_NAVIC_L5, "NAVIC_L5"},
    {GNSS_SIGNAL_TYPE_BEIDOU_B2A_Q, "BDS_B2AQ"}
};
// GnssSvType
DECLARE_TBL(GnssSvType) = {
    {GNSS_SV_TYPE_UNKNOWN, "UNKNOWN"},
    {GNSS_SV_TYPE_GPS, "GPS"},
    {GNSS_SV_TYPE_SBAS, "SBAS"},
    {GNSS_SV_TYPE_GLONASS, "GLO"},
    {GNSS_SV_TYPE_QZSS, "QZSS"},
    {GNSS_SV_TYPE_BEIDOU, "BDS"},
    {GNSS_SV_TYPE_GALILEO, "GAL"},
    {GNSS_SV_TYPE_NAVIC, "NAVIC"}
};
// Gnss_LocSvSystemEnumType
DECLARE_TBL(Gnss_LocSvSystemEnumType) = {
    {GNSS_LOC_SV_SYSTEM_GPS,     "GPS"},
    {GNSS_LOC_SV_SYSTEM_GALILEO, "GAL"},
    {GNSS_LOC_SV_SYSTEM_SBAS,    "SBAS"},
    {GNSS_LOC_SV_SYSTEM_GLONASS, "GLO"},
    {GNSS_LOC_SV_SYSTEM_BDS,     "BDS"},
    {GNSS_LOC_SV_SYSTEM_QZSS,    "QZSS"},
    {GNSS_LOC_SV_SYSTEM_NAVIC,   "NAVIC"}
};
// GnssLocationInfoFlagMask
DECLARE_TBL(GnssLocationInfoFlagMask) = {
    {GNSS_LOCATION_INFO_ALTITUDE_MEAN_SEA_LEVEL_BIT, "ALT_SEA_LEVEL"},
    {GNSS_LOCATION_INFO_ALTITUDE_MEAN_SEA_LEVEL_BIT, "DOP"},
    {GNSS_LOCATION_INFO_MAGNETIC_DEVIATION_BIT, "MAG_DEV"},
    {GNSS_LOCATION_INFO_HOR_RELIABILITY_BIT, "HOR_RELIAB"},
    {GNSS_LOCATION_INFO_VER_RELIABILITY_BIT, "VER_RELIAB"},
    {GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MAJOR_BIT, "HOR_ACCU_ELIP_SEMI_MAJOR"},
    {GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MINOR_BIT, "HOR_ACCU_ELIP_SEMI_MINOR"},
    {GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_AZIMUTH_BIT, "HOR_ACCU_ELIP_AZIMUTH"},
    {GNSS_LOCATION_INFO_GNSS_SV_USED_DATA_BIT, "GNSS_SV_USED"},
    {GNSS_LOCATION_INFO_NAV_SOLUTION_MASK_BIT, "NAV_SOLUTION"},
    {GNSS_LOCATION_INFO_POS_TECH_MASK_BIT, "POS_TECH"},
    {GNSS_LOCATION_INFO_SV_SOURCE_INFO_BIT, "SV_SOURCE"},
    {GNSS_LOCATION_INFO_POS_DYNAMICS_DATA_BIT, "POS_DYNAMICS"},
    {GNSS_LOCATION_INFO_EXT_DOP_BIT, "EXT_DOP"},
    {GNSS_LOCATION_INFO_NORTH_STD_DEV_BIT, "NORTH_STD_DEV"},
    {GNSS_LOCATION_INFO_EAST_STD_DEV_BIT, "EAST_STD_DEV"},
    {GNSS_LOCATION_INFO_EAST_STD_DEV_BIT, "NORTH_VEL"},
    {GNSS_LOCATION_INFO_EAST_VEL_BIT, "EAST_VEL"},
    {GNSS_LOCATION_INFO_UP_VEL_BIT, "UP_VEL"},
    {GNSS_LOCATION_INFO_NORTH_VEL_UNC_BIT, "NORTH_VEL_UNC"},
    {GNSS_LOCATION_INFO_EAST_VEL_UNC_BIT, "EAST_VEL_UNC"},
    {GNSS_LOCATION_INFO_UP_VEL_UNC_BIT, "UP_VEL_UNC"},
    {GNSS_LOCATION_INFO_LEAP_SECONDS_BIT, "LEAP_SECONDS"},
    {GNSS_LOCATION_INFO_TIME_UNC_BIT, "TIME_UNC"},
    {GNSS_LOCATION_INFO_NUM_SV_USED_IN_POSITION_BIT, "NUM_SV_USED_IN_FIX"},
    {GNSS_LOCATION_INFO_CALIBRATION_CONFIDENCE_PERCENT_BIT, "CAL_CONF_PRECENT"},
    {GNSS_LOCATION_INFO_CALIBRATION_STATUS_BIT, "CAL_STATUS"},
    {GNSS_LOCATION_INFO_OUTPUT_ENG_TYPE_BIT, "OUTPUT_ENG_TYPE"},
    {GNSS_LOCATION_INFO_OUTPUT_ENG_MASK_BIT, "OUTPUT_ENG_MASK"},
    {GNSS_LOCATION_INFO_CONFORMITY_INDEX_BIT, "CONFORMITY_INDEX"}
};
// LocationReliability
DECLARE_TBL(LocationReliability) = {
    {LOCATION_RELIABILITY_NOT_SET, "NOT_SET"},
    {LOCATION_RELIABILITY_VERY_LOW, "VERY_LOW"},
    {LOCATION_RELIABILITY_LOW, "LOW"},
    {LOCATION_RELIABILITY_MEDIUM, "MED"},
    {LOCATION_RELIABILITY_HIGH, "HI"}
};
// GnssSystemTimeStructTypeFlags
DECLARE_TBL(GnssSystemTimeStructTypeFlags) = {
    {GNSS_SYSTEM_TIME_WEEK_VALID, "WEEK"},
    {GNSS_SYSTEM_TIME_WEEK_MS_VALID, "WEEK_MS"},
    {GNSS_SYSTEM_CLK_TIME_BIAS_VALID, "CLK_BIAS"},
    {GNSS_SYSTEM_CLK_TIME_BIAS_UNC_VALID, "CLK_BIAS_UNC"},
    {GNSS_SYSTEM_REF_FCOUNT_VALID, "REF_COUNT"},
    {GNSS_SYSTEM_NUM_CLOCK_RESETS_VALID, "CLK_RESET"}
};
// GnssGloTimeStructTypeFlags
DECLARE_TBL(GnssGloTimeStructTypeFlags) = {
    {GNSS_CLO_DAYS_VALID, "DAYS"},
    {GNSS_GLO_MSEC_VALID, "MS"},
    {GNSS_GLO_CLK_TIME_BIAS_VALID, "CLK_BIAS"},
    {GNSS_GLO_CLK_TIME_BIAS_UNC_VALID, "CLK_BIAS_UNC"},
    {GNSS_GLO_REF_FCOUNT_VALID, "REF_COUNT"},
    {GNSS_GLO_NUM_CLOCK_RESETS_VALID, "CLK_RESET"},
    {GNSS_GLO_FOUR_YEAR_VALID, "YEAR"}
};
// DrCalibrationStatusMask
DECLARE_TBL(DrCalibrationStatusMask) = {
    {DR_ROLL_CALIBRATION_NEEDED, "ROLL"},
    {DR_PITCH_CALIBRATION_NEEDED, "PITCH"},
    {DR_YAW_CALIBRATION_NEEDED, "YAW"},
    {DR_ODO_CALIBRATION_NEEDED, "ODO"},
    {DR_GYRO_CALIBRATION_NEEDED, "GYRO"}
};
// LocReqEngineTypeMask
DECLARE_TBL(LocReqEngineTypeMask) = {
    {LOC_REQ_ENGINE_FUSED_BIT, "FUSED"},
    {LOC_REQ_ENGINE_SPE_BIT, "SPE"},
    {LOC_REQ_ENGINE_PPE_BIT, "PPE"},
    {LOC_REQ_ENGINE_VPE_BIT, "VPE"}
};
// LocOutputEngineType
DECLARE_TBL(LocOutputEngineType) = {
    {LOC_OUTPUT_ENGINE_FUSED, "FUSED"},
    {LOC_OUTPUT_ENGINE_SPE, "SPE"},
    {LOC_OUTPUT_ENGINE_PPE, "PPE"},
    {LOC_OUTPUT_ENGINE_VPE, "VPE"},
    {LOC_OUTPUT_ENGINE_COUNT, "COUNT"}
};
// PositioningEngineMask
DECLARE_TBL(PositioningEngineMask) = {
    {STANDARD_POSITIONING_ENGINE, "SPE"},
    {DEAD_RECKONING_ENGINE, "DRE"},
    {PRECISE_POSITIONING_ENGINE, "PPE"},
    {VP_POSITIONING_ENGINE, "VPE"}
};
// GnssDataMask
DECLARE_TBL(GnssDataMask) = {
    {GNSS_DATA_JAMMER_IND_BIT, "JAMMER"},
    {GNSS_DATA_AGC_BIT, "AGC"}
};
// GnssMeasurementsDataFlagsMask
DECLARE_TBL(GnssMeasurementsDataFlagsMask) = {
    {GNSS_MEASUREMENTS_DATA_SV_ID_BIT, "svId"},
    {GNSS_MEASUREMENTS_DATA_SV_TYPE_BIT, "svType"},
    {GNSS_MEASUREMENTS_DATA_STATE_BIT, "stateMask"},
    {GNSS_MEASUREMENTS_DATA_RECEIVED_SV_TIME_BIT, "receivedSvTimeNs"},
    {GNSS_MEASUREMENTS_DATA_RECEIVED_SV_TIME_UNCERTAINTY_BIT, "receivedSvTimeUncertaintyNs"},
    {GNSS_MEASUREMENTS_DATA_CARRIER_TO_NOISE_BIT, "carrierToNoiseDbHz"},
    {GNSS_MEASUREMENTS_DATA_PSEUDORANGE_RATE_BIT, "pseudorangeRateMps"},
    {GNSS_MEASUREMENTS_DATA_PSEUDORANGE_RATE_UNCERTAINTY_BIT, "pseudorangeRateUncertaintyMps"},
    {GNSS_MEASUREMENTS_DATA_ADR_STATE_BIT, "adrStateMask"},
    {GNSS_MEASUREMENTS_DATA_ADR_BIT, "adrMeters"},
    {GNSS_MEASUREMENTS_DATA_ADR_UNCERTAINTY_BIT, "adrUncertaintyMeters"},
    {GNSS_MEASUREMENTS_DATA_CARRIER_FREQUENCY_BIT, "carrierFrequencyHz"},
    {GNSS_MEASUREMENTS_DATA_CARRIER_CYCLES_BIT, "carrierCycles"},
    {GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_BIT, "carrierPhase"},
    {GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_UNCERTAINTY_BIT, "carrierPhaseUncertainty"},
    {GNSS_MEASUREMENTS_DATA_MULTIPATH_INDICATOR_BIT, "multipathIndicator"},
    {GNSS_MEASUREMENTS_DATA_SIGNAL_TO_NOISE_RATIO_BIT, "signalToNoiseRatioDb"},
    {GNSS_MEASUREMENTS_DATA_AUTOMATIC_GAIN_CONTROL_BIT, "agcLevelDb"},
    {GNSS_MEASUREMENTS_DATA_FULL_ISB_BIT, "interSignalBiasNs"},
    {GNSS_MEASUREMENTS_DATA_FULL_ISB_UNCERTAINTY_BIT, "interSignalBiasUncertaintyNs"},
    {GNSS_MEASUREMENTS_DATA_CYCLE_SLIP_COUNT_BIT, "cycleSlipCount"}
};
// GnssMeasurementsStateMask
DECLARE_TBL(GnssMeasurementsStateMask) = {
    {GNSS_MEASUREMENTS_STATE_CODE_LOCK_BIT, "CODE_LOCK"},
    {GNSS_MEASUREMENTS_STATE_BIT_SYNC_BIT, "BIT_SYNC"},
    {GNSS_MEASUREMENTS_STATE_SUBFRAME_SYNC_BIT, "SUBFRAME_SYNC"},
    {GNSS_MEASUREMENTS_STATE_TOW_DECODED_BIT, "TOW_DECODED"},
    {GNSS_MEASUREMENTS_STATE_MSEC_AMBIGUOUS_BIT, "MSEC_AMBIGUOUS"},
    {GNSS_MEASUREMENTS_STATE_SYMBOL_SYNC_BIT, "SYMBOL_SYNC"},
    {GNSS_MEASUREMENTS_STATE_GLO_STRING_SYNC_BIT, "GLO_STRING_SYNC"},
    {GNSS_MEASUREMENTS_STATE_GLO_TOD_DECODED_BIT, "GLO_TOD_DECODED"},
    {GNSS_MEASUREMENTS_STATE_BDS_D2_BIT_SYNC_BIT, "BDS_D2_BIT_SYNC"},
    {GNSS_MEASUREMENTS_STATE_BDS_D2_SUBFRAME_SYNC_BIT, "BDS_D2_SUBFRAME_SYNC"},
    {GNSS_MEASUREMENTS_STATE_GAL_E1BC_CODE_LOCK_BIT, "GAL_E1BC_CODE_LOCK"},
    {GNSS_MEASUREMENTS_STATE_GAL_E1C_2ND_CODE_LOCK_BIT, "GAL_E1C_2ND_CODE_LOCK"},
    {GNSS_MEASUREMENTS_STATE_GAL_E1B_PAGE_SYNC_BIT, "GAL_E1B_PAGE_SYNC"},
    {GNSS_MEASUREMENTS_STATE_SBAS_SYNC_BIT, "SBAS_SYNC"}
};
// GnssMeasurementsAdrStateMask
DECLARE_TBL(GnssMeasurementsAdrStateMask) = {
    {GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_VALID_BIT, "VALID"},
    {GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_RESET_BIT, "RESET"},
    {GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_CYCLE_SLIP_BIT, "CYCLE_SLIP"}
};
// GnssMeasurementsMultipathIndicator
DECLARE_TBL(GnssMeasurementsMultipathIndicator) = {
    {GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_UNKNOWN, "UNKNOWN"},
    {GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_PRESENT, "PRESENT"},
    {GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_NOT_PRESENT, "NOT_PRESENT"}
};
// GnssMeasurementsClockFlagsMask
DECLARE_TBL(GnssMeasurementsClockFlagsMask) = {
    {GNSS_MEASUREMENTS_CLOCK_FLAGS_LEAP_SECOND_BIT, "LEAP_SECOND"},
    {GNSS_MEASUREMENTS_CLOCK_FLAGS_TIME_BIT, "TIME"},
    {GNSS_MEASUREMENTS_CLOCK_FLAGS_TIME_UNCERTAINTY_BIT, "TIME_UNC"},
    {GNSS_MEASUREMENTS_CLOCK_FLAGS_FULL_BIAS_BIT, "FULL_BIAS"},
    {GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_BIT, "BIAS"},
    {GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_BIT, "BIAS_UNC"},
    {GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_BIT, "DRIFT"},
    {GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_UNCERTAINTY_BIT, "DRIFT_UNC"},
    {GNSS_MEASUREMENTS_CLOCK_FLAGS_HW_CLOCK_DISCONTINUITY_COUNT_BIT, "HW_CLK_DISCONTINUITY_CNT"}
};
// LeapSecondSysInfoMask
DECLARE_TBL(LeapSecondSysInfoMask) = {
    {LEAP_SECOND_SYS_INFO_CURRENT_LEAP_SECONDS_BIT, "CUR_LEAP_SEC"},
    {LEAP_SECOND_SYS_INFO_LEAP_SECOND_CHANGE_BIT, "LEAP_SEC_CHANGE"}
};
// LocationSystemInfoMask
DECLARE_TBL(LocationSystemInfoMask) = {
    {LOC_SYS_INFO_LEAP_SECOND, "LEAP_SEC"}
};

// LocationSystemInfoMask
DECLARE_TBL(DrSolutionStatusMask) = {
    {DR_SOLUTION_STATUS_VEHICLE_SENSOR_SPEED_INPUT_DETECTED, "VEHICLE_SENSOR_SPEED_INPUT_DETECTED"},
    {DR_SOLUTION_STATUS_VEHICLE_SENSOR_SPEED_INPUT_USED, "VEHICLE_SENSOR_SPEED_INPUT_USED"}
};

string LocationClientApi::capabilitiesToString(LocationCapabilitiesMask capabMask) {
    string out;
    out.reserve(256);

    out += FIELDVAL_MASK(capabMask, LocationCapabilitiesMask_tbl);

    return out;
}

// LocSessionStatus
DECLARE_TBL(LocSessionStatus) = {
    {LOC_SESS_SUCCESS, "LOC_SESS_SUCCESS"},
    {LOC_SESS_INTERMEDIATE, "LOC_SESS_INTERMEDIATE"},
    {LOC_SESS_FAILURE, "LOC_SESS_FAILURE" }
};

string GnssLocationSvUsedInPosition::toString() const {
    string out;
    out.reserve(256);

    // gpsSvUsedIdsMask
    out += FIELDVAL_HEX(gpsSvUsedIdsMask);
    out += loc_parenthesize(maskToVals(gpsSvUsedIdsMask, GPS_SV_PRN_MIN)) + "\n";

    out += FIELDVAL_HEX(gloSvUsedIdsMask);
    out += loc_parenthesize(maskToVals(gloSvUsedIdsMask, GLO_SV_PRN_MIN)) + "\n";

    out += FIELDVAL_HEX(galSvUsedIdsMask);
    out += loc_parenthesize(maskToVals(galSvUsedIdsMask, GAL_SV_PRN_MIN)) + "\n";

    out += FIELDVAL_HEX(bdsSvUsedIdsMask);
    out += loc_parenthesize(maskToVals(bdsSvUsedIdsMask, BDS_SV_PRN_MIN)) + "\n";

    out += FIELDVAL_HEX(qzssSvUsedIdsMask);
    out += loc_parenthesize(maskToVals(qzssSvUsedIdsMask, QZSS_SV_PRN_MIN)) + "\n";

    out += FIELDVAL_HEX(navicSvUsedIdsMask);
    out += loc_parenthesize(maskToVals(navicSvUsedIdsMask, NAVIC_SV_PRN_MIN)) + "\n";

    return out;
}

string GnssMeasUsageInfo::toString() const {
    string out;
    out.reserve(256);

    out += FIELDVAL_ENUM(gnssConstellation, Gnss_LocSvSystemEnumType_tbl);
    out += FIELDVAL_DEC(gnssSvId);
    out += FIELDVAL_MASK(gnssSignalType, GnssSignalTypeMask_tbl);

    return out;
}

string GnssLocationPositionDynamics::toString() const {
    string out;
    out.reserve(256);

    out += FIELDVAL_MASK(bodyFrameDataMask, GnssLocationPosDataMask_tbl);
    out += FIELDVAL_DEC(longAccel);
    out += FIELDVAL_DEC(latAccel);
    out += FIELDVAL_DEC(vertAccel);
    out += FIELDVAL_DEC(longAccelUnc);
    out += FIELDVAL_DEC(latAccelUnc);
    out += FIELDVAL_DEC(vertAccelUnc);
    out += FIELDVAL_DEC(pitch);
    out += FIELDVAL_DEC(pitchUnc);
    out += FIELDVAL_DEC(pitchRate);
    out += FIELDVAL_DEC(pitchRateUnc);
    out += FIELDVAL_DEC(roll);
    out += FIELDVAL_DEC(rollUnc);
    out += FIELDVAL_DEC(rollRate);
    out += FIELDVAL_DEC(rollRateUnc);
    out += FIELDVAL_DEC(yaw);
    out += FIELDVAL_DEC(yawUnc);
    out += FIELDVAL_DEC(yawRate);
    out += FIELDVAL_DEC(yawRateUnc);

    return out;
}

string GnssSystemTimeStructType::toString() const {
    string out;
    out.reserve(256);

    out += FIELDVAL_MASK(validityMask, GnssSystemTimeStructTypeFlags_tbl);
    out += FIELDVAL_DEC(systemWeek);
    out += FIELDVAL_DEC(systemMsec);
    out += FIELDVAL_DEC(systemClkTimeBias);
    out += FIELDVAL_DEC(systemClkTimeUncMs);
    out += FIELDVAL_DEC(refFCount);
    out += FIELDVAL_DEC(numClockResets);

    return out;
}

string GnssGloTimeStructType::toString() const {
    string out;
    out.reserve(256);

    out += FIELDVAL_MASK(validityMask, GnssGloTimeStructTypeFlags_tbl);
    out += FIELDVAL_DEC(gloFourYear);
    out += FIELDVAL_DEC(gloDays);
    out += FIELDVAL_DEC(gloMsec);
    out += FIELDVAL_DEC(gloClkTimeBias);
    out += FIELDVAL_DEC(gloClkTimeUncMs);
    out += FIELDVAL_DEC(refFCount);
    out += FIELDVAL_DEC(numClockResets);

    return out;
}

string GnssSystemTime::toString() const {
    switch (gnssSystemTimeSrc) {
    case GNSS_LOC_SV_SYSTEM_GPS:
        return u.gpsSystemTime.toString();
    case GNSS_LOC_SV_SYSTEM_GALILEO:
        return u.galSystemTime.toString();
    case GNSS_LOC_SV_SYSTEM_GLONASS:
        return u.gloSystemTime.toString();
    case GNSS_LOC_SV_SYSTEM_BDS:
        return u.bdsSystemTime.toString();
    case GNSS_LOC_SV_SYSTEM_QZSS:
        return u.qzssSystemTime.toString();
    case GNSS_LOC_SV_SYSTEM_NAVIC:
        return u.navicSystemTime.toString();
    default:
        return "Unknown System ID: " + gnssSystemTimeSrc;
    }
}

string LLAInfo::toString() const {
    string out;
    out.reserve(256);
    out +=  "VRP based " + FIELDVAL_DEC(latitude);
    out +=  "VRP based " + FIELDVAL_DEC(longitude);
    out +=  "VRP based " + FIELDVAL_DEC(altitude);
    return out;
}

string Location::toString() const {
    string out;
    out.reserve(256);

    out += FIELDVAL_MASK(flags, LocationFlagsMask_tbl);
    out += FIELDVAL_DEC(timestamp);
    out += FIELDVAL_DEC(latitude);
    out += FIELDVAL_DEC(longitude);
    out += FIELDVAL_DEC(altitude);
    out += FIELDVAL_DEC(speed);
    out += FIELDVAL_DEC(bearing);
    out += FIELDVAL_DEC(horizontalAccuracy);
    out += FIELDVAL_DEC(verticalAccuracy);
    out += FIELDVAL_DEC(speedAccuracy);
    out += FIELDVAL_DEC(bearingAccuracy);
    out += FIELDVAL_MASK(techMask, LocationTechnologyMask_tbl);

    return out;
}

string GnssLocation::toString() const {
    string out;
    out.reserve(8096);

    out += Location::toString();
    out += FIELDVAL_MASK(gnssInfoFlags, GnssLocationInfoFlagMask_tbl);
    out += FIELDVAL_DEC(altitudeMeanSeaLevel);
    out += FIELDVAL_DEC(pdop);
    out += FIELDVAL_DEC(hdop);
    out += FIELDVAL_DEC(vdop);
    out += FIELDVAL_DEC(gdop);
    out += FIELDVAL_DEC(tdop);
    out += FIELDVAL_DEC(magneticDeviation);
    out += FIELDVAL_ENUM(horReliability, LocationReliability_tbl);
    out += FIELDVAL_ENUM(verReliability, LocationReliability_tbl);
    out += FIELDVAL_DEC(horUncEllipseSemiMajor);
    out += FIELDVAL_DEC(horUncEllipseSemiMinor);
    out += FIELDVAL_DEC(horUncEllipseOrientAzimuth);
    out += FIELDVAL_DEC(northStdDeviation);
    out += FIELDVAL_DEC(eastStdDeviation);
    out += FIELDVAL_DEC(northVelocity);
    out += FIELDVAL_DEC(eastVelocity);
    out += FIELDVAL_DEC(upVelocity);
    out += FIELDVAL_DEC(northVelocityStdDeviation);
    out += FIELDVAL_DEC(eastVelocityStdDeviation);
    out += FIELDVAL_DEC(upVelocityStdDeviation);
    out += FIELDVAL_DEC(numSvUsedInPosition);
    out += svUsedInPosition.toString();
    out += FIELDVAL_MASK(navSolutionMask, GnssLocationNavSolutionMask_tbl);
    out += bodyFrameData.toString();
    out += gnssSystemTime.toString();

    uint32_t ind = 0;
    for (auto measUsage : measUsageInfo) {
        out += "measUsageInfo[";
        out += to_string(ind);
        out += "]: ";
        out += measUsage.toString();
        ind++;
    }

    out += FIELDVAL_DEC(leapSeconds);
    out += FIELDVAL_DEC(timeUncMs);
    out += FIELDVAL_DEC(calibrationConfidencePercent);
    out += FIELDVAL_MASK(calibrationStatus, DrCalibrationStatusMask_tbl);
    out += FIELDVAL_ENUM(locOutputEngType, LocOutputEngineType_tbl);
    out += FIELDVAL_MASK(locOutputEngMask, PositioningEngineMask_tbl);
    out += FIELDVAL_DEC(conformityIndex);
    out += llaVRPBased.toString();
    out += FIELDVAL_DEC(enuVelocityVRPBased[0]);
    out += FIELDVAL_DEC(enuVelocityVRPBased[1]);
    out += FIELDVAL_DEC(enuVelocityVRPBased[2]);
    out += FIELDVAL_MASK(drSolutionStatusMask, DrSolutionStatusMask_tbl);
    out += FIELDVAL_MASK(sessionStatus, LocSessionStatus_tbl);

    return out;
}

string GnssSv::toString() const {
    string out;
    out.reserve(256);

    out += FIELDVAL_DEC(svId);
    out += FIELDVAL_ENUM(type, GnssSvType_tbl);
    out += FIELDVAL_DEC(cN0Dbhz);
    out += FIELDVAL_DEC(elevation);
    out += FIELDVAL_DEC(azimuth);
    out += FIELDVAL_MASK(gnssSvOptionsMask, GnssSvOptionsMask_tbl);
    out += FIELDVAL_DEC(carrierFrequencyHz);
    out += FIELDVAL_MASK(gnssSignalTypeMask, GnssSignalTypeMask_tbl);
    out += FIELDVAL_DEC(basebandCarrierToNoiseDbHz);
    out += FIELDVAL_DEC(gloFrequency);

    return out;
}

string GnssData::toString() const {
    string out;
    out.reserve(4096);

    for (int i = 0; i < GNSS_MAX_NUMBER_OF_SIGNAL_TYPES; i++) {
        out += FIELDVAL_MASK(i, GnssSignalTypes_tbl);
        out += FIELDVAL_MASK(gnssDataMask[i], GnssDataMask_tbl);
        out += FIELDVAL_DEC(jammerInd[i]);
        out += FIELDVAL_DEC(agc[i]);
    }

    return out;
}

string GnssMeasurementsData::toString() const {
    string out;
    out.reserve(256);

    out += FIELDVAL_MASK(flags, GnssMeasurementsDataFlagsMask_tbl);
    out += FIELDVAL_DEC(svId);
    out += FIELDVAL_ENUM(svType, GnssSvType_tbl);
    out += FIELDVAL_DEC(timeOffsetNs);
    out += FIELDVAL_MASK(stateMask, GnssMeasurementsStateMask_tbl);
    out += FIELDVAL_DEC(receivedSvTimeNs);
    out += FIELDVAL_DEC(receivedSvTimeUncertaintyNs);
    out += FIELDVAL_DEC(carrierToNoiseDbHz);
    out += FIELDVAL_DEC(pseudorangeRateMps);
    out += FIELDVAL_DEC(pseudorangeRateUncertaintyMps);
    out += FIELDVAL_MASK(adrStateMask, GnssMeasurementsAdrStateMask_tbl);
    out += FIELDVAL_DEC(adrMeters);
    out += FIELDVAL_DEC(adrUncertaintyMeters);
    out += FIELDVAL_DEC(carrierFrequencyHz);
    out += FIELDVAL_DEC(carrierCycles);
    out += FIELDVAL_DEC(carrierPhase);
    out += FIELDVAL_DEC(carrierPhaseUncertainty);
    out += FIELDVAL_ENUM(multipathIndicator, GnssMeasurementsMultipathIndicator_tbl);
    out += FIELDVAL_DEC(signalToNoiseRatioDb);
    out += FIELDVAL_DEC(agcLevelDb);
    out += FIELDVAL_DEC(basebandCarrierToNoiseDbHz);
    out += FIELDVAL_MASK(gnssSignalType, GnssSignalTypeMask_tbl);
    out += FIELDVAL_DEC(interSignalBiasNs);
    out += FIELDVAL_DEC(interSignalBiasUncertaintyNs);
    out += FIELDVAL_DEC(cycleSlipCount);

    return out;
}

string GnssMeasurementsClock::toString() const {
    string out;
    out.reserve(256);

    out += FIELDVAL_MASK(flags, GnssMeasurementsClockFlagsMask_tbl);
    out += FIELDVAL_DEC(leapSecond);
    out += FIELDVAL_DEC(timeNs);
    out += FIELDVAL_DEC(timeUncertaintyNs);
    out += FIELDVAL_DEC(fullBiasNs);
    out += FIELDVAL_DEC(biasNs);
    out += FIELDVAL_DEC(biasUncertaintyNs);
    out += FIELDVAL_DEC(driftNsps);
    out += FIELDVAL_DEC(driftUncertaintyNsps);
    out += FIELDVAL_DEC(hwClockDiscontinuityCount);

    return out;
}

string GnssMeasurements::toString() const {
    string out;
    // (number of GnssMeasurementsData in the vector + GnssMeasurementsClock) * 256
    out.reserve((measurements.size() + 1) << 8);

    out += clock.toString();
    for (auto meas : measurements) {
        out += meas.toString();
    }

    return out;
}

string LeapSecondChangeInfo::toString() const {
    string out;
    out.reserve(256);

    out += gpsTimestampLsChange.toString();
    out += FIELDVAL_DEC(leapSecondsBeforeChange);
    out += FIELDVAL_DEC(leapSecondsAfterChange);

    return out;
}

string LeapSecondSystemInfo::toString() const {
    string out;
    out.reserve(256);

    out += FIELDVAL_MASK(leapSecondInfoMask, LeapSecondSysInfoMask_tbl);
    out += FIELDVAL_DEC(leapSecondCurrent);

    return out;
}

string LocationSystemInfo::toString() const {
    string out;
    out.reserve(256);

    out += FIELDVAL_MASK(systemInfoMask, LocationSystemInfoMask_tbl);
    out += leapSecondSysInfo.toString();

    return out;
}

} // namespace location_client