// Copyright 2022 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 "src/camera/lib/formatting/formatting.h"

#include <fuchsia/camera2/cpp/fidl.h>
#include <fuchsia/camera2/hal/cpp/fidl.h>
#include <fuchsia/camera3/cpp/fidl.h>
#include <fuchsia/sysmem/cpp/fidl.h>

#include <cstdint>
#include <map>
#include <string>
#include <string_view>
#include <variant>
#include <vector>

#include "src/camera/lib/formatting/macros.h"

namespace camera::formatting {

struct PropertyList;
using PropertyListPtr = std::unique_ptr<PropertyList>;
struct Property {
  std::optional<std::string> name;
  std::variant<std::string, PropertyListPtr> value;
};
struct PropertyList {
  std::vector<Property> properties;
  static PropertyListPtr New() { return std::make_unique<PropertyList>(); }
  // NOLINTNEXTLINE(misc-no-recursion): naturally recursive type
  void Format(std::ostream& os, size_t depth = 0) const {
    std::string pad(depth * 2, ' ');
    for (const auto& property : properties) {
      if (property.name) {
        os << pad << "\"" << *property.name << "\": ";
      }
      if (property.value.index() == 0) {
        os << "\"" << std::get<std::string>(property.value) << "\"\n";
      } else {
        os << "{\n";
        std::get<1>(property.value)->Format(os, depth + 1);
        os << "}\n";
      }
    }
  }
};

std::ostream& operator<<(std::ostream& os, const PropertyList& p) {
  p.Format(os);
  return os;
}

std::ostream& operator<<(std::ostream& os, const PropertyListPtr& p) {
  if (p) {
    os << *p;
  } else {
    os << "<MISSING PROPERTY LIST>";
  }
  return os;
}

template <typename T>
PropertyListPtr Dump(const std::vector<T>& x) {
  auto p = PropertyList::New();
  for (size_t i = 0; i < std::size(x); ++i) {
    p->properties.push_back({.name = std::to_string(i), .value = Dump(x[i])});
  }
  return p;
}

template <typename T, size_t N>
PropertyListPtr Dump(const std::array<T, N>& x) {
  auto p = PropertyList::New();
  for (size_t i = 0; i < std::size(x); ++i) {
    p->properties.push_back({.name = std::to_string(i), .value = Dump(x[i])});
  }
  return p;
}

template <typename T>
PropertyListPtr Dump(const T& x) {
  auto p = PropertyList::New();
  p->properties.push_back({.value = std::to_string(x)});
  return p;
}

template <>
PropertyListPtr Dump(const std::string& x) {
  auto p = PropertyList::New();
  p->properties.push_back({.value = x});
  return p;
}

template <>
PropertyListPtr Dump(const bool& x) {
  auto p = PropertyList::New();
  p->properties.push_back({.value = (x ? "true" : "false")});
  return p;
}

zx_koid_t GetKoid(zx_handle_t handle) {
  zx_info_handle_basic_t info;
  zx_status_t status =
      zx_object_get_info(handle, ZX_INFO_HANDLE_BASIC, &info, sizeof(info), nullptr, nullptr);
  return status == ZX_OK ? info.koid : ZX_KOID_INVALID;
}

template <>
PropertyListPtr Dump(const zx::vmo& x) {
  auto p = PropertyList::New();
  p->properties.push_back({.name = "koid", .value = std::to_string(GetKoid(x.get()))});
  return p;
}

}  // namespace camera::formatting

ENUM_BEGIN(fuchsia::camera2, DeviceType)
ENUM_ELEMENT(DeviceType::BUILTIN)
ENUM_ELEMENT(DeviceType::VIRTUAL)
ENUM_END()

ENUM_BEGIN(fuchsia::camera2, FrameStatus)
ENUM_ELEMENT(FrameStatus::OK)
ENUM_ELEMENT(FrameStatus::ERROR_FRAME)
ENUM_ELEMENT(FrameStatus::ERROR_BUFFER_FULL)
ENUM_END()

ENUM_BEGIN(fuchsia::sysmem, HeapType)
ENUM_ELEMENT(HeapType::SYSTEM_RAM)
ENUM_ELEMENT(HeapType::AMLOGIC_SECURE)
ENUM_ELEMENT(HeapType::AMLOGIC_SECURE_VDEC)
ENUM_ELEMENT(HeapType::GOLDFISH_DEVICE_LOCAL)
ENUM_ELEMENT(HeapType::GOLDFISH_HOST_VISIBLE)
ENUM_ELEMENT(HeapType::FRAMEBUFFER)
ENUM_END()

ENUM_BEGIN(fuchsia::sysmem, CoherencyDomain)
ENUM_ELEMENT(CoherencyDomain::CPU)
ENUM_ELEMENT(CoherencyDomain::RAM)
ENUM_ELEMENT(CoherencyDomain::INACCESSIBLE)
ENUM_END()

