// Copyright 2021 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.

#ifndef SRC_LIB_FIDL_CPP_INCLUDE_LIB_FIDL_CPP_INTERNAL_MAKE_RESPONSE_CONTEXT_H_
#define SRC_LIB_FIDL_CPP_INCLUDE_LIB_FIDL_CPP_INTERNAL_MAKE_RESPONSE_CONTEXT_H_

#include <lib/fidl/cpp/any_error_in.h>
#include <lib/fidl/cpp/unified_messaging.h>
#include <lib/fidl/llcpp/client_base.h>

#include <optional>

namespace fidl {
namespace internal {

// |DecodeResponseAndFoldError| decodes an incoming message |incoming| returns
// a transport-specific result type (e.g. |fidl::Result| for Zircon channel
// transport). In doing so it combines any FIDL application error from the error
// syntax with transport errors.
//
// If a terminal error occurred which warrants unbinding, |out_maybe_unbind|
// will be populated with a reason if not nullptr.
template <typename FidlMethod>
auto DecodeResponseAndFoldError(::fidl::IncomingMessage&& incoming,
                                ::std::optional<::fidl::UnbindInfo>* out_maybe_unbind) {
  using ResultType = typename FidlMethod::Protocol::Transport::template Result<FidlMethod>;
  using NaturalResponse = ::fidl::Response<FidlMethod>;
  constexpr bool HasApplicationError =
      ::fidl::internal::NaturalMethodTypes<FidlMethod>::HasApplicationError;
  constexpr bool IsAbsentBody = ::fidl::internal::NaturalMethodTypes<FidlMethod>::IsAbsentBody;

  // Check error from the underlying transport.
  if (!incoming.ok()) {
    ResultType error = ::fitx::error(incoming.error());
    if (out_maybe_unbind != nullptr) {
      out_maybe_unbind->emplace(incoming.error());
    }
    return error;
  }

  ::fitx::result decoded = [&] {
    if constexpr (IsAbsentBody) {
      return DecodeTransactionalMessage(std::move(incoming));
    } else {
      using Body = typename MessageTraits<NaturalResponse>::Payload;
      return DecodeTransactionalMessage<Body>(std::move(incoming));
    }
  }();

  // Check decoding error.
  if (decoded.is_error()) {
    ResultType error = ::fitx::error(decoded.error_value());
    if (out_maybe_unbind != nullptr) {
      out_maybe_unbind->emplace(decoded.error_value());
    }
    return error;
  }

  if constexpr (IsAbsentBody) {
    // Absent body.
    ResultType value = ::fitx::success();
    return value;
  } else {
    NaturalResponse response =
        NaturalMessageConverter<NaturalResponse>::FromDomainObject(std::move(decoded.value()));
    if constexpr (HasApplicationError) {
      // Fold application error.
      if (response.is_error()) {
        ResultType error = response.take_error();
        return error;
      }
      ZX_DEBUG_ASSERT(response.is_ok());
      if constexpr (::fidl::internal::NaturalMethodTypes<FidlMethod>::IsEmptyStructPayload) {
        // Omit empty structs.
        ResultType value = ::fitx::success();
        return value;
      } else {
        ResultType value = response.take_value();
        return value;
      }
    } else {
      ResultType value = ::fitx::ok(std::move(response));
      return value;
    }
  }
}

// |MakeResponseContext| is a helper to create an adaptor from a |ResponseContext|
// to a response/result callback. It returns a raw pointer which deletes itself
// upon the receipt of a response or an error.
template <typename FidlMethod>
ResponseContext* MakeResponseContext(uint64_t ordinal,
                                     ::fidl::ClientCallback<FidlMethod> callback) {
  using ResultType = typename FidlMethod::Protocol::Transport::template Result<FidlMethod>;
  using CallbackType = ::fidl::ClientCallback<FidlMethod>;

  class ResponseContext final : public ::fidl::internal::ResponseContext {
   public:
    explicit ResponseContext(uint64_t ordinal, CallbackType&& callback)
        : ::fidl::internal::ResponseContext(ordinal), callback_(std::move(callback)) {}

   private:
    std::optional<::fidl::UnbindInfo> OnRawResult(
        ::fidl::IncomingMessage&& result,
        ::fidl::internal::IncomingTransportContext transport_context) override {
      std::optional<fidl::UnbindInfo> maybe_unbind;
      ResultType value = DecodeResponseAndFoldError<FidlMethod>(std::move(result), &maybe_unbind);
      callback_(value);
      delete this;
      return maybe_unbind;
    }

    ::fidl::ClientCallback<FidlMethod> callback_;
  };

  return new ResponseContext(ordinal, std::forward<CallbackType>(callback));
}

}  // namespace internal
}  // namespace fidl

#endif  // SRC_LIB_FIDL_CPP_INCLUDE_LIB_FIDL_CPP_INTERNAL_MAKE_RESPONSE_CONTEXT_H_