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

// This file is copied from
// hardware/interfaces/wifi/1.0/vts/functional/wifi_hidl_call_util.h
// Please make sure these two file are consistent.

#pragma once

#include <functional>
#include <tuple>
#include <type_traits>
#include <utility>

namespace {
namespace detail {
template <typename>
struct functionArgSaver;

// Provides a std::function that takes one argument, and a buffer
// wherein the function will store its argument. The buffer has
// the same type as the argument, but with const and reference
// modifiers removed.
template <typename ArgT>
struct functionArgSaver<std::function<void(ArgT)>> final {
    using StorageT = typename std::remove_const<
        typename std::remove_reference<ArgT>::type>::type;

    std::function<void(ArgT)> saveArgs = [this](ArgT arg) {
        this->saved_values = arg;
    };

    StorageT saved_values;
};

// Provides a std::function that takes two arguments, and a buffer
// wherein the function will store its arguments. The buffer is a
// std::pair, whose elements have the same types as the arguments
// (but with const and reference modifiers removed).
template <typename Arg1T, typename Arg2T>
struct functionArgSaver<std::function<void(Arg1T, Arg2T)>> final {
    using StorageT =
        std::pair<typename std::remove_const<
                      typename std::remove_reference<Arg1T>::type>::type,
                  typename std::remove_const<
                      typename std::remove_reference<Arg2T>::type>::type>;

    std::function<void(Arg1T, Arg2T)> saveArgs = [this](Arg1T arg1,
                                                        Arg2T arg2) {
        this->saved_values = {arg1, arg2};
    };

    StorageT saved_values;
};

// Provides a std::function that takes three or more arguments, and a
// buffer wherein the function will store its arguments. The buffer is a
// std::tuple whose elements have the same types as the arguments (but
// with const and reference modifiers removed).
template <typename... ArgT>
struct functionArgSaver<std::function<void(ArgT...)>> final {
    using StorageT = std::tuple<typename std::remove_const<
        typename std::remove_reference<ArgT>::type>::type...>;

    std::function<void(ArgT...)> saveArgs = [this](ArgT... arg) {
        this->saved_values = {arg...};
    };

    StorageT saved_values;
};

// Invokes |method| on |object|, providing |method| a CallbackT as the
// final argument. Returns a copy of the parameters that |method| provided
// to CallbackT. (The parameters are returned by value.)
template <typename CallbackT, typename MethodT, typename ObjectT,
          typename... ArgT>
typename functionArgSaver<CallbackT>::StorageT invokeMethod(
    MethodT method, ObjectT object, ArgT&&... methodArg) {
    functionArgSaver<CallbackT> result_buffer;
    const auto& res = ((*object).*method)(std::forward<ArgT>(methodArg)...,
                                          result_buffer.saveArgs);
    EXPECT_TRUE(res.isOk());
    return result_buffer.saved_values;
}

// Invokes |void method| on |object| without arguments.
template <typename MethodT, typename ObjectT>
void invokeVoidMethodWithoutArguments(MethodT method, ObjectT object) {
    const auto& res = ((*object).*method)();
    EXPECT_TRUE(res.isOk());
}

}  // namespace detail
}  // namespace

// Invokes |method| on |strong_pointer|, passing provided arguments through to
// |method|.
//
// Returns either:
// - A copy of the result callback parameter (for callbacks with a single
//   parameter), OR
// - A pair containing a copy of the result callback parameters (for callbacks
//   with two parameters), OR
// - A tuple containing a copy of the result callback paramters (for callbacks
//   with three or more parameters).
//
// Example usage:
//   EXPECT_EQ(HostapdStatusCode::SUCCESS,
//       HIDL_INVOKE(strong_pointer, methodReturningHostapdStatus).code);
//   EXPECT_EQ(HostapdStatusCode::SUCCESS,
//       HIDL_INVOKE(strong_pointer, methodReturningHostapdStatusAndOneMore)
//         .first.code);
//   EXPECT_EQ(HostapdStatusCode::SUCCESS, std::get<0>(
//       HIDL_INVOKE(strong_pointer, methodReturningHostapdStatusAndTwoMore))
//         .code);
#define HIDL_INVOKE(strong_pointer, method, ...)                              \
    (detail::invokeMethod<                                                    \
        std::remove_reference<decltype(*strong_pointer)>::type::method##_cb>( \
        &std::remove_reference<decltype(*strong_pointer)>::type::method,      \
        strong_pointer, ##__VA_ARGS__))

// Invokes |void method| on |strong_pointer| without arguments.
#define HIDL_INVOKE_VOID_WITHOUT_ARGUMENTS(strong_pointer, method)       \
    (detail::invokeVoidMethodWithoutArguments(                           \
        &std::remove_reference<decltype(*strong_pointer)>::type::method, \
        strong_pointer))
