// Copyright 2020 The Pigweed Authors
//
// 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
//
//     https://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.
#pragma once

#include <tuple>
#include <type_traits>

#include "gtest/gtest.h"
#include "pw_rpc/internal/packet.h"
#include "pw_rpc/raw/internal/method.h"

namespace pw::rpc::internal {

template <typename...>
struct MatchesTypes {};

// This class tests Method implementation classes and MethodTraits
// specializations. It verifies that they provide the expected functions and
// that they correctly identify and construct the various method types.
//
// The TestService class must inherit from Service and provide the following
// methods with valid signatures for RPCs:
//
//   - Unary: synchronous unary RPC member function
//   - StaticUnary: synchronous unary RPC static member function
//   - AsyncUnary: asynchronous unary RPC member function
//   - StaticAsyncUnary: asynchronous unary RPC static member function
//   - ServerStreaming: server streaming RPC member function
//   - StaticServerStreaming: server streaming static RPC member function
//   - ClientStreaming: client streaming RPC member function
//   - StaticClientStreaming: client streaming static RPC member function
//   - BidirectionalStreaming: bidirectional streaming RPC member function
//   - StaticBidirectionalStreaming: bidirectional streaming static RPC
//         member function
//
template <typename MethodImpl, typename TestService>
class MethodImplTests {
 public:
  template <typename... ExtraTypes, typename... CreationArgs>
  constexpr bool Pass(
      const MatchesTypes<ExtraTypes...>& = {},
      const std::tuple<CreationArgs...>& creation_args = {}) const {
    return Matches<ExtraTypes...>().Pass() && Type().Pass() &&
           Creation().Pass(creation_args);
  }

 private:
  template <typename... ExtraTypes>
  struct Matches {
    constexpr bool Pass() const { return true; }

    // Test that the matches() function matches valid signatures.
    static_assert(
        MethodImpl::template matches<&TestService::Unary, ExtraTypes...>());
    static_assert(MethodImpl::template matches<&TestService::StaticUnary,
                                               ExtraTypes...>());

    static_assert(MethodImpl::template matches<&TestService::AsyncUnary,
                                               ExtraTypes...>());
    static_assert(MethodImpl::template matches<&TestService::StaticAsyncUnary,
                                               ExtraTypes...>());

    static_assert(MethodImpl::template matches<&TestService::ServerStreaming,
                                               ExtraTypes...>());
    static_assert(
        MethodImpl::template matches<&TestService::StaticServerStreaming,
                                     ExtraTypes...>());

    static_assert(MethodImpl::template matches<&TestService::ClientStreaming,
                                               ExtraTypes...>());
    static_assert(
        MethodImpl::template matches<&TestService::StaticClientStreaming,
                                     ExtraTypes...>());

    static_assert(
        MethodImpl::template matches<&TestService::BidirectionalStreaming,
                                     ExtraTypes...>());
    static_assert(
        MethodImpl::template matches<&TestService::StaticBidirectionalStreaming,
                                     ExtraTypes...>());

    // Test that the matches() function does not match the wrong method type.
    static_assert(!MethodImpl::template matches<&TestService::UnaryWrongArg,
                                                ExtraTypes...>());
    static_assert(
        !MethodImpl::template matches<&TestService::StaticUnaryVoidReturn,
                                      ExtraTypes...>());

    static_assert(
        !MethodImpl::template matches<&TestService::ServerStreamingBadReturn,
                                      ExtraTypes...>());
    static_assert(!MethodImpl::template matches<
                  &TestService::StaticServerStreamingMissingArg,
                  ExtraTypes...>());

    static_assert(
        !MethodImpl::template matches<&TestService::ClientStreamingBadReturn,
                                      ExtraTypes...>());
    static_assert(!MethodImpl::template matches<
                  &TestService::StaticClientStreamingMissingArg,
                  ExtraTypes...>());

    static_assert(!MethodImpl::template matches<
                  &TestService::BidirectionalStreamingBadReturn,
                  ExtraTypes...>());
    static_assert(!MethodImpl::template matches<
                  &TestService::StaticBidirectionalStreamingMissingArg,
                  ExtraTypes...>());
  };

  // Check that MethodTraits resolves to the correct value for kType.
  struct Type {
    constexpr bool Pass() const { return true; }

    // Don't check kSynchronous for Unary since not all method implementations
    // support synchronous unary.
    static_assert(MethodTraits<decltype(&TestService::Unary)>::kType ==
                  MethodType::kUnary);
    static_assert(MethodTraits<decltype(&TestService::StaticUnary)>::kType ==
                  MethodType::kUnary);
    static_assert(MethodTraits<decltype(&TestService::AsyncUnary)>::kType ==
                  MethodType::kUnary);
    static_assert(
        !MethodTraits<decltype(&TestService::AsyncUnary)>::kSynchronous);
    static_assert(
        MethodTraits<decltype(&TestService::StaticAsyncUnary)>::kType ==
        MethodType::kUnary);
    static_assert(
        !MethodTraits<decltype(&TestService::StaticAsyncUnary)>::kSynchronous);

