/*
 * Copyright 2001-2010 Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Originally written based on Parallel port addon by Michael Pfeiffer,
 * changes by Andreas Benzler, Philippe Houdoin
 * Rewritten to use the USBKit by Ithamar R. Adema.
 *   (Using code from usb_printer.cpp by Michael Lotz)
 *
 * Authors:
 *              Ithamar R. Adema, <ithamar.adema@team-embedded.nl>
 *              Michael Pfeiffer,
 *              Andreas Benzler,
 *              Philippe Houdoin,
 */

#include "PrintTransportAddOn.h"

#include <USBKit.h>
#include <String.h>

#include <HashString.h>
#include <HashMap.h>

#define PRINTER_INTERFACE_CLASS         0x07
#define PRINTER_INTERFACE_SUBCLASS      0x01

// printer interface types
#define PIT_UNIDIRECTIONAL              0x01
#define PIT_BIDIRECTIONAL               0x02
#define PIT_1284_4_COMPATIBLE           0x03
#define PIT_VENDOR_SPECIFIC             0xff


// TODO handle disconnection of printer during printing
// currently the USBPrinter will be deleted and USBTransport will still
// access the memory
class USBPrinter {
public:
        USBPrinter(const BString& id, const BString& name,
                const BUSBInterface *interface, const BUSBEndpoint *in, const BUSBEndpoint *out);

        ssize_t Write(const void *buf, size_t size);
        ssize_t Read(void *buf, size_t size);

        const BUSBInterface     *fInterface;
        const BUSBEndpoint      *fOut;
        const BUSBEndpoint      *fIn;
        BString                 fName;
        BString                 fID;
};


class USBPrinterRoster : public BUSBRoster {
public:
        USBPrinterRoster();

        status_t DeviceAdded(BUSBDevice *dev);
        void DeviceRemoved(BUSBDevice *dev);

        USBPrinter *Printer(const BString& key);

        status_t ListPrinters(BMessage *msg);
private:
        typedef HashMap<HashString,USBPrinter*> PrinterMap;
        PrinterMap fPrinters;
};


class USBTransport : public BDataIO {
public:
        USBTransport(BDirectory *printer, BMessage *msg);
        ~USBTransport();

        status_t InitCheck() { return fPrinter ? B_OK : B_ERROR; };

        ssize_t Read(void *buffer, size_t size);
        ssize_t Write(const void *buffer, size_t size);

private:
        USBPrinter *fPrinter;
        USBPrinterRoster *fRoster;
};


// Set transport_features so we stay loaded
uint32 transport_features = B_TRANSPORT_IS_HOTPLUG;


USBPrinterRoster::USBPrinterRoster()
{
        Start();
}


USBPrinter *
USBPrinterRoster::Printer(const BString& key)
{
        if (fPrinters.ContainsKey(key.String()))
                return fPrinters.Get(key.String());

        return NULL;
}


status_t
USBPrinterRoster::DeviceAdded(BUSBDevice *dev)
{
        const BUSBConfiguration *config = dev->ActiveConfiguration();
        const BUSBEndpoint *in = NULL, *out = NULL;
        const BUSBInterface *printer = NULL;

        // Try to find a working printer interface in this device
        if (config) {
                for (uint32 idx = 0; printer == NULL
                        && idx < config->CountInterfaces(); idx++) {
                        const BUSBInterface *interface = config->InterfaceAt(idx);
                        for (uint32 alt = 0; alt < interface->CountAlternates(); alt++) {
                                const BUSBInterface *alternate = interface->AlternateAt(alt);
                                if (alternate->Class() == PRINTER_INTERFACE_CLASS
                                        && alternate->Subclass() == PRINTER_INTERFACE_SUBCLASS
                                        && (alternate->Protocol() == PIT_UNIDIRECTIONAL
                                        || alternate->Protocol() == PIT_BIDIRECTIONAL
                                        ||  alternate->Protocol() == PIT_1284_4_COMPATIBLE)) {
                                        // Found a usable Printer interface!
                                        for (uint32 endpointIdx = 0;
                                                endpointIdx < alternate->CountEndpoints();
                                                endpointIdx++) {
                                                const BUSBEndpoint *endpoint =
                                                        alternate->EndpointAt(endpointIdx);
                                                if (!endpoint->IsBulk())
                                                        continue;

                                                if (endpoint->IsInput())
                                                        in = endpoint;
                                                else if (endpoint->IsOutput())
                                                        out = endpoint;

                                                if (!in || !out)
                                                        continue;

                                                printer = alternate;
                                                ((BUSBInterface*)interface)->SetAlternate(alt);
                                                break;
                                        }
                                }
                        }
                }
        }

        if (printer != NULL) {
                // We found a working printer interface, lets determine a unique ID
                //  for it now, and a user identification for display in the Printers
                //  preference.
                BString portId = dev->SerialNumberString();
                if (!portId.Length()) {
                        // No persistent unique ID available, use the vendor/product
                        //   ID for now. This will be unique as long as no two similar
                        //   devices are attached.
                        portId << dev->VendorID() << "/" << dev->ProductID();
                }

                BString portName = dev->ManufacturerString();
                if (portName.Length())
                        portName << " ";
                portName << dev->ProductString();

                //TODO: Do we want to use usb.ids to find proper name if strings
                //        are not supplied by USB?

                fPrinters.Put(portId.String(), new USBPrinter(portId, portName,
                        printer, in, out));
        }

        return B_OK;
}


