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

#ifndef RUNTIME_PROBE_PROBE_FUNCTION_ARGUMENT_H_
#define RUNTIME_PROBE_PROBE_FUNCTION_ARGUMENT_H_

#include <memory>
#include <vector>

#include "base/values.h"

namespace runtime_probe {

// To know how to define an argument parser and use it in your probe function,
// please check "functions/shell.h" as an example.  It should be well commented.
//
// Currently, we only supports the following types of arguments:
//   - std::string
//   - int
//   - bool
//   - double
//   - std::vector<std::string>
//   - std::vector<std::unique_ptr<ProbeFunction>>
//
// Arguments can have default value, except for
// std::vector<std::unique_ptr<ProbeFunction>>.

class ProbeFunction;

template <typename T>
bool ParseArgumentInternal(const char* function_name,
                           const char* member_name,
                           T* member,
                           const base::Value& value);

template <typename T>
bool ParseArgument(const char* function_name,
                   const char* member_name,
                   T* member,
                   const base::Value& value) {
  if (value.is_dict()) {
    auto* real_value = value.FindKey(member_name);
    if (!real_value) {
      LOG(ERROR) << function_name << ": `" << member_name << "` not found";
      return false;
    }
    return ParseArgumentInternal(function_name, member_name, member,
                                 *real_value);
  }
  return ParseArgumentInternal(function_name, member_name, member, value);
}

template <typename T>
bool ParseArgument(const char* function_name,
                   const char* member_name,
                   T* member,
                   const base::Value& value,
                   const T&& default_value) {
  CHECK(value.is_dict());
  if (!value.FindKey(member_name)) {
    *member = default_value;
    return true;
  }

  return ParseArgument(function_name, member_name, member, value);
}

template <>
bool ParseArgument<std::vector<std::unique_ptr<ProbeFunction>>>(
    const char* function_name,
    const char* member_name,
    std::vector<std::unique_ptr<ProbeFunction>>* member,
    const base::Value& dict_value,
    const std::vector<std::unique_ptr<ProbeFunction>>&& default_value) = delete;

// We assume that |function_name|, |instance|, |dict_value| are available in the
// scope this macro is called.  See `functions/shell.h` about how this macro is
// used.
#define PARSE_ARGUMENT(member_name, ...)                                \
  ParseArgument(function_name, #member_name, &instance->member_name##_, \
                dict_value, ##__VA_ARGS__)

}  // namespace runtime_probe

#endif  // RUNTIME_PROBE_PROBE_FUNCTION_ARGUMENT_H_