// Copyright (c) 2014 The Chromium 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 <sstream>

#include "device/hid/hid_report_descriptor.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

using namespace testing;

namespace device {

namespace {

std::ostream& operator<<(std::ostream& os,
                         const HidUsageAndPage::Page& usage_page) {
  switch (usage_page) {
    case HidUsageAndPage::kPageUndefined:
      os << "Undefined";
      break;
    case HidUsageAndPage::kPageGenericDesktop:
      os << "Generic Desktop";
      break;
    case HidUsageAndPage::kPageSimulation:
      os << "Simulation";
      break;
    case HidUsageAndPage::kPageVirtualReality:
      os << "Virtual Reality";
      break;
    case HidUsageAndPage::kPageSport:
      os << "Sport";
      break;
    case HidUsageAndPage::kPageGame:
      os << "Game";
      break;
    case HidUsageAndPage::kPageKeyboard:
      os << "Keyboard";
      break;
    case HidUsageAndPage::kPageLed:
      os << "Led";
      break;
    case HidUsageAndPage::kPageButton:
      os << "Button";
      break;
    case HidUsageAndPage::kPageOrdinal:
      os << "Ordinal";
      break;
    case HidUsageAndPage::kPageTelephony:
      os << "Telephony";
      break;
    case HidUsageAndPage::kPageConsumer:
      os << "Consumer";
      break;
    case HidUsageAndPage::kPageDigitizer:
      os << "Digitizer";
      break;
    case HidUsageAndPage::kPagePidPage:
      os << "Pid Page";
      break;
    case HidUsageAndPage::kPageUnicode:
      os << "Unicode";
      break;
    case HidUsageAndPage::kPageAlphanumericDisplay:
      os << "Alphanumeric Display";
      break;
    case HidUsageAndPage::kPageMedicalInstruments:
      os << "Medical Instruments";
      break;
    case HidUsageAndPage::kPageMonitor0:
      os << "Monitor 0";
      break;
    case HidUsageAndPage::kPageMonitor1:
      os << "Monitor 1";
      break;
    case HidUsageAndPage::kPageMonitor2:
      os << "Monitor 2";
      break;
    case HidUsageAndPage::kPageMonitor3:
      os << "Monitor 3";
      break;
    case HidUsageAndPage::kPagePower0:
      os << "Power 0";
      break;
    case HidUsageAndPage::kPagePower1:
      os << "Power 1";
      break;
    case HidUsageAndPage::kPagePower2:
      os << "Power 2";
      break;
    case HidUsageAndPage::kPagePower3:
      os << "Power 3";
      break;
    case HidUsageAndPage::kPageBarCodeScanner:
      os << "Bar Code Scanner";
      break;
    case HidUsageAndPage::kPageScale:
      os << "Scale";
      break;
    case HidUsageAndPage::kPageMagneticStripeReader:
      os << "Magnetic Stripe Reader";
      break;
    case HidUsageAndPage::kPageReservedPointOfSale:
      os << "Reserved Point Of Sale";
      break;
    case HidUsageAndPage::kPageCameraControl:
      os << "Camera Control";
      break;
    case HidUsageAndPage::kPageArcade:
      os << "Arcade";
      break;
    case HidUsageAndPage::kPageVendor:
      os << "Vendor";
      break;
    case HidUsageAndPage::kPageMediaCenter:
      os << "Media Center";
      break;
    default:
      NOTREACHED();
      break;
  }
  return os;
}

std::ostream& operator<<(std::ostream& os,
                         const HidUsageAndPage& usage_and_page) {
  os << "Usage Page: " << usage_and_page.usage_page << ", Usage: "
     << "0x" << std::hex << std::uppercase << usage_and_page.usage;
  return os;
}

std::ostream& operator<<(std::ostream& os,
                         const HidReportDescriptorItem::Tag& tag) {
  switch (tag) {
    case HidReportDescriptorItem::kTagDefault:
      os << "Default";
      break;
    case HidReportDescriptorItem::kTagInput:
      os << "Input";
      break;
    case HidReportDescriptorItem::kTagOutput:
      os << "Output";
      break;
    case HidReportDescriptorItem::kTagFeature:
      os << "Feature";
      break;
    case HidReportDescriptorItem::kTagCollection:
      os << "Collection";
      break;
    case HidReportDescriptorItem::kTagEndCollection:
      os << "End Collection";
      break;
    case HidReportDescriptorItem::kTagUsagePage:
      os << "Usage Page";
      break;
    case HidReportDescriptorItem::kTagLogicalMinimum:
      os << "Logical Minimum";
      break;
    case HidReportDescriptorItem::kTagLogicalMaximum:
      os << "Logical Maximum";
      break;
    case HidReportDescriptorItem::kTagPhysicalMinimum:
      os << "Physical Minimum";
      break;
    case HidReportDescriptorItem::kTagPhysicalMaximum:
      os << "Physical Maximum";
      break;
    case HidReportDescriptorItem::kTagUnitExponent:
      os << "Unit Exponent";
      break;
    case HidReportDescriptorItem::kTagUnit:
      os << "Unit";
      break;
    case HidReportDescriptorItem::kTagReportSize:
      os << "Report Size";
      break;
    case HidReportDescriptorItem::kTagReportId:
      os << "Report ID";
      break;
    case HidReportDescriptorItem::kTagReportCount:
      os << "Report Count";
      break;
    case HidReportDescriptorItem::kTagPush:
      os << "Push";
      break;
    case HidReportDescriptorItem::kTagPop:
      os << "Pop";
      break;
    case HidReportDescriptorItem::kTagUsage:
      os << "Usage";
      break;
    case HidReportDescriptorItem::kTagUsageMinimum:
      os << "Usage Minimum";
      break;
    case HidReportDescriptorItem::kTagUsageMaximum:
      os << "Usage Maximum";
      break;
    case HidReportDescriptorItem::kTagDesignatorIndex:
      os << "Designator Index";
      break;
    case HidReportDescriptorItem::kTagDesignatorMinimum:
      os << "Designator Minimum";
      break;
    case HidReportDescriptorItem::kTagDesignatorMaximum:
      os << "Designator Maximum";
      break;
    case HidReportDescriptorItem::kTagStringIndex:
      os << "String Index";
      break;
    case HidReportDescriptorItem::kTagStringMinimum:
      os << "String Minimum";
      break;
    case HidReportDescriptorItem::kTagStringMaximum:
      os << "String Maximum";
      break;
    case HidReportDescriptorItem::kTagDelimiter:
      os << "Delimeter";
      break;
    case HidReportDescriptorItem::kTagLong:
      os << "Long";
      break;
    default:
      NOTREACHED();
      break;
  }

  return os;
}

std::ostream& operator<<(std::ostream& os,
                         const HidReportDescriptorItem::ReportInfo& data) {
  if (data.data_or_constant)
    os << "Con";
  else
    os << "Dat";
  if (data.array_or_variable)
    os << "|Arr";
  else
    os << "|Var";
  if (data.absolute_or_relative)
    os << "|Abs";
  else
    os << "|Rel";
  if (data.wrap)
    os << "|Wrp";
  else
    os << "|NoWrp";
  if (data.linear)
    os << "|NoLin";
  else
    os << "|Lin";
  if (data.preferred)
    os << "|NoPrf";
  else
    os << "|Prf";
  if (data.null)
    os << "|Null";
  else
    os << "|NoNull";
  if (data.bit_field_or_buffer)
    os << "|Buff";
  else
    os << "|BitF";
  return os;
}

std::ostream& operator<<(std::ostream& os,
                         const HidReportDescriptorItem::CollectionType& type) {
  switch (type) {
    case HidReportDescriptorItem::kCollectionTypePhysical:
      os << "Physical";
      break;
    case HidReportDescriptorItem::kCollectionTypeApplication:
      os << "Application";
      break;
    case HidReportDescriptorItem::kCollectionTypeLogical:
      os << "Logical";
      break;
    case HidReportDescriptorItem::kCollectionTypeReport:
      os << "Report";
      break;
    case HidReportDescriptorItem::kCollectionTypeNamedArray:
      os << "Named Array";
      break;
    case HidReportDescriptorItem::kCollectionTypeUsageSwitch:
      os << "Usage Switch";
      break;
    case HidReportDescriptorItem::kCollectionTypeUsageModifier:
      os << "Usage Modifier";
      break;
    case HidReportDescriptorItem::kCollectionTypeReserved:
      os << "Reserved";
      break;
    case HidReportDescriptorItem::kCollectionTypeVendor:
      os << "Vendor";
      break;
    default:
      NOTREACHED();
      break;
  }
  return os;
}

std::ostream& operator<<(std::ostream& os,
                         const HidReportDescriptorItem& item) {
  HidReportDescriptorItem::Tag item_tag = item.tag();
  uint32_t data = item.GetShortData();

  std::ostringstream sstr;
  sstr << item_tag;
  sstr << " (";

  long pos = sstr.tellp();
  switch (item_tag) {
    case HidReportDescriptorItem::kTagDefault:
    case HidReportDescriptorItem::kTagEndCollection:
    case HidReportDescriptorItem::kTagPush:
    case HidReportDescriptorItem::kTagPop:
    case HidReportDescriptorItem::kTagLong:
      break;

    case HidReportDescriptorItem::kTagCollection:
      sstr << HidReportDescriptorItem::GetCollectionTypeFromValue(data);
      break;

    case HidReportDescriptorItem::kTagInput:
    case HidReportDescriptorItem::kTagOutput:
    case HidReportDescriptorItem::kTagFeature:
      sstr << (HidReportDescriptorItem::ReportInfo&)data;
      break;

    case HidReportDescriptorItem::kTagUsagePage:
      sstr << (HidUsageAndPage::Page)data;
      break;

    case HidReportDescriptorItem::kTagUsage:
    case HidReportDescriptorItem::kTagReportId:
      sstr << "0x" << std::hex << std::uppercase << data;
      break;

    default:
      sstr << data;
      break;
  }
  if (pos == sstr.tellp()) {
    std::string str = sstr.str();
    str.erase(str.end() - 2, str.end());
    os << str;
  } else {
    os << sstr.str() << ")";
  }

  return os;
}

const char kIndentStep[] = " ";

std::ostream& operator<<(std::ostream& os,
                         const HidReportDescriptor& descriptor) {
  for (std::vector<linked_ptr<HidReportDescriptorItem> >::const_iterator
           items_iter = descriptor.items().begin();
       items_iter != descriptor.items().end();
       ++items_iter) {
    linked_ptr<HidReportDescriptorItem> item = *items_iter;
    size_t indentLevel = item->GetDepth();
    for (size_t i = 0; i < indentLevel; i++)
      os << kIndentStep;
    os << *item.get() << std::endl;
  }
  return os;
}

// See 'E.6 Report Descriptor (Keyboard)'
// in HID specifications (v1.11)
const uint8_t kKeyboard[] = {
    0x05, 0x01, 0x09, 0x06, 0xA1, 0x01, 0x05, 0x07, 0x19, 0xE0, 0x29,
    0xE7, 0x15, 0x00, 0x25, 0x01, 0x75, 0x01, 0x95, 0x08, 0x81, 0x02,
    0x95, 0x01, 0x75, 0x08, 0x81, 0x01, 0x95, 0x05, 0x75, 0x01, 0x05,
    0x08, 0x19, 0x01, 0x29, 0x05, 0x91, 0x02, 0x95, 0x01, 0x75, 0x03,
    0x91, 0x01, 0x95, 0x06, 0x75, 0x08, 0x15, 0x00, 0x25, 0x65, 0x05,
    0x07, 0x19, 0x00, 0x29, 0x65, 0x81, 0x00, 0xC0};

// See 'E.10 Report Descriptor (Mouse)'
// in HID specifications (v1.11)
const uint8_t kMouse[] = {0x05, 0x01, 0x09, 0x02, 0xA1, 0x01, 0x09, 0x01, 0xA1,
                          0x00, 0x05, 0x09, 0x19, 0x01, 0x29, 0x03, 0x15, 0x00,
                          0x25, 0x01, 0x95, 0x03, 0x75, 0x01, 0x81, 0x02, 0x95,
                          0x01, 0x75, 0x05, 0x81, 0x01, 0x05, 0x01, 0x09, 0x30,
                          0x09, 0x31, 0x15, 0x81, 0x25, 0x7F, 0x75, 0x08, 0x95,
                          0x02, 0x81, 0x06, 0xC0, 0xC0};

const uint8_t kLogitechUnifyingReceiver[] = {
    0x06, 0x00, 0xFF, 0x09, 0x01, 0xA1, 0x01, 0x85, 0x10, 0x75, 0x08,
    0x95, 0x06, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x09, 0x01, 0x81, 0x00,
    0x09, 0x01, 0x91, 0x00, 0xC0, 0x06, 0x00, 0xFF, 0x09, 0x02, 0xA1,
    0x01, 0x85, 0x11, 0x75, 0x08, 0x95, 0x13, 0x15, 0x00, 0x26, 0xFF,
    0x00, 0x09, 0x02, 0x81, 0x00, 0x09, 0x02, 0x91, 0x00, 0xC0, 0x06,
    0x00, 0xFF, 0x09, 0x04, 0xA1, 0x01, 0x85, 0x20, 0x75, 0x08, 0x95,
    0x0E, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x09, 0x41, 0x81, 0x00, 0x09,
    0x41, 0x91, 0x00, 0x85, 0x21, 0x95, 0x1F, 0x15, 0x00, 0x26, 0xFF,
    0x00, 0x09, 0x42, 0x81, 0x00, 0x09, 0x42, 0x91, 0x00, 0xC0};

}  // namespace

class HidReportDescriptorTest : public testing::Test {