ENUM_BEGIN(fuchsia::sysmem, PixelFormatType)
ENUM_ELEMENT(PixelFormatType::INVALID)
ENUM_ELEMENT(PixelFormatType::R8G8B8A8)
ENUM_ELEMENT(PixelFormatType::BGRA32)
ENUM_ELEMENT(PixelFormatType::I420)
ENUM_ELEMENT(PixelFormatType::M420)
ENUM_ELEMENT(PixelFormatType::NV12)
ENUM_ELEMENT(PixelFormatType::YUY2)
ENUM_ELEMENT(PixelFormatType::MJPEG)
ENUM_ELEMENT(PixelFormatType::YV12)
ENUM_ELEMENT(PixelFormatType::BGR24)
ENUM_ELEMENT(PixelFormatType::RGB565)
ENUM_ELEMENT(PixelFormatType::RGB332)
ENUM_ELEMENT(PixelFormatType::RGB2220)
ENUM_ELEMENT(PixelFormatType::L8)
ENUM_ELEMENT(PixelFormatType::R8)
ENUM_ELEMENT(PixelFormatType::R8G8)
ENUM_ELEMENT(PixelFormatType::A2R10G10B10)
ENUM_ELEMENT(PixelFormatType::A2B10G10R10)
ENUM_ELEMENT(PixelFormatType::DO_NOT_CARE)
ENUM_END()

ENUM_BEGIN(fuchsia::sysmem, ColorSpaceType)
ENUM_ELEMENT(ColorSpaceType::INVALID)
ENUM_ELEMENT(ColorSpaceType::SRGB)
ENUM_ELEMENT(ColorSpaceType::REC601_NTSC)
ENUM_ELEMENT(ColorSpaceType::REC601_NTSC_FULL_RANGE)
ENUM_ELEMENT(ColorSpaceType::REC601_PAL)
ENUM_ELEMENT(ColorSpaceType::REC601_PAL_FULL_RANGE)
ENUM_ELEMENT(ColorSpaceType::REC709)
ENUM_ELEMENT(ColorSpaceType::REC2020)
ENUM_ELEMENT(ColorSpaceType::REC2100)
ENUM_ELEMENT(ColorSpaceType::PASS_THROUGH)
ENUM_ELEMENT(ColorSpaceType::DO_NOT_CARE)
ENUM_END()

BITS_BEGIN(fuchsia::camera2, CameraStreamType)
BITS_ELEMENT(CameraStreamType::MACHINE_LEARNING)
BITS_ELEMENT(CameraStreamType::MONITORING)
BITS_ELEMENT(CameraStreamType::FULL_RESOLUTION)
BITS_ELEMENT(CameraStreamType::DOWNSCALED_RESOLUTION)
BITS_ELEMENT(CameraStreamType::VIDEO_CONFERENCE)
BITS_ELEMENT(CameraStreamType::EXTENDED_FOV)
BITS_END()

MARK_NOTIMPL(fuchsia::sysmem, FormatModifier)

STRUCT_BEGIN(fuchsia::sysmem, BufferUsage)
STRUCT_ELEMENT(none)
STRUCT_ELEMENT(cpu)
STRUCT_ELEMENT(vulkan)
STRUCT_ELEMENT(display)
STRUCT_ELEMENT(video)
STRUCT_END()

STRUCT_BEGIN(fuchsia::sysmem, PixelFormat)
STRUCT_ELEMENT(type)
STRUCT_ELEMENT(has_format_modifier)
STRUCT_ELEMENT(format_modifier)
STRUCT_END()

STRUCT_BEGIN(fuchsia::sysmem, BufferMemorySettings)
STRUCT_ELEMENT(size_bytes)
STRUCT_ELEMENT(is_physically_contiguous)
STRUCT_ELEMENT(is_secure)
STRUCT_ELEMENT(coherency_domain)
STRUCT_ELEMENT(heap)
STRUCT_END()

STRUCT_BEGIN(fuchsia::sysmem, ColorSpace)
STRUCT_ELEMENT(type)
STRUCT_END()

STRUCT_BEGIN(fuchsia::sysmem, ImageFormatConstraints)
STRUCT_ELEMENT(pixel_format)
STRUCT_ELEMENT(color_spaces_count)
STRUCT_ELEMENT(color_space)
STRUCT_ELEMENT(min_coded_width)
STRUCT_ELEMENT(max_coded_width)
STRUCT_ELEMENT(min_coded_height)
STRUCT_ELEMENT(max_coded_height)
STRUCT_ELEMENT(max_bytes_per_row)
STRUCT_ELEMENT(max_coded_width_times_coded_height)
STRUCT_ELEMENT(layers)
STRUCT_ELEMENT(coded_width_divisor)
STRUCT_ELEMENT(coded_height_divisor)
STRUCT_ELEMENT(bytes_per_row_divisor)
STRUCT_ELEMENT(start_offset_divisor)
STRUCT_ELEMENT(display_width_divisor)
STRUCT_ELEMENT(display_height_divisor)
STRUCT_ELEMENT(required_min_coded_width)
STRUCT_ELEMENT(required_max_coded_width)
STRUCT_ELEMENT(required_min_coded_height)
STRUCT_ELEMENT(required_max_coded_height)
STRUCT_ELEMENT(required_min_bytes_per_row)
STRUCT_ELEMENT(required_max_bytes_per_row)
STRUCT_END()

