#include "TUSBScannerIO.h"
#include "tsystem.h"
#include <iostream>

//#define HAS_LIBUSB

#if defined(HAS_LIBUSB)
#include <USB.h>
#endif

#include <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
}