/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#define STATSD_DEBUG false  // STOPSHIP if true
#include "Log.h"

#include "logd/LogEvent.h"

#include <android-base/stringprintf.h>
#include <android/binder_ibinder.h>
#include <private/android_filesystem_config.h>

#include "flags/FlagProvider.h"
#include "stats_annotations.h"
#include "stats_log_util.h"
#include "statslog_statsd.h"

namespace android {
namespace os {
namespace statsd {

// for TrainInfo experiment id serialization
const int FIELD_ID_EXPERIMENT_ID = 1;

using namespace android::util;
using android::base::StringPrintf;
using android::util::ProtoOutputStream;
using std::string;
using std::vector;

namespace {

uint8_t getTypeId(uint8_t typeInfo) {
    return typeInfo & 0x0F;  // type id in lower 4 bytes
}

uint8_t getNumAnnotations(uint8_t typeInfo) {
    return (typeInfo >> 4) & 0x0F;  // num annotations in upper 4 bytes
}

}  // namespace

LogEvent::LogEvent(int32_t uid, int32_t pid)
    : mLogdTimestampNs(getWallClockNs()), mLogUid(uid), mLogPid(pid) {
}

LogEvent::LogEvent(const string& trainName, int64_t trainVersionCode, bool requiresStaging,
                   bool rollbackEnabled, bool requiresLowLatencyMonitor, int32_t state,
                   const std::vector<uint8_t>& experimentIds, int32_t userId) {
    mLogdTimestampNs = getWallClockNs();
    mElapsedTimestampNs = getElapsedRealtimeNs();
    mTagId = util::BINARY_PUSH_STATE_CHANGED;
    mLogUid = AIBinder_getCallingUid();
    mLogPid = AIBinder_getCallingPid();

    mValues.push_back(FieldValue(Field(mTagId, getSimpleField(1)), Value(trainName)));
    mValues.push_back(FieldValue(Field(mTagId, getSimpleField(2)), Value(trainVersionCode)));
    mValues.push_back(FieldValue(Field(mTagId, getSimpleField(3)), Value((int)requiresStaging)));
    mValues.push_back(FieldValue(Field(mTagId, getSimpleField(4)), Value((int)rollbackEnabled)));
    mValues.push_back(
            FieldValue(Field(mTagId, getSimpleField(5)), Value((int)requiresLowLatencyMonitor)));
    mValues.push_back(FieldValue(Field(mTagId, getSimpleField(6)), Value(state)));
    mValues.push_back(FieldValue(Field(mTagId, getSimpleField(7)), Value(experimentIds)));
    mValues.push_back(FieldValue(Field(mTagId, getSimpleField(8)), Value(userId)));
}

LogEvent::LogEvent(int64_t wallClockTimestampNs, int64_t elapsedTimestampNs,
                   const InstallTrainInfo& trainInfo) {
    mLogdTimestampNs = wallClockTimestampNs;
    mElapsedTimestampNs = elapsedTimestampNs;
    mTagId = util::TRAIN_INFO;

    mValues.push_back(
            FieldValue(Field(mTagId, getSimpleField(1)), Value(trainInfo.trainVersionCode)));
    std::vector<uint8_t> experimentIdsProto;
    writeExperimentIdsToProto(trainInfo.experimentIds, &experimentIdsProto);
    mValues.push_back(FieldValue(Field(mTagId, getSimpleField(2)), Value(experimentIdsProto)));
    mValues.push_back(FieldValue(Field(mTagId, getSimpleField(3)), Value(trainInfo.trainName)));
    mValues.push_back(FieldValue(Field(mTagId, getSimpleField(4)), Value(trainInfo.status)));
}

void LogEvent::parseInt32(int32_t* pos, int32_t depth, bool* last, uint8_t numAnnotations) {
    int32_t value = readNextValue<int32_t>();
    addToValues(pos, depth, value, last);
    parseAnnotations(numAnnotations);
}

void LogEvent::parseInt64(int32_t* pos, int32_t depth, bool* last, uint8_t numAnnotations) {
    int64_t value = readNextValue<int64_t>();
    addToValues(pos, depth, value, last);
    parseAnnotations(numAnnotations);
}

void LogEvent::parseString(int32_t* pos, int32_t depth, bool* last, uint8_t numAnnotations) {
    int32_t numBytes = readNextValue<int32_t>();
    if ((uint32_t)numBytes > mRemainingLen) {
        mValid = false;
        return;
    }

    string value = string((char*)mBuf, numBytes);
    mBuf += numBytes;
    mRemainingLen -= numBytes;
    addToValues(pos, depth, value, last);
    parseAnnotations(numAnnotations);
}

void LogEvent::parseFloat(int32_t* pos, int32_t depth, bool* last, uint8_t numAnnotations) {
    float value = readNextValue<float>();
    addToValues(pos, depth, value, last);
    parseAnnotations(numAnnotations);
}

void LogEvent::parseBool(int32_t* pos, int32_t depth, bool* last, uint8_t numAnnotations) {
    // cast to int32_t because FieldValue does not support bools
    int32_t value = (int32_t)readNextValue<uint8_t>();
    addToValues(pos, depth, value, last);
    parseAnnotations(numAnnotations);
}

void LogEvent::parseByteArray(int32_t* pos, int32_t depth, bool* last, uint8_t numAnnotations) {
    int32_t numBytes = readNextValue<int32_t>();
    if ((uint32_t)numBytes > mRemainingLen) {
        mValid = false;
        return;
    }

    vector<uint8_t> value(mBuf, mBuf + numBytes);
    mBuf += numBytes;
    mRemainingLen -= numBytes;
    addToValues(pos, depth, value, last);
    parseAnnotations(numAnnotations);
}

void LogEvent::parseKeyValuePairs(int32_t* pos, int32_t depth, bool* last, uint8_t numAnnotations) {
    int32_t numPairs = readNextValue<uint8_t>();

    for (pos[1] = 1; pos[1] <= numPairs; pos[1]++) {
        last[1] = (pos[1] == numPairs);

        // parse key
        pos[2] = 1;
        parseInt32(pos, /*depth=*/2, last, /*numAnnotations=*/0);

        // parse value
        last[2] = true;

        uint8_t typeInfo = readNextValue<uint8_t>();
        switch (getTypeId(typeInfo)) {
            case INT32_TYPE:
                pos[2] = 2;  // pos[2] determined by index of type in KeyValuePair in atoms.proto
                parseInt32(pos, /*depth=*/2, last, /*numAnnotations=*/0);
                break;
            case INT64_TYPE:
                pos[2] = 3;
                parseInt64(pos, /*depth=*/2, last, /*numAnnotations=*/0);
                break;
            case STRING_TYPE:
                pos[2] = 4;
                parseString(pos, /*depth=*/2, last, /*numAnnotations=*/0);
                break;
            case FLOAT_TYPE:
                pos[2] = 5;
                parseFloat(pos, /*depth=*/2, last, /*numAnnotations=*/0);
                break;
            default:
                mValid = false;
        }
    }

    parseAnnotations(numAnnotations);

    pos[1] = pos[2] = 1;
    last[1] = last[2] = false;
}

void LogEvent::parseAttributionChain(int32_t* pos, int32_t depth, bool* last,
                                     uint8_t numAnnotations) {
    std::optional<size_t> firstUidInChainIndex = mValues.size();
    const uint8_t numNodes = readNextValue<uint8_t>();

    if (numNodes > INT8_MAX) mValid = false;

    for (pos[1] = 1; pos[1] <= numNodes; pos[1]++) {
        last[1] = (pos[1] == numNodes);

        // parse uid
        pos[2] = 1;
        parseInt32(pos, /*depth=*/2, last, /*numAnnotations=*/0);

        // parse tag
        pos[2] = 2;
        last[2] = true;
        parseString(pos, /*depth=*/2, last, /*numAnnotations=*/0);
    }

    if (mValues.size() > (firstUidInChainIndex.value() + 1)) {
        // At least one node was successfully parsed.
        mAttributionChainStartIndex = firstUidInChainIndex;
        mAttributionChainEndIndex = mValues.size() - 1;
    } else {
        firstUidInChainIndex = std::nullopt;
        mValid = false;
    }

    if (mValid) {
        parseAnnotations(numAnnotations, /*numElements*/ std::nullopt, firstUidInChainIndex);
    }

    pos[1] = pos[2] = 1;
    last[1] = last[2] = false;
}

void LogEvent::parseArray(int32_t* pos, int32_t depth, bool* last, uint8_t numAnnotations) {
    const uint8_t numElements = readNextValue<uint8_t>();
    const uint8_t typeInfo = readNextValue<uint8_t>();
    const uint8_t typeId = getTypeId(typeInfo);

    if (numElements > INT8_MAX) mValid = false;

    for (pos[1] = 1; pos[1] <= numElements; pos[1]++) {
        last[1] = (pos[1] == numElements);

        // The top-level array is at depth 0, and all of its elements are at depth 1.
        // Once nested fields are supported, array elements will be at top-level depth + 1.

        switch (typeId) {
            case INT32_TYPE:
                parseInt32(pos, /*depth=*/1, last, /*numAnnotations=*/0);
                break;
            case INT64_TYPE:
                parseInt64(pos, /*depth=*/1, last, /*numAnnotations=*/0);
                break;
            case FLOAT_TYPE:
                parseFloat(pos, /*depth=*/1, last, /*numAnnotations=*/0);
                break;
            case BOOL_TYPE:
                parseBool(pos, /*depth=*/1, last, /*numAnnotations=*/0);
                break;
            case STRING_TYPE:
                parseString(pos, /*depth=*/1, last, /*numAnnotations=*/0);
                break;
            default:
                mValid = false;
                break;
        }
    }

    parseAnnotations(numAnnotations, numElements);

    pos[1] = 1;
    last[1] = false;
}

// Assumes that mValues is not empty
bool LogEvent::checkPreviousValueType(Type expected) const {
    return mValues[mValues.size() - 1].mValue.getType() == expected;
}

void LogEvent::parseIsUidAnnotation(uint8_t annotationType, std::optional<uint8_t> numElements) {
    // Need to set numElements if not an array.
    if (!numElements) {
        numElements = 1;
    }

    // If array is empty, skip uid parsing.
    if (numElements == 0 && annotationType == BOOL_TYPE) {
        readNextValue<uint8_t>();
        return;
    }

    // Allowed types: INT, repeated INT
    if (mValues.empty() || numElements > mValues.size() || !checkPreviousValueType(INT) ||
        annotationType != BOOL_TYPE) {
        VLOG("Atom ID %d error while parseIsUidAnnotation()", mTagId);
        mValid = false;
        return;
    }

    bool isUid = readNextValue<uint8_t>();
    if (isUid) {
        mNumUidFields += numElements.value();
    }

    for (int i = 1; i <= numElements; i++) {
        mValues[mValues.size() - i].mAnnotations.setUidField(isUid);
    }
}

void LogEvent::parseTruncateTimestampAnnotation(uint8_t annotationType) {
    if (!mValues.empty() || annotationType != BOOL_TYPE) {
        VLOG("Atom ID %d error while parseTruncateTimestampAnnotation()", mTagId);
        mValid = false;
        return;
    }

    mTruncateTimestamp = readNextValue<uint8_t>();
}

void LogEvent::parsePrimaryFieldAnnotation(uint8_t annotationType,
                                           std::optional<uint8_t> numElements,
                                           std::optional<size_t> firstUidInChainIndex) {
    // Allowed types: all types except for attribution chains and repeated fields.
    if (mValues.empty() || annotationType != BOOL_TYPE || firstUidInChainIndex || numElements) {
        VLOG("Atom ID %d error while parsePrimaryFieldAnnotation()", mTagId);
        mValid = false;
        return;
    }

    const bool primaryField = readNextValue<uint8_t>();
    mValues[mValues.size() - 1].mAnnotations.setPrimaryField(primaryField);
}

void LogEvent::parsePrimaryFieldFirstUidAnnotation(uint8_t annotationType,
                                                   std::optional<size_t> firstUidInChainIndex) {
    // Allowed types: attribution chains
    if (mValues.empty() || annotationType != BOOL_TYPE || !firstUidInChainIndex) {
        VLOG("Atom ID %d error while parsePrimaryFieldFirstUidAnnotation()", mTagId);
        mValid = false;
        return;
    }

    if (mValues.size() < firstUidInChainIndex.value() + 1) {  // AttributionChain is empty.
        VLOG("Atom ID %d error while parsePrimaryFieldFirstUidAnnotation()", mTagId);
        mValid = false;
        android_errorWriteLog(0x534e4554, "174485572");
        return;
    }

    const bool primaryField = readNextValue<uint8_t>();
    mValues[firstUidInChainIndex.value()].mAnnotations.setPrimaryField(primaryField);
}

void LogEvent::parseExclusiveStateAnnotation(uint8_t annotationType,
                                             std::optional<uint8_t> numElements) {
    // Allowed types: BOOL
    if (mValues.empty() || annotationType != BOOL_TYPE || !checkPreviousValueType(INT) ||
        numElements) {
        VLOG("Atom ID %d error while parseExclusiveStateAnnotation()", mTagId);
        mValid = false;
        return;
    }

    const bool exclusiveState = readNextValue<uint8_t>();
    mExclusiveStateFieldIndex = mValues.size() - 1;
    mValues[getExclusiveStateFieldIndex().value()].mAnnotations.setExclusiveState(exclusiveState);
}

void LogEvent::parseTriggerStateResetAnnotation(uint8_t annotationType,
                                                std::optional<uint8_t> numElements) {
    // Allowed types: INT
    if (mValues.empty() || annotationType != INT32_TYPE || !checkPreviousValueType(INT) ||
        numElements) {
        VLOG("Atom ID %d error while parseTriggerStateResetAnnotation()", mTagId);
        mValid = false;
        return;
    }

    mResetState = readNextValue<int32_t>();
}

void LogEvent::parseStateNestedAnnotation(uint8_t annotationType,
                                          std::optional<uint8_t> numElements) {
    // Allowed types: BOOL
    if (mValues.empty() || annotationType != BOOL_TYPE || !checkPreviousValueType(INT) ||
        numElements) {
        VLOG("Atom ID %d error while parseStateNestedAnnotation()", mTagId);
        mValid = false;
        return;
    }

    bool nested = readNextValue<uint8_t>();
    mValues[mValues.size() - 1].mAnnotations.setNested(nested);
}

void LogEvent::parseRestrictionCategoryAnnotation(uint8_t annotationType) {
    // Allowed types: INT, field value should be empty since this is atom-level annotation.
    if (!mValues.empty() || annotationType != INT32_TYPE) {
        mValid = false;
        return;
    }
    int value = readNextValue<int32_t>();
    // should be one of predefined category in StatsLog.java
    switch (value) {
        case ASTATSLOG_RESTRICTION_CATEGORY_DIAGNOSTIC:
        case ASTATSLOG_RESTRICTION_CATEGORY_SYSTEM_INTELLIGENCE:
        case ASTATSLOG_RESTRICTION_CATEGORY_AUTHENTICATION:
        case ASTATSLOG_RESTRICTION_CATEGORY_FRAUD_AND_ABUSE:
            break;
        default:
            mValid = false;
            return;
    }
    mRestrictionCategory = static_cast<StatsdRestrictionCategory>(value);
    return;
}

void LogEvent::parseFieldRestrictionAnnotation(uint8_t annotationType) {
    // Allowed types: BOOL
    if (mValues.empty() || annotationType != BOOL_TYPE) {
        mValid = false;
        return;
    }
    // Read the value so that the rest of the event is correctly parsed
    // TODO: store the field annotations once the metrics need to parse them.
    readNextValue<uint8_t>();
    return;
}

// firstUidInChainIndex is a default parameter that is only needed when parsing
// annotations for attribution chains.
// numElements is a default param that is only needed when parsing annotations for repeated fields
void LogEvent::parseAnnotations(uint8_t numAnnotations, std::optional<uint8_t> numElements,
                                std::optional<size_t> firstUidInChainIndex) {
    for (uint8_t i = 0; i < numAnnotations; i++) {
        uint8_t annotationId = readNextValue<uint8_t>();
        uint8_t annotationType = readNextValue<uint8_t>();

        switch (annotationId) {
            case ASTATSLOG_ANNOTATION_ID_IS_UID:
                parseIsUidAnnotation(annotationType, numElements);
                break;
            case ASTATSLOG_ANNOTATION_ID_TRUNCATE_TIMESTAMP:
                parseTruncateTimestampAnnotation(annotationType);
                break;
            case ASTATSLOG_ANNOTATION_ID_PRIMARY_FIELD:
                parsePrimaryFieldAnnotation(annotationType, numElements, firstUidInChainIndex);
                break;
            case ASTATSLOG_ANNOTATION_ID_PRIMARY_FIELD_FIRST_UID:
                parsePrimaryFieldFirstUidAnnotation(annotationType, firstUidInChainIndex);
                break;
            case ASTATSLOG_ANNOTATION_ID_EXCLUSIVE_STATE:
                parseExclusiveStateAnnotation(annotationType, numElements);
                break;
            case ASTATSLOG_ANNOTATION_ID_TRIGGER_STATE_RESET:
                parseTriggerStateResetAnnotation(annotationType, numElements);
                break;
            case ASTATSLOG_ANNOTATION_ID_STATE_NESTED:
                parseStateNestedAnnotation(annotationType, numElements);
                break;
            case ASTATSLOG_ANNOTATION_ID_RESTRICTION_CATEGORY:
                if (isAtLeastU()) {
                    parseRestrictionCategoryAnnotation(annotationType);
                } else {
                    mValid = false;
                }
                break;
            // Currently field restrictions are ignored, so we parse but do not store them.
            case ASTATSLOG_ANNOTATION_ID_FIELD_RESTRICTION_PERIPHERAL_DEVICE_INFO:
            case ASTATSLOG_ANNOTATION_ID_FIELD_RESTRICTION_APP_USAGE:
            case ASTATSLOG_ANNOTATION_ID_FIELD_RESTRICTION_APP_ACTIVITY:
            case ASTATSLOG_ANNOTATION_ID_FIELD_RESTRICTION_HEALTH_CONNECT:
            case ASTATSLOG_ANNOTATION_ID_FIELD_RESTRICTION_ACCESSIBILITY:
            case ASTATSLOG_ANNOTATION_ID_FIELD_RESTRICTION_SYSTEM_SEARCH:
            case ASTATSLOG_ANNOTATION_ID_FIELD_RESTRICTION_USER_ENGAGEMENT:
            case ASTATSLOG_ANNOTATION_ID_FIELD_RESTRICTION_AMBIENT_SENSING:
            case ASTATSLOG_ANNOTATION_ID_FIELD_RESTRICTION_DEMOGRAPHIC_CLASSIFICATION:
                if (isAtLeastU()) {
                    parseFieldRestrictionAnnotation(annotationType);
                } else {
                    mValid = false;
                }
                break;
            default:
                VLOG("Atom ID %d error while parseAnnotations() - wrong annotationId(%d)", mTagId,
                     annotationId);
                mValid = false;
                return;
        }
    }
}

LogEvent::BodyBufferInfo LogEvent::parseHeader(const uint8_t* buf, size_t len) {
    BodyBufferInfo bodyInfo;

    mParsedHeaderOnly = true;

    mBuf = buf;
    mRemainingLen = (uint32_t)len;

    // Beginning of buffer is OBJECT_TYPE | NUM_FIELDS | TIMESTAMP | ATOM_ID
    uint8_t typeInfo = readNextValue<uint8_t>();
    if (getTypeId(typeInfo) != OBJECT_TYPE) {
        mValid = false;
        mBuf = nullptr;
        return bodyInfo;
    }

    uint8_t numElements = readNextValue<uint8_t>();
    if (numElements < 2 || numElements > INT8_MAX) {
        mValid = false;
        mBuf = nullptr;
        return bodyInfo;
    }

    typeInfo = readNextValue<uint8_t>();
    if (getTypeId(typeInfo) != INT64_TYPE) {
        mValid = false;
        mBuf = nullptr;
        return bodyInfo;
    }
    mElapsedTimestampNs = readNextValue<int64_t>();
    numElements--;

    typeInfo = readNextValue<uint8_t>();
    if (getTypeId(typeInfo) != INT32_TYPE) {
        mValid = false;
        mBuf = nullptr;
        return bodyInfo;
    }
    mTagId = readNextValue<int32_t>();
    numElements--;

    parseAnnotations(getNumAnnotations(typeInfo));  // atom-level annotations

    bodyInfo.numElements = numElements;
    bodyInfo.buffer = mBuf;
    bodyInfo.bufferSize = mRemainingLen;

    mBuf = nullptr;
    return bodyInfo;
}

bool LogEvent::parseBody(const BodyBufferInfo& bodyInfo) {
    mParsedHeaderOnly = false;

    mBuf = bodyInfo.buffer;
    mRemainingLen = (uint32_t)bodyInfo.bufferSize;

    int32_t pos[] = {1, 1, 1};
    bool last[] = {false, false, false};

    // While this number is not guaranteed to be correct due to repeated fields and
    // attribution chains, it still positively affects performance and reduces the number
    // of vector buffer reallocations.
    mValues.reserve(bodyInfo.numElements);

    for (pos[0] = 1; pos[0] <= bodyInfo.numElements && mValid; pos[0]++) {
        last[0] = (pos[0] == bodyInfo.numElements);

        uint8_t typeInfo = readNextValue<uint8_t>();
        uint8_t typeId = getTypeId(typeInfo);

        switch (typeId) {
            case BOOL_TYPE:
                parseBool(pos, /*depth=*/0, last, getNumAnnotations(typeInfo));
                break;
            case INT32_TYPE:
                parseInt32(pos, /*depth=*/0, last, getNumAnnotations(typeInfo));
                break;
            case INT64_TYPE:
                parseInt64(pos, /*depth=*/0, last, getNumAnnotations(typeInfo));
                break;
            case FLOAT_TYPE:
                parseFloat(pos, /*depth=*/0, last, getNumAnnotations(typeInfo));
                break;
            case BYTE_ARRAY_TYPE:
                parseByteArray(pos, /*depth=*/0, last, getNumAnnotations(typeInfo));
                break;
            case STRING_TYPE:
                parseString(pos, /*depth=*/0, last, getNumAnnotations(typeInfo));
                break;
            case KEY_VALUE_PAIRS_TYPE:
                parseKeyValuePairs(pos, /*depth=*/0, last, getNumAnnotations(typeInfo));
                break;
            case ATTRIBUTION_CHAIN_TYPE:
                parseAttributionChain(pos, /*depth=*/0, last, getNumAnnotations(typeInfo));
                break;
            case LIST_TYPE:
                parseArray(pos, /*depth=*/0, last, getNumAnnotations(typeInfo));
                break;
            case ERROR_TYPE:
                /* mErrorBitmask =*/readNextValue<int32_t>();
                mValid = false;
                break;
            default:
                mValid = false;
                break;
        }
    }

    if (mRemainingLen != 0) mValid = false;
    mBuf = nullptr;
    return mValid;
}

// This parsing logic is tied to the encoding scheme used in StatsEvent.java and
// stats_event.c
bool LogEvent::parseBuffer(const uint8_t* buf, size_t len) {
    BodyBufferInfo bodyInfo = parseHeader(buf, len);

    // emphasize intention to parse the body, however atom data could be incomplete
    // if header/body parsing was failed due to invalid buffer content for example
    mParsedHeaderOnly = false;

    // early termination if header is invalid
    if (!mValid) {
        mBuf = nullptr;
        return false;
    }

    return parseBody(bodyInfo);
}

int64_t LogEvent::GetLong(size_t key, status_t* err) const {
    // TODO(b/110561208): encapsulate the magical operations in Field struct as static functions
    int field = getSimpleField(key);
    for (const auto& value : mValues) {
        if (value.mField.getField() == field) {
            if (value.mValue.getType() == LONG) {
                return value.mValue.long_value;
            } else if (value.mValue.getType() == INT) {
                return value.mValue.int_value;
            } else {
                *err = BAD_TYPE;
                return 0;
            }
        }
        if ((size_t)value.mField.getPosAtDepth(0) > key) {
            break;
        }
    }

    *err = BAD_INDEX;
    return 0;
}

int LogEvent::GetInt(size_t key, status_t* err) const {
    int field = getSimpleField(key);
    for (const auto& value : mValues) {
        if (value.mField.getField() == field) {
            if (value.mValue.getType() == INT) {
                return value.mValue.int_value;
            } else {
                *err = BAD_TYPE;
                return 0;
            }
        }
        if ((size_t)value.mField.getPosAtDepth(0) > key) {
            break;
        }
    }

    *err = BAD_INDEX;
    return 0;
}

const char* LogEvent::GetString(size_t key, status_t* err) const {
    int field = getSimpleField(key);
    for (const auto& value : mValues) {
        if (value.mField.getField() == field) {
            if (value.mValue.getType() == STRING) {
                return value.mValue.str_value.c_str();
            } else {
                *err = BAD_TYPE;
                return 0;
            }
        }
        if ((size_t)value.mField.getPosAtDepth(0) > key) {
            break;
        }
    }

    *err = BAD_INDEX;
    return NULL;
}

bool LogEvent::GetBool(size_t key, status_t* err) const {
    int field = getSimpleField(key);
    for (const auto& value : mValues) {
        if (value.mField.getField() == field) {
            if (value.mValue.getType() == INT) {
                return value.mValue.int_value != 0;
            } else if (value.mValue.getType() == LONG) {
                return value.mValue.long_value != 0;
            } else {
                *err = BAD_TYPE;
                return false;
            }
        }
        if ((size_t)value.mField.getPosAtDepth(0) > key) {
            break;
        }
    }

    *err = BAD_INDEX;
    return false;
}

float LogEvent::GetFloat(size_t key, status_t* err) const {
    int field = getSimpleField(key);
    for (const auto& value : mValues) {
        if (value.mField.getField() == field) {
            if (value.mValue.getType() == FLOAT) {
                return value.mValue.float_value;
            } else {
                *err = BAD_TYPE;
                return 0.0;
            }
        }
        if ((size_t)value.mField.getPosAtDepth(0) > key) {
            break;
        }
    }

    *err = BAD_INDEX;
    return 0.0;
}

std::vector<uint8_t> LogEvent::GetStorage(size_t key, status_t* err) const {
    int field = getSimpleField(key);
    for (const auto& value : mValues) {
        if (value.mField.getField() == field) {
            if (value.mValue.getType() == STORAGE) {
                return value.mValue.storage_value;
            } else {
                *err = BAD_TYPE;
                return vector<uint8_t>();
            }
        }
        if ((size_t)value.mField.getPosAtDepth(0) > key) {
            break;
        }
    }

    *err = BAD_INDEX;
    return vector<uint8_t>();
}

string LogEvent::ToString() const {
    string result;
    result += StringPrintf("{ uid(%d) %lld %lld (%d)", mLogUid, (long long)mLogdTimestampNs,
                           (long long)mElapsedTimestampNs, mTagId);
    string annotations;
    if (mTruncateTimestamp) {
        annotations = "TRUNCATE_TS";
    }
    if (mResetState != -1) {
        annotations += annotations.size() ? ", RESET_STATE" : "RESET_STATE";
    }
    if (annotations.size()) {
        result += " [" + annotations + "] ";
    }

    if (isParsedHeaderOnly()) {
        result += " ParsedHeaderOnly }";
        return result;
    }

    for (const auto& value : mValues) {
        result += StringPrintf("%#x", value.mField.getField()) + "->" + value.mValue.toString();
        result += value.mAnnotations.toString() + " ";
    }
    result += " }";
    return result;
}

void LogEvent::ToProto(ProtoOutputStream& protoOutput) const {
    set<int32_t> usedUids;
    writeFieldValueTreeToStream(mTagId, getValues(), {}, usedUids, &protoOutput);
}

bool LogEvent::hasAttributionChain(std::pair<size_t, size_t>* indexRange) const {
    if (!mAttributionChainStartIndex || !mAttributionChainEndIndex) {
        return false;
    }

    if (nullptr != indexRange) {
        indexRange->first = mAttributionChainStartIndex.value();
        indexRange->second = mAttributionChainEndIndex.value();
    }

    return true;
}

void writeExperimentIdsToProto(const std::vector<int64_t>& experimentIds,
                               std::vector<uint8_t>* protoOut) {
    ProtoOutputStream proto;
    for (const auto& expId : experimentIds) {
        proto.write(FIELD_TYPE_INT64 | FIELD_COUNT_REPEATED | FIELD_ID_EXPERIMENT_ID,
                    (long long)expId);
    }

    protoOut->resize(proto.size());
    size_t pos = 0;
    sp<ProtoReader> reader = proto.data();
    while (reader->readBuffer() != NULL) {
        size_t toRead = reader->currentToRead();
        std::memcpy(protoOut->data() + pos, reader->readBuffer(), toRead);
        pos += toRead;
        reader->move(toRead);
    }
}

}  // namespace statsd
}  // namespace os
}  // namespace android