///
/// HybridUrlRequestBuilderSpecSwift.hpp
/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
/// https://github.com/mrousavy/nitro
/// Copyright © Marc Rousavy @ Margelo
///

#pragma once

#include "HybridUrlRequestBuilderSpec.hpp"

// Forward declaration of `HybridUrlRequestBuilderSpec_cxx` to properly resolve imports.
namespace NitroFetch { class HybridUrlRequestBuilderSpec_cxx; }

// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
namespace NitroModules { class ArrayBufferHolder; }
// Forward declaration of `UrlResponseInfo` to properly resolve imports.
namespace margelo::nitro::nitrofetch { struct UrlResponseInfo; }
// Forward declaration of `HttpHeader` to properly resolve imports.
namespace margelo::nitro::nitrofetch { struct HttpHeader; }
// Forward declaration of `RequestException` to properly resolve imports.
namespace margelo::nitro::nitrofetch { struct RequestException; }
// Forward declaration of `HybridUrlRequestSpec` to properly resolve imports.
namespace margelo::nitro::nitrofetch { class HybridUrlRequestSpec; }

#include <string>
#include <NitroModules/ArrayBuffer.hpp>
#include <variant>
#include <NitroModules/ArrayBufferHolder.hpp>
#include "UrlResponseInfo.hpp"
#include <functional>
#include <unordered_map>
#include "HttpHeader.hpp"
#include <vector>
#include <optional>
#include "RequestException.hpp"
#include <memory>
#include "HybridUrlRequestSpec.hpp"

#include "NitroFetch-Swift-Cxx-Umbrella.hpp"

namespace margelo::nitro::nitrofetch {

  /**
   * The C++ part of HybridUrlRequestBuilderSpec_cxx.swift.
   *
   * HybridUrlRequestBuilderSpecSwift (C++) accesses HybridUrlRequestBuilderSpec_cxx (Swift), and might
   * contain some additional bridging code for C++ <> Swift interop.
   *
   * Since this obviously introduces an overhead, I hope at some point in
   * the future, HybridUrlRequestBuilderSpec_cxx can directly inherit from the C++ class HybridUrlRequestBuilderSpec
   * to simplify the whole structure and memory management.
   */
  class HybridUrlRequestBuilderSpecSwift: public virtual HybridUrlRequestBuilderSpec {
  public:
    // Constructor from a Swift instance
    explicit HybridUrlRequestBuilderSpecSwift(const NitroFetch::HybridUrlRequestBuilderSpec_cxx& swiftPart):
      HybridObject(HybridUrlRequestBuilderSpec::TAG),
      _swiftPart(swiftPart) { }

  public:
    // Get the Swift part
    inline NitroFetch::HybridUrlRequestBuilderSpec_cxx& getSwiftPart() noexcept {
      return _swiftPart;
    }

  public:
    inline size_t getExternalMemorySize() noexcept override {
      return _swiftPart.getMemorySize();
    }
    bool equals(const std::shared_ptr<HybridObject>& other) override {
      if (auto otherCast = std::dynamic_pointer_cast<HybridUrlRequestBuilderSpecSwift>(other)) {
        return _swiftPart.equals(otherCast->_swiftPart);
      }
      return false;
    }
    void dispose() noexcept override {
      _swiftPart.dispose();
    }
    std::string toString() override {
      return _swiftPart.toString();
    }

  public:
    // Properties
    

  public:
    // Methods
    inline void setHttpMethod(const std::string& httpMethod) override {
      auto __result = _swiftPart.setHttpMethod(httpMethod);
      if (__result.hasError()) [[unlikely]] {
        std::rethrow_exception(__result.error());
      }
    }
    inline void addHeader(const std::string& name, const std::string& value) override {
      auto __result = _swiftPart.addHeader(name, value);
      if (__result.hasError()) [[unlikely]] {
        std::rethrow_exception(__result.error());
      }
    }
    inline void setUploadBody(const std::variant<std::shared_ptr<ArrayBuffer>, std::string>& body) override {
      auto __result = _swiftPart.setUploadBody(body);
      if (__result.hasError()) [[unlikely]] {
        std::rethrow_exception(__result.error());
      }
    }
    inline void disableCache() override {
      auto __result = _swiftPart.disableCache();
      if (__result.hasError()) [[unlikely]] {
        std::rethrow_exception(__result.error());
      }
    }
    inline void onSucceeded(const std::function<void(const UrlResponseInfo& /* info */)>& callback) override {
      auto __result = _swiftPart.onSucceeded(callback);
      if (__result.hasError()) [[unlikely]] {
        std::rethrow_exception(__result.error());
      }
    }
    inline void onFailed(const std::function<void(const std::optional<UrlResponseInfo>& /* info */, const RequestException& /* error */)>& callback) override {
      auto __result = _swiftPart.onFailed(callback);
      if (__result.hasError()) [[unlikely]] {
        std::rethrow_exception(__result.error());
      }
    }
    inline void onCanceled(const std::function<void(const std::optional<UrlResponseInfo>& /* info */)>& callback) override {
      auto __result = _swiftPart.onCanceled(callback);
      if (__result.hasError()) [[unlikely]] {
        std::rethrow_exception(__result.error());
      }
    }
    inline void onRedirectReceived(const std::function<void(const UrlResponseInfo& /* info */, const std::string& /* newLocationUrl */)>& callback) override {
      auto __result = _swiftPart.onRedirectReceived(callback);
      if (__result.hasError()) [[unlikely]] {
        std::rethrow_exception(__result.error());
      }
    }
    inline void onResponseStarted(const std::function<void(const UrlResponseInfo& /* info */)>& callback) override {
      auto __result = _swiftPart.onResponseStarted(callback);
      if (__result.hasError()) [[unlikely]] {
        std::rethrow_exception(__result.error());
      }
    }
    inline void onReadCompleted(const std::function<void(const UrlResponseInfo& /* info */, const std::shared_ptr<ArrayBuffer>& /* byteBuffer */, double /* bytesRead */)>& callback) override {
      auto __result = _swiftPart.onReadCompleted(callback);
      if (__result.hasError()) [[unlikely]] {
        std::rethrow_exception(__result.error());
      }
    }
    inline std::shared_ptr<HybridUrlRequestSpec> build() override {
      auto __result = _swiftPart.build();
      if (__result.hasError()) [[unlikely]] {
        std::rethrow_exception(__result.error());
      }
      auto __value = std::move(__result.value());
      return __value;
    }

  private:
    NitroFetch::HybridUrlRequestBuilderSpec_cxx _swiftPart;
  };

} // namespace margelo::nitro::nitrofetch