    static_assert(
        MethodTraits<decltype(&TestService::ServerStreaming)>::kType ==
        MethodType::kServerStreaming);
    static_assert(
        MethodTraits<decltype(&TestService::StaticServerStreaming)>::kType ==
        MethodType::kServerStreaming);

    static_assert(
        MethodTraits<decltype(&TestService::ClientStreaming)>::kType ==
        MethodType::kClientStreaming);
    static_assert(
        MethodTraits<decltype(&TestService::StaticClientStreaming)>::kType ==
        MethodType::kClientStreaming);

    static_assert(
        MethodTraits<decltype(&TestService::BidirectionalStreaming)>::kType ==
        MethodType::kBidirectionalStreaming);
    static_assert(
        MethodTraits<
            decltype(&TestService::StaticBidirectionalStreaming)>::kType ==
        MethodType::kBidirectionalStreaming);
  };

  // Test method creation.
  class Creation {
   public:
    template <typename... Args>
    constexpr bool Pass(const std::tuple<Args...>& args) const {
      return AsyncUnaryMethod(args).id() == 3 &&
             StaticAsyncUnaryMethod(args).id() == 4 &&
             ServerStreamingMethod(args).id() == 5 &&
             StaticServerStreamingMethod(args).id() == 6 &&
             ClientStreamingMethod(args).id() == 7 &&
             StaticClientStreamingMethod(args).id() == 8 &&
             BidirectionalStreamingMethod(args).id() == 9 &&
             StaticBidirectionalStreamingMethod(args).id() == 10 &&
             InvalidMethod().id() == 0;
    }

   private:
    // Do not check synchronous unary since not all method implementations
    // support it.

    template <typename... Args>
    constexpr MethodImpl AsyncUnaryMethod(
        const std::tuple<Args...>& args) const {
      return Call(
          MethodImpl::template AsynchronousUnary<&TestService::AsyncUnary>,
          3,
          args);
    }

    template <typename... Args>
    constexpr MethodImpl StaticAsyncUnaryMethod(
        const std::tuple<Args...>& args) const {
      return Call(MethodImpl::template AsynchronousUnary<
                      &TestService::StaticAsyncUnary>,
                  4,
                  args);
    }

    template <typename... Args>
    constexpr MethodImpl ServerStreamingMethod(
        const std::tuple<Args...>& args) const {
      return Call(
          MethodImpl::template ServerStreaming<&TestService::ServerStreaming>,
          5,
          args);
    }

    template <typename... Args>
    constexpr MethodImpl StaticServerStreamingMethod(
        const std::tuple<Args...>& args) const {
      return Call(MethodImpl::template ServerStreaming<
                      &TestService::StaticServerStreaming>,
                  6,
                  args);
    }

    template <typename... Args>
    constexpr MethodImpl ClientStreamingMethod(
        const std::tuple<Args...>& args) const {
      return Call(
          MethodImpl::template ClientStreaming<&TestService::ClientStreaming>,
          7,
          args);
    }

    template <typename... Args>
    constexpr MethodImpl StaticClientStreamingMethod(
        const std::tuple<Args...>& args) const {
      return Call(MethodImpl::template ClientStreaming<
                      &TestService::StaticClientStreaming>,
                  8,
                  args);
    }

    template <typename... Args>
    constexpr MethodImpl BidirectionalStreamingMethod(
        const std::tuple<Args...>& args) const {
      return Call(MethodImpl::template BidirectionalStreaming<
                      &TestService::BidirectionalStreaming>,
                  9,
                  args);
    }

    template <typename... Args>
    constexpr MethodImpl StaticBidirectionalStreamingMethod(
        const std::tuple<Args...>& args) const {
      return Call(MethodImpl::template BidirectionalStreaming<
                      &TestService::StaticBidirectionalStreaming>,
                  10,
                  args);
    }

    // Test that there is an Invalid method creation function.
    constexpr MethodImpl InvalidMethod() const { return MethodImpl::Invalid(); }

    // Invokes the method creation function with the ID and extra args.
    template <typename Function, typename... Args>
    static constexpr MethodImpl Call(Function&& function,
                                     uint32_t id,
                                     const std::tuple<Args...>& args) {
      return std::apply(function, std::tuple_cat(std::tuple(id), args));
    }
  };
};

}  // namespace pw::rpc::internal