 protected:
  virtual void SetUp() OVERRIDE { descriptor_ = NULL; }

  virtual void TearDown() OVERRIDE {
    if (descriptor_) {
      delete descriptor_;
    }
  }

 public:
  void ParseDescriptor(const std::string& expected,
                       const uint8_t* bytes,
                       size_t size) {
    descriptor_ = new HidReportDescriptor(bytes, size);

    std::stringstream actual;
    actual << *descriptor_;

    std::cout << "HID report descriptor:" << std::endl;
    std::cout << actual.str();

    // TODO(jracle@logitech.com): refactor string comparison in favor of
    // testing individual fields.
    ASSERT_EQ(expected, actual.str());
  }

  void GetTopLevelCollections(const std::vector<HidUsageAndPage>& expected,
                              const uint8_t* bytes,
                              size_t size) {
    descriptor_ = new HidReportDescriptor(bytes, size);

    std::vector<HidUsageAndPage> actual;
    descriptor_->GetTopLevelCollections(&actual);

    std::cout << "HID top-level collections:" << std::endl;
    for (std::vector<HidUsageAndPage>::const_iterator iter = actual.begin();
         iter != actual.end();
         ++iter) {
      std::cout << *iter << std::endl;
    }

    ASSERT_THAT(actual, ContainerEq(expected));
  }

