// 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 "garnet/bin/ui/input_reader/touch.h"

#include <hid-parser/parser.h>
#include <hid-parser/report.h>
#include <hid-parser/units.h>
#include <hid-parser/usages.h>

#include <stdint.h>
#include <stdio.h>
#include <vector>

#include "lib/fxl/logging.h"

namespace mozart {
bool Touch::ParseTouchDescriptor(const hid::ReportDescriptor &desc) {
  size_t touch_points = 0;
  TouchPointConfig configs[MAX_TOUCH_POINTS] = {};
  hid::Attributes scan_time = {};
  hid::Attributes contact_count = {};
  hid::Attributes button = {};
  hid::Collection *finger_collection;
  uint32_t caps = 0;

  for (size_t i = 0; i < desc.input_count; i++) {
    const hid::ReportField field = desc.input_fields[i];

    // Process the global items if we haven't seen them before
    if (!(caps & Capabilities::CONTACT_COUNT) &&
        (field.attr.usage ==
         hid::USAGE(hid::usage::Page::kDigitizer,
                    hid::usage::Digitizer::kContactCount))) {
      contact_count = field.attr;
      caps |= Capabilities::CONTACT_COUNT;
    }
    if (!(caps & Capabilities::SCAN_TIME) &&
        (field.attr.usage == hid::USAGE(hid::usage::Page::kDigitizer,
                                        hid::usage::Digitizer::kScanTime))) {
      scan_time = field.attr;
      caps |= Capabilities::SCAN_TIME;
    }

    if (!(caps & Capabilities::BUTTON) &&
        (field.attr.usage.page == hid::usage::Page::kButton)) {
      button = field.attr;
      caps |= Capabilities::BUTTON;
    }

    // Now we move on to processing touch points, so don't process the item if
    // it's not part of a touch point collection
    if (field.col->usage != hid::USAGE(hid::usage::Page::kDigitizer,
                                       hid::usage::Digitizer::kFinger)) {
      continue;
    }

    // If our collection pointer is different than the previous collection
    // pointer, we have started a new collection and are on a new touch point
    if (field.col != finger_collection) {
      finger_collection = field.col;
      touch_points++;
    }

    if (touch_points < 1) {
      FXL_LOG(ERROR)
          << "Touch descriptor: No touch points found in a collection";
      return false;
    }
    if (touch_points > MAX_TOUCH_POINTS) {
      FXL_LOG(ERROR) << "Touch descriptor: Current touchscreen has "
                     << touch_points
                     << " touch points which is above hardcoded limit of "
                     << MAX_TOUCH_POINTS;
      return false;
    }
    TouchPointConfig *config = &configs[touch_points - 1];

    if (field.attr.usage == hid::USAGE(hid::usage::Page::kDigitizer,
                                       hid::usage::Digitizer::kContactID)) {
      config->contact_id = field.attr;
      config->capabilities |= Capabilities::CONTACT_ID;
      if (config->contact_id.logc_mm.max > contact_id_max_) {
        contact_id_max_ = config->contact_id.logc_mm.max;
      }
    }
    if (field.attr.usage == hid::USAGE(hid::usage::Page::kDigitizer,
                                       hid::usage::Digitizer::kTipSwitch)) {
      config->tip_switch = field.attr;
      config->capabilities |= Capabilities::TIP_SWITCH;
    }
    if (field.attr.usage == hid::USAGE(hid::usage::Page::kGenericDesktop,
                                       hid::usage::GenericDesktop::kX)) {
      config->x = field.attr;
      config->capabilities |= Capabilities::X;
    }
    if (field.attr.usage == hid::USAGE(hid::usage::Page::kGenericDesktop,
                                       hid::usage::GenericDesktop::kY)) {
      config->y = field.attr;
      config->capabilities |= Capabilities::Y;
    }
  }

  if (touch_points == 0) {
    FXL_LOG(ERROR) << "Touch descriptor: Failed to find any touch points";
    return false;
  }

  // Ensure that all touch points have the same capabilities.
  for (size_t i = 1; i < touch_points; i++) {
    if (configs[i].capabilities != configs[0].capabilities) {
      FXL_LOG(ERROR)
          << "Touch descriptor: Touch point capabilities are different";
      for (size_t j = 0; j < touch_points; j++) {
        FXL_LOG(ERROR) << "Touch descriptor: touch_point[" << j
                       << "] = " << configs[i].capabilities;
      }
      return false;
    }
  }

  caps |= configs[0].capabilities;

  touch_points_ = touch_points;
  scan_time_ = scan_time;
  button_ = button;
  contact_count_ = contact_count;
  capabilities_ = caps;
  report_size_ = desc.input_byte_sz;
  report_id_ = desc.report_id;
  for (size_t i = 0; i < touch_points; i++) {
    configs_[i] = configs[i];
  }

  return true;
}

bool Touch::ParseReport(const uint8_t *data, size_t len, Report *report) const {
  assert(report != nullptr);

  if (len != report_size_) {
    FXL_LOG(ERROR) << "Touch HID Report is not correct size, (" << len
                   << " != " << report_size_ << ")";
    return false;
  }

  // X and Y will have units of 10^-5 meters
  hid::Unit length_unit = {};
  length_unit.exp = -5;
  hid::unit::SetSystem(length_unit, hid::unit::System::si_linear);
  hid::unit::SetLengthExp(length_unit, 1);

  size_t contact_count = 0;
  for (size_t i = 0; i < touch_points_; i++) {
    auto config = &configs_[i];

    if (config->capabilities & Capabilities::TIP_SWITCH) {
      uint8_t tip_switch;
      bool success =
          hid::ExtractUint(data, len, config->tip_switch, &tip_switch);
      if (!success || !tip_switch) {
        continue;
      }
    }
    auto contact = &report->contacts[contact_count];
    *contact = {};

    // XXX(konkers): Add 32 bit generic field extraction helpers.
    if (config->capabilities & Capabilities::CONTACT_ID) {
      if (!hid::ExtractUint(data, len, config->contact_id, &contact->id)) {
        FXL_LOG(ERROR) << "Touch report: Failed to parse CONTACT_ID";
        return false;
      }
    }
    if (config->capabilities & Capabilities::X) {
      double x;
      if (!hid::ExtractAsUnit(data, len, config->x, &x)) {
        FXL_LOG(ERROR) << "Touch report: Failed to parse X";
        return false;
      }
      // If this returns true, x was converted. If it returns false,
      // x is unchanged. Either way we return successfully.
      hid::unit::ConvertUnits(config->x.unit, x, length_unit, &x);
      contact->x = static_cast<int32_t>(x);
    }
    if (config->capabilities & Capabilities::Y) {
      double y;
      if (!hid::ExtractAsUnit(data, len, config->y, &y)) {
        FXL_LOG(ERROR) << "Touchpad report: Failed to parse Y";
        return false;
      }
      // If this returns true, x was converted. If it returns false,
      // x is unchanged. Either way we return successfully.
      hid::unit::ConvertUnits(config->y.unit, y, length_unit, &y);
      contact->y = static_cast<int32_t>(y);
    }

    // TODO(SCN-1188): Add support for contact ellipse.

    contact_count++;
  }

  report->contact_count = contact_count;

  if (capabilities_ & Capabilities::BUTTON) {
    uint8_t button;
    if (!hid::ExtractUint(data, len, button_, &button)) {
      FXL_LOG(ERROR) << "Touchpad report: Failed to parse BUTTON";
      return false;
    }
    report->button = (button == 1);
  }

  if (capabilities_ & Capabilities::SCAN_TIME) {
    // If we don't have a unit, extract the raw data
    if (scan_time_.unit.type == 0) {
      if (!hid::ExtractUint(data, len, scan_time_, &report->scan_time)) {
        return false;
      }
    } else {
      double scan_time;
      if (!hid::ExtractAsUnit(data, len, scan_time_, &scan_time)) {
        FXL_LOG(ERROR) << "Touchpad report: Failed to parse SCAN_TIME";
        return false;
      }

      hid::Unit time_unit = {};
      time_unit.exp = -6;
      hid::unit::SetSystem(time_unit, hid::unit::System::si_linear);
      hid::unit::SetTimeExp(time_unit, 1);
      // If this returns true, scan_time was converted. If it returns false,
      // scan_time is unchanged. Either way we return successfully.
      hid::unit::ConvertUnits(scan_time_.unit, scan_time, time_unit,
                              &scan_time);

      report->scan_time = static_cast<uint32_t>(scan_time);
    }
  }
  return true;
}

bool Touch::SetDescriptor(Touch::Descriptor *touch_desc) {
  // X and Y will have units of 10^-5 meters
  hid::Unit length_unit = {};
  length_unit.exp = -5;
  hid::unit::SetSystem(length_unit, hid::unit::System::si_linear);
  hid::unit::SetLengthExp(length_unit, 1);

  double val_out;

  if (hid::unit::ConvertUnits(configs_[0].x.unit, configs_[0].x.phys_mm.min,
                              length_unit, &val_out)) {
    touch_desc->x_min = static_cast<int32_t>(val_out);
  } else {
    touch_desc->x_min = configs_[0].x.phys_mm.min;
  }

  if (hid::unit::ConvertUnits(configs_[0].x.unit, configs_[0].x.phys_mm.max,
                              length_unit, &val_out)) {
    touch_desc->x_max = static_cast<int32_t>(val_out);
  } else {
    touch_desc->x_max = configs_[0].x.phys_mm.max;
  }
  touch_desc->x_resolution = 1;

  if (hid::unit::ConvertUnits(configs_[0].y.unit, configs_[0].y.phys_mm.min,
                              length_unit, &val_out)) {
    touch_desc->y_min = static_cast<int32_t>(val_out);
  } else {
    touch_desc->y_min = configs_[0].y.phys_mm.min;
  }

  if (hid::unit::ConvertUnits(configs_[0].y.unit, configs_[0].y.phys_mm.max,
                              length_unit, &val_out)) {
    touch_desc->y_max = static_cast<int32_t>(val_out);
  } else {
    touch_desc->y_max = configs_[0].y.phys_mm.max;
  }

  touch_desc->y_resolution = 1;

  touch_desc->max_finger_id = contact_id_max_;

  return true;
}

}  // namespace mozart