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

#include "JHybridCameraDeviceSpec.hpp"

// Forward declaration of `DeviceType` to properly resolve imports.
namespace margelo::nitro::camera { enum class DeviceType; }
// Forward declaration of `CameraPosition` to properly resolve imports.
namespace margelo::nitro::camera { enum class CameraPosition; }
// Forward declaration of `HybridCameraDeviceSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridCameraDeviceSpec; }
// Forward declaration of `PixelFormat` to properly resolve imports.
namespace margelo::nitro::camera { enum class PixelFormat; }
// Forward declaration of `DynamicRange` to properly resolve imports.
namespace margelo::nitro::camera { struct DynamicRange; }
// Forward declaration of `DynamicRangeBitDepth` to properly resolve imports.
namespace margelo::nitro::camera { enum class DynamicRangeBitDepth; }
// Forward declaration of `ColorSpace` to properly resolve imports.
namespace margelo::nitro::camera { enum class ColorSpace; }
// Forward declaration of `ColorRange` to properly resolve imports.
namespace margelo::nitro::camera { enum class ColorRange; }
// Forward declaration of `Range` to properly resolve imports.
namespace margelo::nitro::camera { struct Range; }
// Forward declaration of `MediaType` to properly resolve imports.
namespace margelo::nitro::camera { enum class MediaType; }
// Forward declaration of `Size` to properly resolve imports.
namespace margelo::nitro::camera { struct Size; }
// Forward declaration of `OutputStreamType` to properly resolve imports.
namespace margelo::nitro::camera { enum class OutputStreamType; }
// Forward declaration of `HybridCameraOutputSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridCameraOutputSpec; }
// Forward declaration of `TargetStabilizationMode` to properly resolve imports.
namespace margelo::nitro::camera { enum class TargetStabilizationMode; }
// Forward declaration of `HybridCameraSessionConfigSpec` to properly resolve imports.
namespace margelo::nitro::camera { class HybridCameraSessionConfigSpec; }

#include <string>
#include "DeviceType.hpp"
#include "JDeviceType.hpp"
#include "CameraPosition.hpp"
#include "JCameraPosition.hpp"
#include <memory>
#include "HybridCameraDeviceSpec.hpp"
#include <vector>
#include "JHybridCameraDeviceSpec.hpp"
#include "PixelFormat.hpp"
#include "JPixelFormat.hpp"
#include "DynamicRange.hpp"
#include "JDynamicRange.hpp"
#include "DynamicRangeBitDepth.hpp"
#include "JDynamicRangeBitDepth.hpp"
#include "ColorSpace.hpp"
#include "JColorSpace.hpp"
#include "ColorRange.hpp"
#include "JColorRange.hpp"
#include "Range.hpp"
#include "JRange.hpp"
#include <optional>
#include "MediaType.hpp"
#include "JMediaType.hpp"
#include "Size.hpp"
#include "JSize.hpp"
#include "OutputStreamType.hpp"
#include "JOutputStreamType.hpp"
#include "HybridCameraOutputSpec.hpp"
#include "JHybridCameraOutputSpec.hpp"
#include "TargetStabilizationMode.hpp"
#include "JTargetStabilizationMode.hpp"
#include "HybridCameraSessionConfigSpec.hpp"
#include "JHybridCameraSessionConfigSpec.hpp"

namespace margelo::nitro::camera {

  std::shared_ptr<JHybridCameraDeviceSpec> JHybridCameraDeviceSpec::JavaPart::getJHybridCameraDeviceSpec() {
    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
    auto castHybridObject = std::dynamic_pointer_cast<JHybridCameraDeviceSpec>(hybridObject);
    if (castHybridObject == nullptr) [[unlikely]] {
      throw std::runtime_error("Failed to downcast JHybridObject to JHybridCameraDeviceSpec!");
    }
    return castHybridObject;
  }

