// Copyright 2023 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 <fidl/fuchsia.buttons/cpp/fidl.h>
#include <fidl/fuchsia.hardware.platform.bus/cpp/driver/fidl.h>
#include <fidl/fuchsia.hardware.platform.bus/cpp/fidl.h>
#include <lib/ddk/driver.h>
#include <lib/ddk/metadata.h>
#include <lib/ddk/platform-defs.h>
#include <lib/driver/component/cpp/composite_node_spec.h>
#include <lib/driver/component/cpp/node_add_args.h>

#include <bind/fuchsia/adc/cpp/bind.h>
#include <bind/fuchsia/amlogic/platform/a311d/cpp/bind.h>
#include <bind/fuchsia/cpp/bind.h>
#include <bind/fuchsia/gpio/cpp/bind.h>
#include <bind/fuchsia/hardware/adc/cpp/bind.h>
#include <bind/fuchsia/hardware/gpio/cpp/bind.h>
#include <ddk/metadata/buttons.h>
#include <soc/aml-a311d/a311d-hw.h>

#include "src/devices/board/drivers/vim3/vim3-adc.h"
#include "src/devices/board/drivers/vim3/vim3-gpios.h"
#include "src/devices/board/drivers/vim3/vim3.h"

namespace vim3 {
namespace fpbus = fuchsia_hardware_platform_bus;
using fuchsia_hardware_gpio::GpioFlags;
static const buttons_button_config_t buttons[] = {
    {BUTTONS_TYPE_DIRECT, BUTTONS_ID_POWER, 0, 0, 0},
};

static const buttons_gpio_config_t gpios[] = {
    {BUTTONS_GPIO_TYPE_INTERRUPT,
     BUTTONS_GPIO_FLAG_INVERTED | BUTTONS_GPIO_FLAG_WAKE_VECTOR,
     {.interrupt = {static_cast<uint32_t>(GpioFlags::kNoPull)}}},
};

zx::result<> Vim3::ButtonsInit() {
  // Power key.
  fidl::Arena<> fidl_arena;
  fdf::Arena buttons_arena('BTNS');

  fpbus::Node dev = {{.name = "vim3-buttons",
                      .vid = PDEV_VID_GENERIC,
                      .pid = PDEV_PID_GENERIC,
                      .did = PDEV_DID_BUTTONS,
                      .metadata = std::vector<fpbus::Metadata>{
                          {{.type = DEVICE_METADATA_BUTTONS_BUTTONS,
                            .data = std::vector<uint8_t>(
                                reinterpret_cast<const uint8_t*>(&buttons),
                                reinterpret_cast<const uint8_t*>(&buttons) + sizeof(buttons))}},
                          {{.type = DEVICE_METADATA_BUTTONS_GPIOS,
                            .data = std::vector<uint8_t>(
                                reinterpret_cast<const uint8_t*>(&gpios),
                                reinterpret_cast<const uint8_t*>(&gpios) + sizeof(gpios))}}}}};
  const std::vector<fuchsia_driver_framework::BindRule> kPowerButtonRules = {
      fdf::MakeAcceptBindRule(bind_fuchsia_hardware_gpio::SERVICE,
                              bind_fuchsia_hardware_gpio::SERVICE_ZIRCONTRANSPORT),
      fdf::MakeAcceptBindRule(bind_fuchsia::GPIO_CONTROLLER, VIM3_GPIO_ID),
      fdf::MakeAcceptBindRule(bind_fuchsia::GPIO_PIN,
                              bind_fuchsia_amlogic_platform_a311d::GPIOAO_PIN_ID_PIN_7)};
  const std::vector<fuchsia_driver_framework::NodeProperty> kPowerButtonProps = {
      fdf::MakeProperty(bind_fuchsia_hardware_gpio::SERVICE,
                        bind_fuchsia_hardware_gpio::SERVICE_ZIRCONTRANSPORT),
      fdf::MakeProperty(bind_fuchsia_gpio::FUNCTION, bind_fuchsia_gpio::FUNCTION_POWER),
  };
  std::vector<fuchsia_driver_framework::ParentSpec> parents = {
      fuchsia_driver_framework::ParentSpec{{
          .bind_rules = std::move(kPowerButtonRules),
          .properties = std::move(kPowerButtonProps),
      }}};

  fuchsia_driver_framework::CompositeNodeSpec buttonComposite = {
      {.name = "vim3-buttons", .parents = std::move(parents)}};

  fdf::WireUnownedResult gpio_buttons_result =
      pbus_.buffer(buttons_arena)
          ->AddCompositeNodeSpec(fidl::ToWire(fidl_arena, dev),
                                 fidl::ToWire(fidl_arena, buttonComposite));
  if (!gpio_buttons_result.ok()) {
    zxlogf(ERROR, "Failed to send AddCompositeNodeSpec request: %s",
           gpio_buttons_result.status_string());
    return zx::error(gpio_buttons_result.status());
  }
  if (gpio_buttons_result->is_error()) {
    zxlogf(ERROR, "AddCompositeNodeSpec error: %s",
           zx_status_get_string(gpio_buttons_result->error_value()));
    return gpio_buttons_result->take_error();
  }

  // Function Key
  fuchsia_hardware_platform_bus::Node adc_buttons;
  adc_buttons.name() = "buttons";
  adc_buttons.vid() = PDEV_VID_GENERIC;
  adc_buttons.pid() = PDEV_PID_GENERIC;
  adc_buttons.did() = PDEV_DID_ADC_BUTTONS;

  auto func_types = std::vector<fuchsia_input_report::ConsumerControlButton>{
      fuchsia_input_report::ConsumerControlButton::kFunction};
  auto func_adc_config =
      fuchsia_buttons::AdcButtonConfig().channel_idx(2).release_threshold(1'000).press_threshold(
          70);
  auto func_config = fuchsia_buttons::ButtonConfig::WithAdc(std::move(func_adc_config));
  auto func_button =
      fuchsia_buttons::Button().types(std::move(func_types)).button_config(std::move(func_config));
  std::vector<fuchsia_buttons::Button> buttons;
  buttons.emplace_back(std::move(func_button));

  // How long to wait between polling attempts.  This value should be large enough to ensure
  // polling does not overly impact system performance while being small enough to debounce and
  // ensure button presses are correctly registered.
  //
  // TODO(b/315366570): Change the driver to use an IRQ instead of polling.
  constexpr uint32_t kPollingPeriodUSec = 20'000;
  auto metadata =
      fuchsia_buttons::Metadata().polling_rate_usec(kPollingPeriodUSec).buttons(std::move(buttons));

  fit::result metadata_bytes = fidl::Persist(std::move(metadata));
  if (!metadata_bytes.is_ok()) {
    zxlogf(ERROR, "Could not build metadata %s",
           metadata_bytes.error_value().FormatDescription().c_str());
    return zx::error(metadata_bytes.error_value().status());
  }
  std::vector<fuchsia_hardware_platform_bus::Metadata> adc_buttons_metadata{
      {{
          .type = DEVICE_METADATA_BUTTONS,
          .data = metadata_bytes.value(),
      }},
  };
  adc_buttons.metadata() = std::move(adc_buttons_metadata);

  const std::vector<fuchsia_driver_framework::BindRule> kFunctionButtonCompositeRules = {
      fdf::MakeAcceptBindRule(bind_fuchsia_hardware_adc::SERVICE,
                              bind_fuchsia_hardware_adc::SERVICE_ZIRCONTRANSPORT),
      fdf::MakeAcceptBindRule(bind_fuchsia_adc::CHANNEL, VIM3_ADC_BUTTON),
  };
  const std::vector<fuchsia_driver_framework::NodeProperty> kFunctionButtonCompositeProperties = {
      fdf::MakeProperty(bind_fuchsia_hardware_adc::SERVICE,
                        bind_fuchsia_hardware_adc::SERVICE_ZIRCONTRANSPORT),
      fdf::MakeProperty(bind_fuchsia_adc::FUNCTION, bind_fuchsia_adc::FUNCTION_BUTTON),
      fdf::MakeProperty(bind_fuchsia_adc::CHANNEL, VIM3_ADC_BUTTON),
  };

  const std::vector<fuchsia_driver_framework::ParentSpec> kFunctionButtonParents = {
      fuchsia_driver_framework::ParentSpec{{.bind_rules = kFunctionButtonCompositeRules,
                                            .properties = kFunctionButtonCompositeProperties}}};
  auto result =
      pbus_.buffer(buttons_arena)
          ->AddCompositeNodeSpec(
              fidl::ToWire(fidl_arena, adc_buttons),
              fidl::ToWire(fidl_arena,
                           fuchsia_driver_framework::CompositeNodeSpec{
                               {.name = "function-button", .parents = kFunctionButtonParents}}));
  if (!result.ok()) {
    zxlogf(ERROR, "NodeAdd Buttons(adc_buttons) request failed: %s",
           result.FormatDescription().data());
    return result->take_error();
  }
  if (result->is_error()) {
    zxlogf(ERROR, "NodeAdd Buttons(adc_buttons) failed: %s",
           zx_status_get_string(result->error_value()));
    return result->take_error();
  }

  return zx::ok();
}

}  // namespace vim3