/****************************************************************************
**
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the tools applications of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "serenum.h"
#include <QByteArray>
#include <QString>
#include <QDebug>
#include <QFileInfo>
#include <QDir>

#include <usb.h>

class InterfaceInfo
{
public:
    InterfaceInfo(const QString &mf, const QString &pr, int mfid, int prid);
    QString manufacturer;
    QString product;
    int manufacturerid;
    int productid;
};

InterfaceInfo::InterfaceInfo(const QString &mf, const QString &pr, int mfid, int prid) :
    manufacturer(mf),
    product(pr),
    manufacturerid(mfid),
    productid(prid)
{
    if(mf.isEmpty())
        manufacturer = QString("[%1]").arg(mfid, 4, 16, QChar('0'));
    if(pr.isEmpty())
        product = QString("[%1]").arg(prid, 4, 16, QChar('0'));
}

QList<SerialPortId> enumerateSerialPorts(int loglevel)
{
    QList<QString> eligibleInterfaces;
    QList<InterfaceInfo> eligibleInterfacesInfo;
    QList<SerialPortId> list;

    usb_init();
    usb_find_busses();
    usb_find_devices();

    for (struct usb_bus *bus = usb_get_busses(); bus; bus = bus->next) {
        for (struct usb_device *device = bus->devices; device; device = device->next) {
            for (int n = 0; n < device->descriptor.bNumConfigurations && device->config; ++n) {
                struct usb_config_descriptor &usbConfig =device->config[n];
                QList<int> usableInterfaces;
                for (int m = 0; m < usbConfig.bNumInterfaces; ++m) {
                    for (int o = 0; o < usbConfig.interface[m].num_altsetting; ++o) {
                        struct usb_interface_descriptor &descriptor = usbConfig.interface[m].altsetting[o];
                        if (descriptor.bInterfaceClass != 2 // "Communication"
                                || descriptor.bInterfaceSubClass != 2 // Abstract (modem)
                                || descriptor.bInterfaceProtocol != 255) // Vendor Specific
                            continue;

                        unsigned char *buf = descriptor.extra;
                        unsigned int size = descriptor.extralen;
                        while (size >= 2 * sizeof(u_int8_t)) {
                            // for Communication devices there is a slave interface for the actual
                            // data transmission.
                            // the extra info stores that as a index for the interface
                            if (buf[0] >= 5 && buf[1] == 36 && buf[2] == 6) { // CDC Union
                                for (int i = 4; i < buf[0]; i++)
                                    usableInterfaces.append((int) buf[i]);
                            }
                            size -= buf[0];
                            buf += buf[0];
                        }
                    }
                }
                
                if (usableInterfaces.isEmpty())
                    continue;
                
                QString manufacturerString;
                QString productString;
                
                usb_dev_handle *devh = usb_open(device);
                if (devh) {
                    QByteArray buf;
                    buf.resize(256);
                    int err = usb_get_string_simple(devh, device->descriptor.iManufacturer, buf.data(), buf.size());
                    if (err < 0) {
                        if (loglevel > 1)
                            qDebug() << "      can't read manufacturer name, error:" << err;
                    } else {
                        manufacturerString = QString::fromAscii(buf);
                        if (loglevel > 1)
                            qDebug() << "      manufacturer:" << manufacturerString;
                    }

                    buf.resize(256);
                    err = usb_get_string_simple(devh, device->descriptor.iProduct, buf.data(), buf.size());
                    if (err < 0) {
                        if (loglevel > 1)
                            qDebug() << "      can't read product name, error:" << err;
                    } else {
                        productString = QString::fromAscii(buf);
                        if (loglevel > 1)
                            qDebug() << "      product:" << productString;
                    }
                    usb_close(devh);
                } else if (loglevel > 0) {
                    qDebug() << "      can't open usb device";
                }

                // second loop to find the actual data interface.
                foreach (int i, usableInterfaces) {
                    for (int m = 0; m < usbConfig.bNumInterfaces; ++m) {
                        for (int o = 0; o < usbConfig.interface[m].num_altsetting; ++o) {
                            struct usb_interface_descriptor &descriptor = usbConfig.interface[m].altsetting[o];
                            if (descriptor.bInterfaceNumber != i)
                                continue;
                            if (descriptor.bInterfaceClass == 10) { // "CDC Data"
                                if (loglevel > 1) {
                                    qDebug() << "      found the data port"
                                             << "bus:" << bus->dirname
                                             << "device" << device->filename
                                             << "interface" << descriptor.bInterfaceNumber;
                                }
#ifdef Q_OS_MAC
                                eligibleInterfaces << QString("^cu\\.usbmodem.*%1$")
                                                      .arg(QString("%1").arg(descriptor.bInterfaceNumber, 1, 16).toUpper()); 
#else
                                // ### manufacturer and product strings are only readable as root :(
                                if (!manufacturerString.isEmpty() && !productString.isEmpty()) {
                                    eligibleInterfaces << QString("usb-%1_%2-if%3")
                                                          .arg(manufacturerString.replace(QChar(' '), QChar('_')))
                                                          .arg(productString.replace(QChar(' '), QChar('_')))
                                                          .arg(i, 2, 16, QChar('0'));
                                } else {
                                    eligibleInterfaces << QString("if%1").arg(i, 2, 16, QChar('0')); // fix!
                                }
#endif
                                eligibleInterfacesInfo << InterfaceInfo(manufacturerString, productString, device->descriptor.idVendor, device->descriptor.idProduct);
                            }
                        }
                    }
                }
            }
        }
    }
    
    if (loglevel > 1)
        qDebug() << "      searching for interfaces:" << eligibleInterfaces;

#ifdef Q_OS_MAC
    QDir dir("/dev/");
    bool allowAny = false;
#else
    QDir dir("/dev/serial/by-id/");
    bool allowAny = eligibleInterfaces.isEmpty();
#endif
    foreach (const QFileInfo &info, dir.entryInfoList(QDir::System)) {
        if (!info.isDir()) {
            bool usable = allowAny;
            QString friendlyName = info.fileName();
            foreach (const QString &iface, eligibleInterfaces) {
                if (info.fileName().contains(QRegExp(iface))) {
                    if (loglevel > 1)
                        qDebug() << "      found device file:" << info.fileName() << endl;
#ifdef Q_OS_MAC
                    friendlyName = eligibleInterfacesInfo[eligibleInterfaces.indexOf(iface)].product;
#endif
                    usable = true;
                    break;
                }
            }
            if (!usable)
                continue;

            SerialPortId id;
            id.friendlyName = friendlyName;
            id.portName = info.canonicalFilePath();
            list << id;
        }
    }

    if (list.isEmpty() && !eligibleInterfacesInfo.isEmpty() && loglevel > 0) {
        qDebug() << "Possible USB devices found, but without serial drivers:";
        foreach(const InterfaceInfo &iface, eligibleInterfacesInfo) {
            qDebug() << "    Manufacturer:"
                     << iface.manufacturer
                     << "Product:"
                     << iface.product
#ifdef Q_OS_LINUX
                     << endl
                     << "    Load generic driver using:"
                     << QString("sudo modprobe usbserial vendor=0x%1 product=0x%2")
                        .arg(iface.manufacturerid, 4, 16, QChar('0'))
                        .arg(iface.productid, 4, 16, QChar('0'));
#else
                     ;
#endif
        }
    }
    return list;
}