 private:
  HidReportDescriptor* descriptor_;
};

TEST_F(HidReportDescriptorTest, ParseDescriptor_Keyboard) {
  const char expected[] = {
      "Usage Page (Generic Desktop)\n"
      "Usage (0x6)\n"
      "Collection (Physical)\n"
      " Usage Page (Keyboard)\n"
      " Usage Minimum (224)\n"
      " Usage Maximum (231)\n"
      " Logical Minimum (0)\n"
      " Logical Maximum (1)\n"
      " Report Size (1)\n"
      " Report Count (8)\n"
      " Input (Dat|Arr|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n"
      " Report Count (1)\n"
      " Report Size (8)\n"
      " Input (Con|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n"
      " Report Count (5)\n"
      " Report Size (1)\n"
      " Usage Page (Led)\n"
      " Usage Minimum (1)\n"
      " Usage Maximum (5)\n"
      " Output (Dat|Arr|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n"
      " Report Count (1)\n"
      " Report Size (3)\n"
      " Output (Con|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n"
      " Report Count (6)\n"
      " Report Size (8)\n"
      " Logical Minimum (0)\n"
      " Logical Maximum (101)\n"
      " Usage Page (Keyboard)\n"
      " Usage Minimum (0)\n"
      " Usage Maximum (101)\n"
      " Input (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n"
      "End Collection\n"};

  ParseDescriptor(std::string(expected), kKeyboard, sizeof(kKeyboard));
}

TEST_F(HidReportDescriptorTest, TopLevelCollections_Keyboard) {
  HidUsageAndPage expected[] = {
      HidUsageAndPage(0x06, HidUsageAndPage::kPageGenericDesktop)};

  GetTopLevelCollections(std::vector<HidUsageAndPage>(
                             expected, expected + ARRAYSIZE_UNSAFE(expected)),
                         kKeyboard,
                         sizeof(kKeyboard));
}

TEST_F(HidReportDescriptorTest, ParseDescriptor_Mouse) {
  const char expected[] = {
      "Usage Page (Generic Desktop)\n"
      "Usage (0x2)\n"
      "Collection (Physical)\n"
      " Usage (0x1)\n"
      " Collection (Physical)\n"
      "  Usage Page (Button)\n"
      "  Usage Minimum (1)\n"
      "  Usage Maximum (3)\n"
      "  Logical Minimum (0)\n"
      "  Logical Maximum (1)\n"
      "  Report Count (3)\n"
      "  Report Size (1)\n"
      "  Input (Dat|Arr|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n"
      "  Report Count (1)\n"
      "  Report Size (5)\n"
      "  Input (Con|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n"
      "  Usage Page (Generic Desktop)\n"
      "  Usage (0x30)\n"
      "  Usage (0x31)\n"
      "  Logical Minimum (129)\n"
      "  Logical Maximum (127)\n"
      "  Report Size (8)\n"
      "  Report Count (2)\n"
      "  Input (Dat|Arr|Abs|NoWrp|Lin|Prf|NoNull|BitF)\n"
      " End Collection\n"
      "End Collection\n"};

  ParseDescriptor(std::string(expected), kMouse, sizeof(kMouse));
}

TEST_F(HidReportDescriptorTest, TopLevelCollections_Mouse) {
  HidUsageAndPage expected[] = {
      HidUsageAndPage(0x02, HidUsageAndPage::kPageGenericDesktop)};

  GetTopLevelCollections(std::vector<HidUsageAndPage>(
                             expected, expected + ARRAYSIZE_UNSAFE(expected)),
                         kMouse,
                         sizeof(kMouse));
}

TEST_F(HidReportDescriptorTest, ParseDescriptor_LogitechUnifyingReceiver) {
  const char expected[] = {
      "Usage Page (Vendor)\n"
      "Usage (0x1)\n"
      "Collection (Physical)\n"
      " Report ID (0x10)\n"
      " Report Size (8)\n"
      " Report Count (6)\n"
      " Logical Minimum (0)\n"
      " Logical Maximum (255)\n"
      " Usage (0x1)\n"
      " Input (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n"
      " Usage (0x1)\n"
      " Output (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n"
      "End Collection\n"
      "Usage Page (Vendor)\n"
      "Usage (0x2)\n"
      "Collection (Physical)\n"
      " Report ID (0x11)\n"
      " Report Size (8)\n"
      " Report Count (19)\n"
      " Logical Minimum (0)\n"
      " Logical Maximum (255)\n"
      " Usage (0x2)\n"
      " Input (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n"
      " Usage (0x2)\n"
      " Output (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n"
      "End Collection\n"
      "Usage Page (Vendor)\n"
      "Usage (0x4)\n"
      "Collection (Physical)\n"
      " Report ID (0x20)\n"
      " Report Size (8)\n"
      " Report Count (14)\n"
      " Logical Minimum (0)\n"
      " Logical Maximum (255)\n"
      " Usage (0x41)\n"
      " Input (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n"
      " Usage (0x41)\n"
      " Output (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n"
      " Report ID (0x21)\n"
      " Report Count (31)\n"
      " Logical Minimum (0)\n"
      " Logical Maximum (255)\n"
      " Usage (0x42)\n"
      " Input (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n"
      " Usage (0x42)\n"
      " Output (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n"
      "End Collection\n"};

  ParseDescriptor(std::string(expected),
                  kLogitechUnifyingReceiver,
                  sizeof(kLogitechUnifyingReceiver));
}

TEST_F(HidReportDescriptorTest, TopLevelCollections_LogitechUnifyingReceiver) {
  HidUsageAndPage expected[] = {
      HidUsageAndPage(0x01, HidUsageAndPage::kPageVendor),
      HidUsageAndPage(0x02, HidUsageAndPage::kPageVendor),
      HidUsageAndPage(0x04, HidUsageAndPage::kPageVendor), };

  GetTopLevelCollections(std::vector<HidUsageAndPage>(
                             expected, expected + ARRAYSIZE_UNSAFE(expected)),
                         kLogitechUnifyingReceiver,
                         sizeof(kLogitechUnifyingReceiver));
}

}  // namespace device