  jni::local_ref<JHybridCameraDeviceSpec::CxxPart::jhybriddata> JHybridCameraDeviceSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
    return makeCxxInstance(jThis);
  }

  std::shared_ptr<JHybridObject> JHybridCameraDeviceSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
    auto castJavaPart = jni::dynamic_ref_cast<JHybridCameraDeviceSpec::JavaPart>(javaPart);
    if (castJavaPart == nullptr) [[unlikely]] {
      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridCameraDeviceSpec::JavaPart!");
    }
    return std::make_shared<JHybridCameraDeviceSpec>(castJavaPart);
  }

  void JHybridCameraDeviceSpec::CxxPart::registerNatives() {
    registerHybrid({
      makeNativeMethod("initHybrid", JHybridCameraDeviceSpec::CxxPart::initHybrid),
    });
  }

  // Properties
  std::string JHybridCameraDeviceSpec::getId() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getId");
    auto __result = method(_javaPart);
    return __result->toStdString();
  }
  std::string JHybridCameraDeviceSpec::getModelID() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getModelID");
    auto __result = method(_javaPart);
    return __result->toStdString();
  }
  std::string JHybridCameraDeviceSpec::getLocalizedName() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getLocalizedName");
    auto __result = method(_javaPart);
    return __result->toStdString();
  }
  std::string JHybridCameraDeviceSpec::getManufacturer() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getManufacturer");
    auto __result = method(_javaPart);
    return __result->toStdString();
  }
  DeviceType JHybridCameraDeviceSpec::getType() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JDeviceType>()>("getType");
    auto __result = method(_javaPart);
    return __result->toCpp();
  }
  CameraPosition JHybridCameraDeviceSpec::getPosition() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JCameraPosition>()>("getPosition");
    auto __result = method(_javaPart);
    return __result->toCpp();
  }
  std::vector<std::shared_ptr<HybridCameraDeviceSpec>> JHybridCameraDeviceSpec::getPhysicalDevices() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JHybridCameraDeviceSpec::JavaPart>>()>("getPhysicalDevices");
    auto __result = method(_javaPart);
    return [&](auto&& __input) {
      size_t __size = __input->size();
      std::vector<std::shared_ptr<HybridCameraDeviceSpec>> __vector;
      __vector.reserve(__size);
      for (size_t __i = 0; __i < __size; __i++) {
        auto __element = __input->getElement(__i);
        __vector.push_back(__element->getJHybridCameraDeviceSpec());
      }
      return __vector;
    }(__result);
  }
  bool JHybridCameraDeviceSpec::getIsVirtualDevice() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("isVirtualDevice");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  std::vector<PixelFormat> JHybridCameraDeviceSpec::getSupportedPixelFormats() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JPixelFormat>>()>("getSupportedPixelFormats");
    auto __result = method(_javaPart);
    return [&](auto&& __input) {
      size_t __size = __input->size();
      std::vector<PixelFormat> __vector;
      __vector.reserve(__size);
      for (size_t __i = 0; __i < __size; __i++) {
        auto __element = __input->getElement(__i);
        __vector.push_back(__element->toCpp());
      }
      return __vector;
    }(__result);
  }
  bool JHybridCameraDeviceSpec::getSupportsPhotoHDR() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getSupportsPhotoHDR");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  std::vector<DynamicRange> JHybridCameraDeviceSpec::getSupportedVideoDynamicRanges() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JDynamicRange>>()>("getSupportedVideoDynamicRanges");
    auto __result = method(_javaPart);
    return [&](auto&& __input) {
      size_t __size = __input->size();
      std::vector<DynamicRange> __vector;
      __vector.reserve(__size);
      for (size_t __i = 0; __i < __size; __i++) {
        auto __element = __input->getElement(__i);
        __vector.push_back(__element->toCpp());
      }
      return __vector;
    }(__result);
  }
  std::vector<Range> JHybridCameraDeviceSpec::getSupportedFPSRanges() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JRange>>()>("getSupportedFPSRanges");
    auto __result = method(_javaPart);
    return [&](auto&& __input) {
      size_t __size = __input->size();
      std::vector<Range> __vector;
      __vector.reserve(__size);
      for (size_t __i = 0; __i < __size; __i++) {
        auto __element = __input->getElement(__i);
        __vector.push_back(__element->toCpp());
      }
      return __vector;
    }(__result);
  }
  bool JHybridCameraDeviceSpec::getSupportsPreviewImage() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getSupportsPreviewImage");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  bool JHybridCameraDeviceSpec::getSupportsSpeedQualityPrioritization() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getSupportsSpeedQualityPrioritization");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  std::optional<double> JHybridCameraDeviceSpec::getFocalLength() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getFocalLength");
    auto __result = method(_javaPart);
    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
  }
  double JHybridCameraDeviceSpec::getLensAperture() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getLensAperture");
    auto __result = method(_javaPart);
    return __result;
  }
  bool JHybridCameraDeviceSpec::getIsContinuityCamera() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("isContinuityCamera");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  std::optional<std::shared_ptr<HybridCameraDeviceSpec>> JHybridCameraDeviceSpec::getCompanionDeskViewCamera() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridCameraDeviceSpec::JavaPart>()>("getCompanionDeskViewCamera");
    auto __result = method(_javaPart);
    return __result != nullptr ? std::make_optional(__result->getJHybridCameraDeviceSpec()) : std::nullopt;
  }
  std::vector<MediaType> JHybridCameraDeviceSpec::getMediaTypes() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JMediaType>>()>("getMediaTypes");
    auto __result = method(_javaPart);
    return [&](auto&& __input) {
      size_t __size = __input->size();
      std::vector<MediaType> __vector;
      __vector.reserve(__size);
      for (size_t __i = 0; __i < __size; __i++) {
        auto __element = __input->getElement(__i);
        __vector.push_back(__element->toCpp());
      }
      return __vector;
    }(__result);
  }
  bool JHybridCameraDeviceSpec::getSupportsFocusMetering() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getSupportsFocusMetering");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  bool JHybridCameraDeviceSpec::getSupportsFocusLocking() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getSupportsFocusLocking");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  bool JHybridCameraDeviceSpec::getSupportsSmoothAutoFocus() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getSupportsSmoothAutoFocus");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  bool JHybridCameraDeviceSpec::getSupportsExposureMetering() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getSupportsExposureMetering");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  bool JHybridCameraDeviceSpec::getSupportsExposureLocking() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getSupportsExposureLocking");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  bool JHybridCameraDeviceSpec::getSupportsExposureBias() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getSupportsExposureBias");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  double JHybridCameraDeviceSpec::getMinExposureBias() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getMinExposureBias");
    auto __result = method(_javaPart);
    return __result;
  }
  double JHybridCameraDeviceSpec::getMaxExposureBias() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getMaxExposureBias");
    auto __result = method(_javaPart);
    return __result;
  }
  bool JHybridCameraDeviceSpec::getSupportsWhiteBalanceMetering() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getSupportsWhiteBalanceMetering");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  double JHybridCameraDeviceSpec::getMaxWhiteBalanceGain() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getMaxWhiteBalanceGain");
    auto __result = method(_javaPart);
    return __result;
  }
  bool JHybridCameraDeviceSpec::getSupportsWhiteBalanceLocking() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getSupportsWhiteBalanceLocking");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  bool JHybridCameraDeviceSpec::getHasFlash() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getHasFlash");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  bool JHybridCameraDeviceSpec::getHasTorch() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getHasTorch");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  bool JHybridCameraDeviceSpec::getSupportsTorchStrength() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getSupportsTorchStrength");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  double JHybridCameraDeviceSpec::getMinTorchStrength() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getMinTorchStrength");
    auto __result = method(_javaPart);
    return __result;
  }
  double JHybridCameraDeviceSpec::getMaxTorchStrength() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getMaxTorchStrength");
    auto __result = method(_javaPart);
    return __result;
  }
  bool JHybridCameraDeviceSpec::getSupportsLowLightBoost() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getSupportsLowLightBoost");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  double JHybridCameraDeviceSpec::getMinZoom() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getMinZoom");
    auto __result = method(_javaPart);
    return __result;
  }
  double JHybridCameraDeviceSpec::getMaxZoom() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getMaxZoom");
    auto __result = method(_javaPart);
    return __result;
  }
  std::vector<double> JHybridCameraDeviceSpec::getZoomLensSwitchFactors() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayDouble>()>("getZoomLensSwitchFactors");
    auto __result = method(_javaPart);
    return [&]() {
      size_t __size = __result->size();
      std::vector<double> __vector(__size);
      __result->getRegion(0, __size, __vector.data());
      return __vector;
    }();
  }
  bool JHybridCameraDeviceSpec::getSupportsDistortionCorrection() {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getSupportsDistortionCorrection");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }

  // Methods
  std::vector<Size> JHybridCameraDeviceSpec::getSupportedResolutions(OutputStreamType outputStreamType) {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JSize>>(jni::alias_ref<JOutputStreamType> /* outputStreamType */)>("getSupportedResolutions");
    auto __result = method(_javaPart, JOutputStreamType::fromCpp(outputStreamType));
    return [&](auto&& __input) {
      size_t __size = __input->size();
      std::vector<Size> __vector;
      __vector.reserve(__size);
      for (size_t __i = 0; __i < __size; __i++) {
        auto __element = __input->getElement(__i);
        __vector.push_back(__element->toCpp());
      }
      return __vector;
    }(__result);
  }
  bool JHybridCameraDeviceSpec::supportsOutput(const std::shared_ptr<HybridCameraOutputSpec>& output) {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(jni::alias_ref<JHybridCameraOutputSpec::JavaPart> /* output */)>("supportsOutput");
    auto __result = method(_javaPart, std::dynamic_pointer_cast<JHybridCameraOutputSpec>(output)->getJavaPart());
    return static_cast<bool>(__result);
  }
  bool JHybridCameraDeviceSpec::supportsFPS(double fps) {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(double /* fps */)>("supportsFPS");
    auto __result = method(_javaPart, fps);
    return static_cast<bool>(__result);
  }
  bool JHybridCameraDeviceSpec::supportsVideoStabilizationMode(TargetStabilizationMode videoStabilizationMode) {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(jni::alias_ref<JTargetStabilizationMode> /* videoStabilizationMode */)>("supportsVideoStabilizationMode");
    auto __result = method(_javaPart, JTargetStabilizationMode::fromCpp(videoStabilizationMode));
    return static_cast<bool>(__result);
  }
  bool JHybridCameraDeviceSpec::supportsPreviewStabilizationMode(TargetStabilizationMode previewStabilizationMode) {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(jni::alias_ref<JTargetStabilizationMode> /* previewStabilizationMode */)>("supportsPreviewStabilizationMode");
    auto __result = method(_javaPart, JTargetStabilizationMode::fromCpp(previewStabilizationMode));
    return static_cast<bool>(__result);
  }
  bool JHybridCameraDeviceSpec::isSessionConfigSupported(const std::shared_ptr<HybridCameraSessionConfigSpec>& config) {
    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(jni::alias_ref<JHybridCameraSessionConfigSpec::JavaPart> /* config */)>("isSessionConfigSupported");
    auto __result = method(_javaPart, std::dynamic_pointer_cast<JHybridCameraSessionConfigSpec>(config)->getJavaPart());
    return static_cast<bool>(__result);
  }

} // namespace margelo::nitro::camera