#include "TUSBScannerIO.h"

#include "tsystem.h"

#include <iostream></iostream>

//#define HAS_LIBUSB

#if defined(HAS_LIBUSB)

#include <usb.h></usb.h>

#endif

#include <errno.h></errno.h>

using namespace std;

class TUSBScannerIOPD

{

public:

	TUSBScannerIOPD();

	struct usb_device *m_epson;

	struct usb_dev_handle *m_handle;

	int m_epR;

	int m_epW;

	bool m_trace;

};

static pthread_t T = 0;

//#define TRACE cout << __PRETTY_FUNCTION__ << endl;

#define TRACE

TUSBScannerIOPD::TUSBScannerIOPD()

	: m_epson(0), m_handle(0), m_epR(0), m_epW(0), m_trace(false)

{

	/*initialize libusb*/

	TRACE

	if (T == 0)

		T = pthread_self();

#if defined(HAS_LIBUSB)

	usb_set_debug(9);

	usb_init();

	usb_find_busses();

	usb_find_devices();

#endif

}

namespace

{

void buf2printable(const unsigned char *buffer, const int size, ostrstream &os)

{

	int i = 0;

	if ((size == 2) && (buffer[0] == 0x1b)) {

		os << "ESC ";

		char c = buffer[1];

		if (isprint(c))

			os << c << " ";

		return;

	}

	os << std::hex;

	for (; i < tmin(size, 0x40); ++i) {

		char c = buffer[i];

		os << "0x" << (unsigned int)c << " ";

	}

	if (i < size)

		os << "...";

}

}

//-----------------------------------------------------------------------------

TUSBScannerIO::TUSBScannerIO()

	: m_data(new TUSBScannerIOPD())

{

	TRACE

}

//-----------------------------------------------------------------------------

namespace

{

#if defined(HAS_LIBUSB)

//looking for an Epson device

struct usb_device *doCheck(struct usb_device *dev, int level)

{

	if (!dev)

		return 0;

	cout << "checking idVendor = " << std::hex << dev->descriptor.idVendor << endl;

	if (dev->descriptor.idVendor == 0x04b8)

		return dev;

	for (int i = 0; i < dev->num_children; i++)

		if (doCheck(dev->children[i], level + 1))

			return dev->children[i];

	return 0;

}

#endif

};

bool TUSBScannerIO::open()

{

#if defined(HAS_LIBUSB)

	for (struct usb_bus *bus = usb_busses; bus; bus = bus->next) {

		if (bus->root_dev) {

			m_data->m_epson = doCheck(bus->root_dev, 0);

			if (m_data->m_epson)

				break;

		} else {

			struct usb_device *dev;

			for (dev = bus->devices; dev; dev = dev->next)

				m_data->m_epson = doCheck(dev, 0);

			if (m_data->m_epson)

				break;

		}

	}

	if (!m_data->m_epson)

		return false;

	cout << "found" << endl;

	m_data->m_handle = usb_open(m_data->m_epson);

	if (!m_data->m_handle)

		return false;

	cout << "opened" << endl;

	m_data->m_epR = m_data->m_epson->config[0].interface[0].altsetting[0].endpoint[0].bEndpointAddress;

	m_data->m_epW = m_data->m_epson->config[0].interface[0].altsetting[0].endpoint[1].bEndpointAddress;

	int rc;

	rc = usb_set_configuration(m_data->m_handle, m_data->m_epson->config[0].bConfigurationValue);

	cout << "rc (config) = " << rc << endl;

	int ifc = 0;

	rc = usb_claim_interface(m_data->m_handle, ifc);

	if ((rc == -EBUSY) || (rc == -ENOMEM))

		return false;

	cout << "rc (claim) = " << rc << endl;

	cout << "gotit!" << endl;

	return true;

#else

	return false;

#endif

}

//-----------------------------------------------------------------------------

void TUSBScannerIO::close()

{

	TRACE

#if defined(HAS_LIBUSB)

	if (m_data->m_handle) {

		usb_release_interface(m_data->m_handle, 0);

		usb_close(m_data->m_handle);

	}

	m_data->m_handle = 0;

	m_data->m_epson = 0;

#endif

}

//-----------------------------------------------------------------------------

int TUSBScannerIO::receive(unsigned char *buffer, int size)

{

	TRACE

#if defined(HAS_LIBUSB)

	int count;

	count = usb_bulk_read(m_data->m_handle, m_data->m_epR, (char *)buffer, size, 30 * 1000);

	if (m_data->m_trace) {

		ostrstream os;

		os.freeze(false);

		os << "receive: size=" << size << " got = " << count << " buf=";

		buf2printable(buffer, count, os);

		os << '\n' << '\0';

		TSystem::outputDebug(os.str());

	}

	return count;

#else

	return 0;

#endif

}

//-----------------------------------------------------------------------------

int TUSBScannerIO::send(unsigned char *buffer, int size)

{

	TRACE

#if defined(HAS_LIBUSB)

	int count;

	if (T != pthread_self()) {

		cout << "called from another thead" << endl;

		return 0;

	}

	count = usb_bulk_write(m_data->m_handle, m_data->m_epW, (char *)buffer, size, 30 * 1000);

	if (m_data->m_trace) {

		ostrstream os;

		os.freeze(false);

		os << "send: size=" << size << " wrote = " << count << " buf=";

		buf2printable(buffer, size, os);

		os << '\n' << '\0';

		TSystem::outputDebug(os.str());

	}

	return count;

#else

	return 0;

#endif

}

//-----------------------------------------------------------------------------

void TUSBScannerIO::trace(bool on)

{

	TRACE

	m_data->m_trace = on;

}

//-----------------------------------------------------------------------------

TUSBScannerIO::~TUSBScannerIO()

{

	TRACE

}