// 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 <lib/fidl/cpp/transaction_header.h>
#include <lib/fidl/cpp/wire/server.h>

namespace fidl {

namespace internal {

const UnknownMethodHandlerEntry UnknownMethodHandlerEntry::kClosedProtocolHandlerEntry{
    .openness = ::fidl::internal::Openness::kClosed,
    .dispatch = nullptr,
    .send_reply = nullptr,
};

::fidl::DispatchResult TryDispatch(void* impl, ::fidl::IncomingHeaderAndMessage& msg,
                                   fidl::internal::MessageStorageViewBase* storage_view,
                                   ::fidl::Transaction* txn, const MethodEntry* begin,
                                   const MethodEntry* end) {
  if (!msg.ok()) {
    txn->InternalError(fidl::UnbindInfo{msg}, fidl::ErrorOrigin::kReceive);
    // |TryDispatch| is used to ad-hoc compose protocols by trying a series of
    // |TryDispatch|. If the message has an error, exit the cascade of dispatch
    // attempts early since it is meaningless to keep trying otherwise.
    return ::fidl::DispatchResult::kFound;
  }
  auto* hdr = msg.header();
  while (begin < end) {
    if (hdr->ordinal == begin->ordinal) {
      const fidl_message_header& header = *msg.header();
      auto metadata = fidl::WireFormatMetadata::FromTransactionalHeader(header);
      fidl::EncodedMessage body_message = std::move(msg).SkipTransactionHeader();
      fidl::Status decode_status = begin->dispatch(impl, body_message, metadata, storage_view, txn);
      std::move(body_message).CloseHandles();
      if (unlikely(!decode_status.ok())) {
        ZX_DEBUG_ASSERT(decode_status.reason() == fidl::Reason::kDecodeError);
        txn->InternalError(UnbindInfo{decode_status}, fidl::ErrorOrigin::kReceive);
      }
      return ::fidl::DispatchResult::kFound;
    }
    ++begin;
  }
  return ::fidl::DispatchResult::kNotFound;
}

void Dispatch(void* impl, ::fidl::IncomingHeaderAndMessage& msg,
              fidl::internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn,
              const MethodEntry* begin, const MethodEntry* end,
              const UnknownMethodHandlerEntry* unknown_method_handler) {
  ::fidl::DispatchResult result = TryDispatch(impl, msg, storage_view, txn, begin, end);
  switch (result) {
    case ::fidl::DispatchResult::kNotFound: {
      auto* hdr = msg.header();
      ::fidl::UnknownMethodType unknown_method_type =
          ::fidl::internal::UnknownMethodTypeFromHeader(hdr);
      auto is_flexible_interaction = ::fidl::IsFlexibleInteraction(hdr);
      auto ordinal = hdr->ordinal;
      std::move(msg).CloseHandles();
      if (is_flexible_interaction && ::fidl::internal::CanHandleMethod(
                                         unknown_method_handler->openness, unknown_method_type)) {
        if (unknown_method_type == ::fidl::UnknownMethodType::kTwoWay) {
          auto reply = ::fidl::internal::UnknownMethodReply::MakeReplyFor(
              ordinal, ::fidl::MessageDynamicFlags::kFlexibleMethod);
          (unknown_method_handler->send_reply)(reply, txn);
        }
        unknown_method_handler->dispatch(impl, ordinal, unknown_method_type, txn);
        break;
      }
      txn->InternalError(::fidl::UnbindInfo::UnknownOrdinal(), ::fidl::ErrorOrigin::kReceive);
    } break;
    case ::fidl::DispatchResult::kFound:
      break;
  }
}

::fidl::OneWayStatus WeakEventSenderInner::SendEvent(::fidl::OutgoingMessage& message,
                                                     WriteOptions options) const {
  auto matchers = MatchVariant{
      [&](const std::shared_ptr<AsyncServerBinding>& binding) {
        message.set_txid(0);
        message.Write(binding->transport(), std::move(options));
        if (!message.ok()) {
          HandleSendError(message.error());
          return fidl::OneWayStatus{message.error()};
        }
        return fidl::OneWayStatus{fidl::OneWayStatus::Ok()};
      },
      [](fidl::UnbindInfo info) { return OneWayErrorFromUnbindInfo(info); },
      [](WeakServerBindingRef::Invalid) -> fidl::OneWayStatus {
        // NOTE TO USER: if you see a crash at this line, it could mean
        // the code sent an event on a moved-from server binding reference.
        __builtin_abort();
      },
  };
  return std::visit(matchers, binding_.lock_or_error());
}

void WeakEventSenderInner::HandleSendError(fidl::Status error) const {
  if (auto binding = binding_.lock()) {
    binding->HandleError(binding, {UnbindInfo{error}, ErrorOrigin::kSend});
  }
}

ServerBindingRefBase BindServerTypeErased(async_dispatcher_t* dispatcher, AnyTransport&& server_end,
                                          IncomingMessageDispatcher* interface,
                                          ThreadingPolicy threading_policy,
                                          AnyOnUnboundFn on_unbound) {
  std::shared_ptr<AsyncServerBinding> internal_binding = AsyncServerBinding::Create(
      dispatcher, std::move(server_end), interface, threading_policy, std::move(on_unbound));
  ServerBindingRefBase binding_ref(internal_binding, internal_binding->shared_unbind_info());
  AsyncServerBinding* binding_ptr = internal_binding.get();
  // The binding object keeps itself alive until unbinding, so dropping the
  // shared pointer here is fine.
  internal_binding.reset();
  binding_ptr->BeginFirstWait();
  return binding_ref;
}

}  // namespace internal

}  // namespace fidl