// Copyright 2019 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 "hid-instance.h"

#include <lib/driver/logging/cpp/logger.h>
#include <lib/hid/boot.h>
#include <lib/trace/event.h>

#include "hid.h"

namespace hid_driver {

namespace fhidbus = fuchsia_hardware_hidbus;

namespace {

constexpr uint32_t kHidFlagsDead = (1 << 0);
constexpr uint32_t kHidFlagsWriteFailed = (1 << 1);

constexpr uint64_t hid_report_trace_id(uint32_t instance_id, uint64_t report_id) {
  return (report_id << 32) | instance_id;
}

}  // namespace

HidInstance::HidInstance(HidDevice* base, zx::event fifo_event,
                         fidl::ServerEnd<fuchsia_hardware_input::Device> session)
    : base_(base),
      fifo_event_(std::move(fifo_event)),
      binding_(fdf::Dispatcher::GetCurrent()->async_dispatcher(), std::move(session), this,
               [](HidInstance* instance, fidl::UnbindInfo info) {
                 if (!instance) {
                   return;
                 }
                 instance->CloseInstance();
                 instance->base_->RemoveInstance(*instance);
               }) {
  zx_hid_fifo_init(&fifo_);
}

void HidInstance::SetReadable() { fifo_event_.signal(0, ZX_USER_SIGNAL_0); }

void HidInstance::ClearReadable() { fifo_event_.signal(ZX_USER_SIGNAL_0, 0); }

zx_status_t HidInstance::ReadReportFromFifo(uint8_t* buf, size_t buf_size, zx_time_t* time,
                                            size_t* report_size) {
  uint8_t rpt_id;
  if (zx_hid_fifo_peek(&fifo_, &rpt_id) <= 0) {
    return ZX_ERR_SHOULD_WAIT;
  }

  size_t xfer = base_->GetReportSizeById(rpt_id, fhidbus::ReportType::kInput);
  if (xfer == 0) {
    fdf::error("error reading hid device: unknown report id ({})!", rpt_id);
    return ZX_ERR_BAD_STATE;
  }

  // Check if we have enough room left in the buffer.
  if (xfer > buf_size) {
    return ZX_ERR_BUFFER_TOO_SMALL;
  }

  ssize_t rpt_size = zx_hid_fifo_read(&fifo_, buf, xfer);
  if (rpt_size <= 0) {
    // Something went wrong. The fifo should always contain full reports in it.
    return ZX_ERR_INTERNAL;
  }

  size_t left = zx_hid_fifo_size(&fifo_);
  if (left == 0) {
    ClearReadable();
  }

  *report_size = rpt_size;

  *time = timestamps_.front();
  timestamps_.pop();

  reports_sent_ += 1;
  TRACE_FLOW_STEP("input", "hid_report", hid_report_trace_id(trace_id_, reports_sent_));

  return ZX_OK;
}

void HidInstance::ReadReport(ReadReportCompleter::Sync& completer) {
  TRACE_DURATION("input", "HID ReadReport Instance", "bytes_in_fifo", zx_hid_fifo_size(&fifo_));

  if (flags_ & kHidFlagsDead) {
    completer.Close(ZX_ERR_BAD_STATE);
    return;
  }

  std::array<uint8_t, fhidbus::wire::kMaxReportData> buf;
  zx_time_t time = 0;
  size_t report_size = 0;
  zx_status_t status = ReadReportFromFifo(buf.data(), buf.size(), &time, &report_size);
  if (status != ZX_OK) {
    return completer.ReplyError(status);
  }

  auto buf_view = fidl::VectorView<uint8_t>::FromExternal(buf.data(), report_size);
  fidl::Arena arena;
  auto report = fhidbus::wire::Report::Builder(arena).buf(buf_view).timestamp(time);
  completer.ReplySuccess(report.Build());
}

void HidInstance::ReadReports(ReadReportsCompleter::Sync& completer) {
  TRACE_DURATION("input", "HID GetReports Instance", "bytes_in_fifo", zx_hid_fifo_size(&fifo_));

  if (flags_ & kHidFlagsDead) {
    completer.Close(ZX_ERR_BAD_STATE);
    return;
  }

  std::array<uint8_t, fhidbus::wire::kMaxReportData> buf;
  size_t buf_index = 0;
  zx_status_t status = ZX_OK;
  zx_time_t time;

  while (status == ZX_OK) {
    size_t report_size;
    status =
        ReadReportFromFifo(buf.data() + buf_index, buf.size() - buf_index, &time, &report_size);
    if (status == ZX_OK) {
      buf_index += report_size;
    }
  }

  if ((buf_index > 0) && ((status == ZX_ERR_BUFFER_TOO_SMALL) || (status == ZX_ERR_SHOULD_WAIT))) {
    status = ZX_OK;
  }

  if (status != ZX_OK) {
    completer.ReplyError(status);
    return;
  }

  auto buf_view = fidl::VectorView<uint8_t>::FromExternal(buf.data(), buf_index);
  completer.ReplySuccess(buf_view);
}

void HidInstance::GetReportsEvent(GetReportsEventCompleter::Sync& completer) {
  zx::event new_event;
  zx_status_t status = fifo_event_.duplicate(ZX_RIGHTS_BASIC, &new_event);
  if (status != ZX_OK) {
    return completer.ReplyError(status);
  }

  completer.ReplySuccess(std::move(new_event));
}

void HidInstance::Query(QueryCompleter::Sync& completer) {
  fidl::Arena arena;
  completer.ReplySuccess(fidl::ToWire(arena, base_->GetHidInfo()));
}

void HidInstance::GetReportDesc(GetReportDescCompleter::Sync& completer) {
  size_t desc_size = base_->GetReportDescLen();
  const uint8_t* desc = base_->GetReportDesc();

  // (BUG 35762) Const cast is necessary until simple data types are generated
  // as const in LLCPP. We know the data is not modified.
  completer.Reply(fidl::VectorView<uint8_t>::FromExternal(const_cast<uint8_t*>(desc), desc_size));
}

void HidInstance::GetReport(GetReportRequestView request, GetReportCompleter::Sync& completer) {
  size_t needed = base_->GetReportSizeById(request->id, request->type);
  if (needed == 0) {
    completer.ReplyError(ZX_ERR_NOT_FOUND);
    return;
  }
  if (needed > fhidbus::kMaxReportLen) {
    fdf::error("hid: GetReport: Report size {:#x} larger than max size {:#x}", needed,
               fhidbus::kMaxReportLen);
    completer.ReplyError(ZX_ERR_INTERNAL);
    return;
  }

  auto& client = base_->GetHidbusProtocol();
  auto result = client.sync()->GetReport(request->type, request->id, needed);
  if (!result.ok()) {
    fdf::error("FIDL transport failed on GetReport(): {}", result.error().FormatDescription());
    completer.ReplyError(result.status());
    return;
  }
  if (result->is_error()) {
    fdf::error("HID device failed to get report: {}", result->error_value());
    completer.ReplyError(result->error_value());
    return;
  }

  completer.ReplySuccess(result.value()->data);
}

void HidInstance::SetReport(SetReportRequestView request, SetReportCompleter::Sync& completer) {
  size_t needed = base_->GetReportSizeById(request->id, request->type);
  if (needed != request->report.size()) {
    fdf::error("Tried to set Report {} (size {:#x}) with {:#x} bytes", request->id, needed,
               request->report.size());
    completer.ReplyError(ZX_ERR_INVALID_ARGS);
    return;
  }

  auto& client = base_->GetHidbusProtocol();
  auto result = client.sync()->SetReport(request->type, request->id, request->report);
  if (!result.ok()) {
    fdf::error("FIDL transport failed on SetReport(): {}", result.error().FormatDescription());
    completer.ReplyError(result.status());
    return;
  }
  if (result->is_error()) {
    fdf::error("HID device failed to set report: {}", result->error_value());
    completer.ReplyError(result->error_value());
    return;
  }
  completer.ReplySuccess();
}

void HidInstance::GetDeviceReportsReader(GetDeviceReportsReaderRequestView request,
                                         GetDeviceReportsReaderCompleter::Sync& completer) {
  readers_binding_.AddBinding(fdf::Dispatcher::GetCurrent()->async_dispatcher(),
                              std::move(request->reader), &readers_.emplace_back(base_),
                              fidl::kIgnoreBindingClosure);
  completer.ReplySuccess();
}

void HidInstance::SetTraceId(SetTraceIdRequestView request, SetTraceIdCompleter::Sync& completer) {
  trace_id_ = request->id;
}

void HidInstance::CloseInstance() {
  flags_ |= kHidFlagsDead;
  SetReadable();
}

void HidInstance::WriteToFifo(const uint8_t* report, size_t report_len, zx_time_t time) {
  auto iter = readers_.begin();
  while (iter != readers_.end()) {
    if ((*iter).WriteToFifo(report, report_len, time) != ZX_OK) {
      iter = readers_.erase(iter);
    } else {
      iter++;
    }
  }

  if (timestamps_.full()) {
    flags_ |= kHidFlagsWriteFailed;
    return;
  }

  bool was_empty = zx_hid_fifo_size(&fifo_) == 0;

  ssize_t wrote = zx_hid_fifo_write(&fifo_, report, report_len);
  if (wrote <= 0) {
    if (!(flags_ & kHidFlagsWriteFailed)) {
      fdf::error("Could not write to hid fifo (ret={})", wrote);
      flags_ |= kHidFlagsWriteFailed;
    }
    return;
  }

  timestamps_.push(time);

  TRACE_FLOW_BEGIN("input", "hid_report", hid_report_trace_id(trace_id_, reports_written_));
  ++reports_written_;
  flags_ &= ~kHidFlagsWriteFailed;
  if (was_empty) {
    SetReadable();
  }
}

void HidInstance::SetWakeLease(const zx::eventpair& wake_lease) {
  for (auto& reader : readers_) {
    reader.SetWakeLease(wake_lease);
  }
}

}  // namespace hid_driver