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

{{- define "Method:Result:WireMessagingHeader" }}
{{- EnsureNamespace "" }}

template<>
class [[nodiscard]] {{ .WireResult }} final : public ::fidl::Status {
 public:
  {{ .WireResult.Self }}(
      ::{{ .Transport.Namespace }}::UnownedClientEnd<{{ .Protocol }}> client,
      {{ .WireTransactionalRequest }}* request
      {{- if .HasResponse }}, std::optional<zx::time> deadline = std::nullopt{{ end }}
  );

  explicit {{ .WireResult.Self }}(const ::fidl::Status& result) : ::fidl::Status(result) {}
  {{ .WireResult.Self }}({{ .WireResult.Self }}&&) = delete;
  {{ .WireResult.Self }}(const {{ .WireResult.Self }}&) = delete;
  {{ .WireResult.Self }}& operator=({{ .WireResult.Self }}&&) = delete;
  {{ .WireResult.Self }}& operator=(const {{ .WireResult.Self }}&) = delete;
  ~{{ .WireResult.Self }}() = default;

  {{- if .HasWireResultBase }}
    {{ .WireResultBase }}* Unwrap() {
      {{- if .Result }}
        return &result_.value();
      {{- else }}
        ZX_ASSERT(ok());
        return &decoded_.Value()->body;
      {{- end }}
    }
    const {{ .WireResultBase }}* Unwrap() const {
      {{- if .Result }}
        return &result_.value();
      {{- else }}
        ZX_ASSERT(ok());
        return &decoded_.Value()->body;
      {{- end }}
    }

    {{ .WireResultBase }}& value() { return *Unwrap(); }
    const {{ .WireResultBase }}& value() const { return *Unwrap(); }

    {{ .WireResultBase }}* operator->() { return &value(); }
    const {{ .WireResultBase }}* operator->() const { return &value(); }

    {{ .WireResultBase }}& operator*() { return value(); }
    const {{ .WireResultBase }}& operator*() const { return value(); }
  {{- end }}

  {{- if .HasResponse }}
   private:
    {{ .Response.ClientAllocationV1.BackingBufferType }} bytes_;
    ::fidl::internal::DecodedValue<{{ .WireTransactionalResponse }}> decoded_;
    {{- if and .Result .HasWireResultBase }}
      std::optional<{{ .WireResultBase }}> result_ = std::nullopt;
    {{- end }}
  {{- end }}
};

{{- end }}


{{- define "Method:Result:WireMessagingSource" }}
{{- IfdefFuchsia -}}
{{- EnsureNamespace "" }}
{{ .WireResult }}::{{ .WireResult.Self }}(
    ::{{ .Transport.Namespace }}::UnownedClientEnd<{{ .Protocol }}> client,
    {{ .WireTransactionalRequest }}* request
    {{- if .HasResponse }}, std::optional<zx::time> deadline{{ end }}
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::unstable::OwnedEncodedMessage<{{ .WireTransactionalRequest }}, {{ .Transport.Type }}> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();

  {{- if .HasResponse }}
    {{ .IncomingMessageHandleStorageForResponse }} handle_storage;
    ::fidl::unstable::DecodedMessage<{{ .WireTransactionalResponse }}> decoded{
        outgoing.Call(
            client.handle(), handle_storage.view(bytes_.view()),
            deadline.has_value() ? fidl::CallOptions{.deadline = deadline->get()} : fidl::CallOptions{}
        )
    };
    SetStatus(decoded);
    if (ok()) {
      decoded_ = decoded.Take();
    }

    {{- if .HasApplicationError }}
      if (ok()) {
        auto* raw_response = &decoded_.Value()->body;
        if (raw_response->result.is_err()) {
          result_ = fitx::error(raw_response->result.err());
        } else if (raw_response->result.is_response()) {
          result_ = fitx::ok(
            {{- if .Result.ValueParameters -}}
              &(raw_response->result.response())
            {{- end -}}
          );
        }
      }
    {{- end }}
  {{- else }}
    outgoing.Write(client.handle());
    SetStatus(outgoing);
  {{- end }}
}

{{- EndifFuchsia -}}
{{- end }}