void
USBPrinterRoster::DeviceRemoved(BUSBDevice *dev)
{
        PrinterMap::Iterator iterator = fPrinters.GetIterator();
        while (iterator.HasNext()) {
                const PrinterMap::Entry& entry = iterator.Next();
                // If the device is in the list, remove it
                if (entry.value->fInterface->Device() == dev) {
                        fPrinters.Remove(entry.key);
                        delete entry.value;
                        break;
                }
        }
}


status_t
USBPrinterRoster::ListPrinters(BMessage *msg)
{
        PrinterMap::Iterator iterator = fPrinters.GetIterator();
        while (iterator.HasNext()) {
                const PrinterMap::Entry& entry = iterator.Next();
                msg->AddString("port_id", entry.value->fID);
                msg->AddString("port_name", entry.value->fName);
        }

        return B_OK;
}


USBPrinter::USBPrinter(const BString& id, const BString& name,
        const BUSBInterface *intf, const BUSBEndpoint *in, const BUSBEndpoint *out)
        : fInterface(intf), fOut(out), fIn(in), fName(name), fID(id)
{
}


//TODO: see usb_printer.cpp for error handling during read/write!
ssize_t
USBPrinter::Write(const void *buf, size_t size)
{
        if (!buf || size <= 0)
                return B_BAD_VALUE;

        // NOTE: we can safely cast below as we're sending data _out_
        return fOut->BulkTransfer((void*)buf, size);
}


ssize_t
USBPrinter::Read(void *buf, size_t size)
{
        if (!buf || size <= 0)
                return B_BAD_VALUE;

        return fIn->BulkTransfer(buf, size);
}


// Implementation of transport add-on interface

BDataIO *
instantiate_transport(BDirectory *printer, BMessage *msg)
{
        USBTransport *transport = new(std::nothrow) USBTransport(printer, msg);
        if (transport != NULL && transport->InitCheck() == B_OK)
                return transport;

        delete transport;
        return NULL;
}


// List detected printers
status_t
list_transport_ports(BMessage *msg)
{
        USBPrinterRoster roster;
        status_t status = roster.ListPrinters(msg);
        roster.Stop();
        return status;
}


// Implementation of USBTransport
USBTransport::USBTransport(BDirectory *printer, BMessage *msg)
        : fPrinter(NULL)
{
        BString key;

        if (printer->ReadAttrString("transport_address", &key) != B_OK)
                return;

        fRoster = new(std::nothrow) USBPrinterRoster;
        if (fRoster == NULL)
                return;

        fPrinter = fRoster->Printer(key.String());
        if (fPrinter == NULL)
                return;

        // If caller doesn't care...
        if (msg == NULL)
                return;

        // Fill up the message
        msg->what = 'okok';
}


USBTransport::~USBTransport()
{
        if (fRoster != NULL) {
                fRoster->Stop();
                delete fRoster;
        }
}


ssize_t
USBTransport::Read(void *buffer, size_t size)
{
        return fPrinter ? fPrinter->Read(buffer, size) : B_ERROR;
}


ssize_t
USBTransport::Write(const void *buffer, size_t size)
{
        return fPrinter ? fPrinter->Write(buffer, size) : B_ERROR;
}