// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/local_aggregation_1.1/aggregation_procedures/select_first_aggregation_procedure.h"

#include "src/lib/statusor/status_macros.h"
#include "src/pb/observation.pb.h"
#include "src/registry/packed_event_codes.h"

namespace cobalt::local_aggregation {

SelectFirstAggregationProcedure::SelectFirstAggregationProcedure(const MetricDefinition &metric,
                                                                 const ReportDefinition &report)
    : AggregationProcedure(metric, report) {
  // Record only the first event vector that is logged for each aggregation period.
  SetEventCodeBufferMax(1);
}

void SelectFirstAggregationProcedure::UpdateAggregateData(
    const logger::EventRecord & /*event_record*/, AggregateData *aggregate_data,
    EventCodeAggregate * /*aggregate*/) {
  aggregate_data->set_at_least_once(true);
}

std::string SelectFirstAggregationProcedure::DebugString() const { return "SELECT_FIRST"; }

lib::statusor::StatusOr<std::unique_ptr<Observation>>
SelectFirstAggregationProcedure::GenerateSingleObservation(
    const logger::Encoder *encoder, const std::vector<EventCodeAggregate *> & /*aggregates*/,
    const std::set<uint32_t> &event_vectors) {
  std::vector<std::tuple<std::vector<uint32_t>, int64_t>> data;
  data.reserve(event_vectors.size());

  for (const auto &packed_event_vector : event_vectors) {
    auto event_vector = config::UnpackEventCodes(packed_event_vector);
    data.emplace_back(std::make_tuple(event_vector, 1));
  }

  if (data.empty()) {
    return {nullptr};
  }

  return encoder->EncodeIntegerObservation(data);
}

}  // namespace cobalt::local_aggregation