// Copyright 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 "components/usb_service/usb_device_filter.h"

#include "base/values.h"
#include "components/usb_service/usb_device.h"
#include "components/usb_service/usb_device_handle.h"
#include "components/usb_service/usb_interface.h"

namespace usb_service {

namespace {

const char kProductIdKey[] = "productId";
const char kVendorIdKey[] = "vendorId";
const char kInterfaceClassKey[] = "interfaceClass";
const char kInterfaceSubclassKey[] = "interfaceSubclass";
const char kInterfaceProtocolKey[] = "interfaceProtocol";

}  // namespace

UsbDeviceFilter::UsbDeviceFilter()
    : vendor_id_set_(false),
      product_id_set_(false),
      interface_class_set_(false),
      interface_subclass_set_(false),
      interface_protocol_set_(false) {
}

UsbDeviceFilter::~UsbDeviceFilter() {
}

void UsbDeviceFilter::SetVendorId(uint16 vendor_id) {
  vendor_id_set_ = true;
  vendor_id_ = vendor_id;
}

void UsbDeviceFilter::SetProductId(uint16 product_id) {
  product_id_set_ = true;
  product_id_ = product_id;
}

void UsbDeviceFilter::SetInterfaceClass(uint8 interface_class) {
  interface_class_set_ = true;
  interface_class_ = interface_class;
}

void UsbDeviceFilter::SetInterfaceSubclass(uint8 interface_subclass) {
  interface_subclass_set_ = true;
  interface_subclass_ = interface_subclass;
}

void UsbDeviceFilter::SetInterfaceProtocol(uint8 interface_protocol) {
  interface_protocol_set_ = true;
  interface_protocol_ = interface_protocol;
}

bool UsbDeviceFilter::Matches(scoped_refptr<UsbDevice> device) {
  if (vendor_id_set_) {
    if (device->vendor_id() != vendor_id_) {
      return false;
    }

    if (product_id_set_ && device->product_id() != product_id_) {
      return false;
    }
  }

  if (interface_class_set_) {
    bool foundMatch = false;
    scoped_refptr<const UsbConfigDescriptor> config = device->ListInterfaces();

    // TODO(reillyg): Check device configuration if the class is not defined at
    // a per-interface level. This is not really important because most devices
    // have per-interface classes. The only counter-examples I know of are hubs.

    for (size_t i = 0; i < config->GetNumInterfaces() && !foundMatch; ++i) {
      scoped_refptr<const UsbInterfaceDescriptor> iface =
          config->GetInterface(i);

      for (size_t j = 0; j < iface->GetNumAltSettings() && !foundMatch; ++j) {
        scoped_refptr<const UsbInterfaceAltSettingDescriptor> altSetting =
            iface->GetAltSetting(j);

        if (altSetting->GetInterfaceClass() == interface_class_ &&
            (!interface_subclass_set_ ||
             (altSetting->GetInterfaceSubclass() == interface_subclass_ &&
              (!interface_protocol_set_ ||
               altSetting->GetInterfaceProtocol() == interface_protocol_)))) {
          foundMatch = true;
        }
      }
    }

    if (!foundMatch) {
      return false;
    }
  }

  return true;
}

base::Value* UsbDeviceFilter::ToValue() const {
  scoped_ptr<base::DictionaryValue> obj(new base::DictionaryValue());

  if (vendor_id_set_) {
    obj->SetInteger(kVendorIdKey, vendor_id_);
    if (product_id_set_) {
      obj->SetInteger(kProductIdKey, product_id_);
    }
  }

  if (interface_class_set_) {
    obj->SetInteger(kInterfaceClassKey, interface_class_);
    if (interface_subclass_set_) {
      obj->SetInteger(kInterfaceSubclassKey, interface_subclass_);
      if (interface_protocol_set_) {
        obj->SetInteger(kInterfaceProtocolKey, interface_protocol_);
      }
    }
  }

  return obj.release();
}

}  // namespace usb_service