STRUCT_BEGIN(fuchsia::sysmem, ImageFormat_2)
STRUCT_ELEMENT(pixel_format)
STRUCT_ELEMENT(coded_width)
STRUCT_ELEMENT(coded_height)
STRUCT_ELEMENT(bytes_per_row)
STRUCT_ELEMENT(display_width)
STRUCT_ELEMENT(display_height)
STRUCT_ELEMENT(layers)
STRUCT_ELEMENT(color_space)
STRUCT_ELEMENT(has_pixel_aspect_ratio)
STRUCT_ELEMENT(pixel_aspect_ratio_width)
STRUCT_ELEMENT(pixel_aspect_ratio_height)
STRUCT_END()

STRUCT_BEGIN(fuchsia::sysmem, BufferMemoryConstraints)
STRUCT_ELEMENT(min_size_bytes)
STRUCT_ELEMENT(max_size_bytes)
STRUCT_ELEMENT(physically_contiguous_required)
STRUCT_ELEMENT(secure_required)
STRUCT_ELEMENT(ram_domain_supported)
STRUCT_ELEMENT(cpu_domain_supported)
STRUCT_ELEMENT(inaccessible_domain_supported)
STRUCT_ELEMENT(heap_permitted_count)
STRUCT_ELEMENT(heap_permitted)
STRUCT_END()

STRUCT_BEGIN(fuchsia::sysmem, VmoBuffer)
STRUCT_ELEMENT(vmo)
STRUCT_ELEMENT(vmo_usable_start)
STRUCT_END()

STRUCT_BEGIN(fuchsia::sysmem, SingleBufferSettings)
STRUCT_ELEMENT(buffer_settings)
STRUCT_ELEMENT(has_image_format_constraints)
STRUCT_ELEMENT(image_format_constraints)
STRUCT_END()

STRUCT_BEGIN(fuchsia::sysmem, BufferCollectionConstraints)
STRUCT_ELEMENT(usage)
STRUCT_ELEMENT(min_buffer_count_for_camping)
STRUCT_ELEMENT(min_buffer_count_for_dedicated_slack)
STRUCT_ELEMENT(min_buffer_count_for_shared_slack)
STRUCT_ELEMENT(min_buffer_count)
STRUCT_ELEMENT(max_buffer_count)
STRUCT_ELEMENT(has_buffer_memory_constraints)
STRUCT_ELEMENT(buffer_memory_constraints)
STRUCT_ELEMENT(image_format_constraints_count)
STRUCT_ELEMENT(image_format_constraints)
STRUCT_END()

STRUCT_BEGIN(fuchsia::sysmem, BufferCollectionInfo_2)
STRUCT_ELEMENT(buffer_count)
STRUCT_ELEMENT(settings)
STRUCT_ELEMENT(buffers)
STRUCT_END()

STRUCT_BEGIN(fuchsia::camera2, FrameRate)
STRUCT_ELEMENT(frames_per_sec_numerator)
STRUCT_ELEMENT(frames_per_sec_denominator)
STRUCT_END()

TABLE_BEGIN(fuchsia::camera2, FrameMetadata)
TABLE_ELEMENT(timestamp);
TABLE_ELEMENT(image_format_index);
TABLE_ELEMENT(capture_timestamp);
TABLE_END()

TABLE_BEGIN(fuchsia::camera2, DeviceInfo)
TABLE_ELEMENT(vendor_id)
TABLE_ELEMENT(vendor_name)
TABLE_ELEMENT(product_id)
TABLE_ELEMENT(product_name)
TABLE_ELEMENT(type)
TABLE_END()

TABLE_BEGIN(fuchsia::camera2, StreamProperties)
TABLE_ELEMENT(stream_type)
TABLE_END()

STRUCT_BEGIN(fuchsia::camera2, FrameAvailableInfo)
STRUCT_ELEMENT(frame_status)
STRUCT_ELEMENT(buffer_id)
STRUCT_ELEMENT(metadata)
STRUCT_END()

TABLE_BEGIN(fuchsia::camera2, StreamConstraints)
TABLE_ELEMENT(properties)
TABLE_ELEMENT(format_index)
TABLE_END()

STRUCT_BEGIN(fuchsia::camera2::hal, Config)
STRUCT_ELEMENT(stream_configs)
STRUCT_END()

STRUCT_BEGIN(fuchsia::camera2::hal, StreamConfig)
STRUCT_ELEMENT(frame_rate)
STRUCT_ELEMENT(constraints)
STRUCT_ELEMENT(properties)
STRUCT_ELEMENT(image_formats)
STRUCT_END()