// Copyright (c) 2013 The Chromium OS 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 "mist/usb_interface.h"

#include <libusb.h>

#include <base/logging.h>
#include <base/strings/stringprintf.h>

#include "mist/usb_device.h"
#include "mist/usb_interface_descriptor.h"

using base::StringPrintf;

namespace mist {

UsbInterface::UsbInterface(const base::WeakPtr<UsbDevice>& device,
                           const libusb_interface* interface)
    : device_(device), interface_(interface) {
  CHECK(interface_);
}

int UsbInterface::GetNumAlternateSettings() const {
  return interface_->num_altsetting;
}

UsbInterfaceDescriptor* UsbInterface::GetAlternateSetting(int index) const {
  if (index < 0 || index >= GetNumAlternateSettings()) {
    LOG(ERROR) << StringPrintf(
        "Invalid alternate setting index %d. "
        "Must be non-negative and less than %d.",
        index, GetNumAlternateSettings());
    return nullptr;
  }

  return new UsbInterfaceDescriptor(device_, &interface_->altsetting[index]);
}

}  // namespace mist
