/*
 * 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.
 */

#include "Log.h"

#include "frameworks/base/cmds/statsd/src/statsd_config.pb.h"
#include "frameworks/base/cmds/statsd/src/statsd_internal.pb.h"
#include "dimension.h"


namespace android {
namespace os {
namespace statsd {

const DimensionsValue* getSingleLeafValue(const DimensionsValue* value) {
    if (value->value_case() == DimensionsValue::ValueCase::kValueTuple) {
        return getSingleLeafValue(&value->value_tuple().dimensions_value(0));
    } else {
        return value;
    }
}

DimensionsValue getSingleLeafValue(const DimensionsValue& value) {
    const DimensionsValue* leafValue = getSingleLeafValue(&value);
    return *leafValue;
}

void appendLeafNodeToTree(const Field& field,
                            const DimensionsValue& value,
                            DimensionsValue* parentValue) {
    if (field.child_size() <= 0) {
        *parentValue = value;
        parentValue->set_field(field.field());
        return;
    }
    parentValue->set_field(field.field());
    int idx = -1;
    for (int i = 0; i < parentValue->mutable_value_tuple()->dimensions_value_size(); ++i) {
        if (parentValue->mutable_value_tuple()->dimensions_value(i).field() ==
                field.child(0).field()) {
            idx = i;
        }
    }
    if (idx < 0) {
        parentValue->mutable_value_tuple()->add_dimensions_value();
        idx = parentValue->mutable_value_tuple()->dimensions_value_size() - 1;
    }
    appendLeafNodeToTree(
        field.child(0), value,
        parentValue->mutable_value_tuple()->mutable_dimensions_value(idx));
}

void appendLeafNodeToTrees(const Field& field,
                           const DimensionsValue& node,
                           std::vector<DimensionsValue>* rootTrees) {
    if (rootTrees == nullptr) {
        return;
    }
    if (rootTrees->empty()) {
        DimensionsValue tree;
        appendLeafNodeToTree(field, node, &tree);
        rootTrees->push_back(tree);
    } else {
        for (size_t i = 0; i < rootTrees->size(); ++i) {
            appendLeafNodeToTree(field, node, &rootTrees->at(i));
        }
    }
}

namespace {

void findDimensionsValues(
       const FieldValueMap& fieldValueMap,
       const FieldMatcher& matcher,
       Field* rootField,
       Field* leafField,
       std::vector<DimensionsValue>* rootDimensionsValues);

void findNonRepeatedDimensionsValues(
       const FieldValueMap& fieldValueMap,
       const FieldMatcher& matcher,
       Field* rootField,
       Field* leafField,
       std::vector<DimensionsValue>* rootValues) {
    if (matcher.child_size() > 0) {
        Field* newLeafField = leafField->add_child();
        for (const auto& childMatcher : matcher.child()) {
          newLeafField->set_field(childMatcher.field());
          findDimensionsValues(fieldValueMap, childMatcher, rootField, newLeafField, rootValues);
        }
        leafField->clear_child();
    } else {
        auto ret = fieldValueMap.equal_range(*rootField);
        int found = 0;
        for (auto it = ret.first; it != ret.second; ++it) {
            found++;
        }
        // Not found.
        if (found <= 0) {
            return;
        }
        if (found > 1) {
            ALOGE("Found multiple values for optional field.");
            return;
        }
        appendLeafNodeToTrees(*rootField, ret.first->second, rootValues);
    }
}

void findRepeatedDimensionsValues(const FieldValueMap& fieldValueMap,
                                  const FieldMatcher& matcher,
                                  Field* rootField,
                                  Field* leafField,
                                  std::vector<DimensionsValue>* rootValues) {
    if (matcher.position() == Position::FIRST) {
        leafField->set_position_index(0);
        findNonRepeatedDimensionsValues(fieldValueMap, matcher, rootField, leafField, rootValues);
        leafField->clear_position_index();
    } else {
        auto itLower = fieldValueMap.lower_bound(*rootField);
        if (itLower == fieldValueMap.end()) {
            return;
        }
        const int leafFieldNum = leafField->field();
        leafField->set_field(leafFieldNum + 1);
        auto itUpper = fieldValueMap.lower_bound(*rootField);
        // Resets the field number.
        leafField->set_field(leafFieldNum);

        switch (matcher.position()) {
             case Position::LAST:
                 {
                     itUpper--;
                     if (itUpper != fieldValueMap.end()) {
                         int last_index = getPositionByReferenceField(*rootField, itUpper->first);
                         if (last_index < 0) {
                            return;
                         }
                         leafField->set_position_index(last_index);
                         findNonRepeatedDimensionsValues(
                            fieldValueMap, matcher, rootField, leafField, rootValues);
                         leafField->clear_position_index();
                     }
                 }
                 break;
             case Position::ANY:
                 {
                    std::set<int> indexes;
                    for (auto it = itLower; it != itUpper; ++it) {
                        int index = getPositionByReferenceField(*rootField, it->first);
                        if (index >= 0) {
                            indexes.insert(index);
                        }
                    }
                    if (!indexes.empty()) {
                        std::vector<DimensionsValue> allValues;
                        for (const int index : indexes) {
                             leafField->set_position_index(index);
                             std::vector<DimensionsValue> newValues = *rootValues;
                             findNonRepeatedDimensionsValues(
                                fieldValueMap, matcher, rootField, leafField, &newValues);
                             allValues.insert(allValues.end(), newValues.begin(), newValues.end());
                             leafField->clear_position_index();
                        }
                        rootValues->clear();
                        rootValues->insert(rootValues->end(), allValues.begin(), allValues.end());
                    }
                 }
                 break;
             default:
                break;
         }
    }
}

void findDimensionsValues(
       const FieldValueMap& fieldValueMap,
       const FieldMatcher& matcher,
       Field* rootField,
       Field* leafField,
       std::vector<DimensionsValue>* rootDimensionsValues) {
    if (!matcher.has_position()) {
        findNonRepeatedDimensionsValues(fieldValueMap, matcher, rootField, leafField,
                                        rootDimensionsValues);
    } else {
        findRepeatedDimensionsValues(fieldValueMap, matcher, rootField, leafField,
                                     rootDimensionsValues);
    }
}

} // namespace

void findDimensionsValues(
       const FieldValueMap& fieldValueMap,
       const FieldMatcher& matcher,
       std::vector<DimensionsValue>* rootDimensionsValues) {
    Field rootField;
    buildSimpleAtomField(matcher.field(), &rootField);
    findDimensionsValues(fieldValueMap, matcher, &rootField, &rootField, rootDimensionsValues);
}

void buildSimpleAtomFieldMatcher(const int tagId, FieldMatcher* matcher) {
    matcher->set_field(tagId);
}

void buildSimpleAtomFieldMatcher(const int tagId, const int fieldNum, FieldMatcher* matcher) {
    matcher->set_field(tagId);
    matcher->add_child()->set_field(fieldNum);
}

constexpr int ATTRIBUTION_FIELD_NUM_IN_ATOM_PROTO = 1;
constexpr int UID_FIELD_NUM_IN_ATTRIBUTION_NODE_PROTO = 1;
constexpr int TAG_FIELD_NUM_IN_ATTRIBUTION_NODE_PROTO = 2;

void buildAttributionUidFieldMatcher(const int tagId, const Position position,
                                     FieldMatcher* matcher) {
    matcher->set_field(tagId);
    auto child = matcher->add_child();
    child->set_field(ATTRIBUTION_FIELD_NUM_IN_ATOM_PROTO);
    child->set_position(position);
    child->add_child()->set_field(UID_FIELD_NUM_IN_ATTRIBUTION_NODE_PROTO);
}

void buildAttributionTagFieldMatcher(const int tagId, const Position position,
                                     FieldMatcher* matcher) {
    matcher->set_field(tagId);
    FieldMatcher* child = matcher->add_child();
    child->set_field(ATTRIBUTION_FIELD_NUM_IN_ATOM_PROTO);
    child->set_position(position);
    child->add_child()->set_field(TAG_FIELD_NUM_IN_ATTRIBUTION_NODE_PROTO);
}

void buildAttributionFieldMatcher(const int tagId, const Position position, FieldMatcher* matcher) {
    matcher->set_field(tagId);
    FieldMatcher* child = matcher->add_child();
    child->set_field(ATTRIBUTION_FIELD_NUM_IN_ATOM_PROTO);
    child->set_position(position);
    child->add_child()->set_field(UID_FIELD_NUM_IN_ATTRIBUTION_NODE_PROTO);
    child->add_child()->set_field(TAG_FIELD_NUM_IN_ATTRIBUTION_NODE_PROTO);
}

void DimensionsValueToString(const DimensionsValue& value, std::string *flattened) {
    *flattened += std::to_string(value.field());
    *flattened += ":";
    switch (value.value_case()) {
        case DimensionsValue::ValueCase::kValueStr:
            *flattened += value.value_str();
            break;
        case DimensionsValue::ValueCase::kValueInt:
            *flattened += std::to_string(value.value_int());
            break;
        case DimensionsValue::ValueCase::kValueLong:
            *flattened += std::to_string(value.value_long());
            break;
        case DimensionsValue::ValueCase::kValueBool:
            *flattened += std::to_string(value.value_bool());
            break;
        case DimensionsValue::ValueCase::kValueFloat:
            *flattened += std::to_string(value.value_float());
            break;
        case DimensionsValue::ValueCase::kValueTuple:
            {
                *flattened += "{";
                for (int i = 0; i < value.value_tuple().dimensions_value_size(); ++i) {
                    DimensionsValueToString(value.value_tuple().dimensions_value(i), flattened);
                    *flattened += "|";
                }
                *flattened += "}";
            }
            break;
        case DimensionsValue::ValueCase::VALUE_NOT_SET:
            break;
    }
}

std::string DimensionsValueToString(const DimensionsValue& value) {
    std::string flatten;
    DimensionsValueToString(value, &flatten);
    return flatten;
}

bool IsSubDimension(const DimensionsValue& dimension, const DimensionsValue& sub) {
    if (dimension.field() != sub.field()) {
        return false;
    }
    if (dimension.value_case() != sub.value_case()) {
        return false;
    }
    switch (dimension.value_case()) {
        case DimensionsValue::ValueCase::kValueStr:
            return dimension.value_str() == sub.value_str();
        case DimensionsValue::ValueCase::kValueInt:
            return dimension.value_int() == sub.value_int();
        case DimensionsValue::ValueCase::kValueLong:
            return dimension.value_long() == sub.value_long();
        case DimensionsValue::ValueCase::kValueBool:
            return dimension.value_bool() == sub.value_bool();
        case DimensionsValue::ValueCase::kValueFloat:
            return dimension.value_float() == sub.value_float();
        case DimensionsValue::ValueCase::kValueTuple: {
            if (dimension.value_tuple().dimensions_value_size() <
                sub.value_tuple().dimensions_value_size()) {
                return false;
            }
            bool allSub = true;
            for (int i = 0; allSub && i < sub.value_tuple().dimensions_value_size(); ++i) {
                bool isSub = false;
                for (int j = 0; !isSub &&
                        j < dimension.value_tuple().dimensions_value_size(); ++j) {
                    isSub |= IsSubDimension(dimension.value_tuple().dimensions_value(j),
                                            sub.value_tuple().dimensions_value(i));
                }
                allSub &= isSub;
            }
            return allSub;
        }
        break;
        case DimensionsValue::ValueCase::VALUE_NOT_SET:
            return false;
        default:
            return false;
    }
}

long getLongFromDimenValue(const DimensionsValue& dimensionValue) {
    switch (dimensionValue.value_case()) {
        case DimensionsValue::ValueCase::kValueInt:
            return dimensionValue.value_int();
        case DimensionsValue::ValueCase::kValueLong:
            return dimensionValue.value_long();
        case DimensionsValue::ValueCase::kValueBool:
            return dimensionValue.value_bool() ? 1 : 0;
        case DimensionsValue::ValueCase::kValueFloat:
            return (int64_t)dimensionValue.value_float();
        case DimensionsValue::ValueCase::kValueTuple:
        case DimensionsValue::ValueCase::kValueStr:
        case DimensionsValue::ValueCase::VALUE_NOT_SET:
            return 0;
    }
}

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