/*
 * Copyright (C) 2018 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 DEBUG false  // STOPSHIP if true
#include "Log.h"

#include "StatsPullerManagerImpl.h"
#include "field_util.h"
#include "puller_util.h"
#include "statslog.h"

namespace android {
namespace os {
namespace statsd {

using std::map;
using std::shared_ptr;
using std::vector;

DimensionsValue* getFieldValue(shared_ptr<LogEvent> event, int tagId, int fieldNum) {
  Field field;
  buildSimpleAtomField(tagId, fieldNum, &field);
  return event->findFieldValueOrNull(field);
}

bool shouldMerge(shared_ptr<LogEvent>& lhs, shared_ptr<LogEvent>& rhs,
                 const vector<int>& nonAdditiveFields, int tagId) {
  for (int f : nonAdditiveFields) {
    DimensionsValue* lValue = getFieldValue(lhs, tagId, f);
    DimensionsValue* rValue = getFieldValue(rhs, tagId, f);
    if (!compareDimensionsValue(*lValue, *rValue)) {
      return false;
    }
  }
  return true;
}

// merge rhs to lhs
void mergeEvent(shared_ptr<LogEvent>& lhs, shared_ptr<LogEvent>& rhs,
                const vector<int>& additiveFields, int tagId) {
  for (int f : additiveFields) {
    DimensionsValue* lValue = getFieldValue(lhs, tagId, f);
    DimensionsValue* rValue = getFieldValue(rhs, tagId, f);
    if (lValue->has_value_int()) {
      lValue->set_value_int(lValue->value_int() + rValue->value_int());
    } else if (lValue->has_value_long()) {
      lValue->set_value_long(lValue->value_long() + rValue->value_long());
    }
  }
}

// process all data and merge isolated with host if necessary
void mergeIsolatedUidsToHostUid(vector<shared_ptr<LogEvent>>& data,
                                const sp<UidMap>& uidMap, int tagId) {
  if (StatsPullerManagerImpl::kAllPullAtomInfo.find(tagId) ==
      StatsPullerManagerImpl::kAllPullAtomInfo.end()) {
    VLOG("Unknown pull atom id %d", tagId);
    return;
  }
  if (android::util::kAtomsWithUidField.find(tagId) ==
      android::util::kAtomsWithUidField.end()) {
    VLOG("No uid to merge for atom %d", tagId);
    return;
  }
  const vector<int>& additiveFields =
      StatsPullerManagerImpl::kAllPullAtomInfo.find(tagId)
          ->second.additiveFields;
  const vector<int>& nonAdditiveFields =
      StatsPullerManagerImpl::kAllPullAtomInfo.find(tagId)
          ->second.nonAdditiveFields;

  // map of host uid to isolated uid data index in the original vector.
  // because of non additive fields, there could be multiple of them that can't
  // be merged into one
  map<int, vector<int>> hostToIsolated;
  // map of host uid to their position in the original vector
  map<int, vector<int>> hostPosition;
  vector<int> isolatedUidPos;
  // all uids in the original vector
  vector<int> allUids;
  for (size_t i = 0; i < data.size(); i++) {
    // uid field is always first primitive filed, if present
    DimensionsValue* uidField = getFieldValue(data[i], tagId, 1);
    if (!uidField) {
      VLOG("Bad data for %d, %s", tagId, data[i]->ToString().c_str());
      return;
    }
    int uid = uidField->value_int();
    allUids.push_back(uid);
    const int hostUid = uidMap->getHostUidOrSelf(uid);
    if (hostUid != uid) {
      uidField->set_value_int(hostUid);
      hostToIsolated[hostUid].push_back(i);
      isolatedUidPos.push_back(i);
    }
  }
  vector<shared_ptr<LogEvent>> mergedData;
  for (size_t i = 0; i < allUids.size(); i++) {
    if (hostToIsolated.find(allUids[i]) != hostToIsolated.end()) {
      hostPosition[allUids[i]].push_back(i);
    } else if (std::find(isolatedUidPos.begin(), isolatedUidPos.end(), i) != isolatedUidPos.end()) {
      continue;
    } else {
      mergedData.push_back(data[i]);
    }
  }
  for (auto iter = hostToIsolated.begin(); iter != hostToIsolated.end();
       iter++) {
    int uid = iter->first;
    vector<int>& isolated = hostToIsolated[uid];
    vector<int> toBeMerged;
    toBeMerged.insert(toBeMerged.begin(), isolated.begin(), isolated.end());
    if (hostPosition.find(uid) != hostPosition.end()) {
      vector<int>& host = hostPosition[uid];
      toBeMerged.insert(toBeMerged.end(), host.begin(), host.end());
    }
    vector<bool> used(toBeMerged.size());
    for (size_t i = 0; i < toBeMerged.size(); i++) {
      if (used[i] == true) {
        continue;
      }
      for (size_t j = i + 1; j < toBeMerged.size(); j++) {
        shared_ptr<LogEvent>& lhs = data[toBeMerged[i]];
        shared_ptr<LogEvent>& rhs = data[toBeMerged[j]];
        if (shouldMerge(lhs, rhs, nonAdditiveFields, tagId)) {
          mergeEvent(lhs, rhs, additiveFields, tagId);
          used[j] = true;
        }
      }
    }
    for (size_t i = 0; i < toBeMerged.size(); i++) {
      if (used[i] == false) {
      mergedData.push_back(data[i]);
    }
    }
  }
  data.clear();
  data = mergedData;
}

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