#include "TUSBScannerIO.h"

#include "tsystem.h"

#include <windows.h></windows.h>

class TUSBScannerIOPD

{

public:

	TUSBScannerIOPD()

		: m_handle(INVALID_HANDLE_VALUE), m_trace(false)

	{

	}

	HANDLE m_handle;

	bool m_trace;

};

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

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())

{

}

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

bool TUSBScannerIO::open()

{

	m_data->m_handle = CreateFile("\\\\.\\usbscan0", GENERIC_WRITE | GENERIC_READ,

								  FILE_SHARE_WRITE | FILE_SHARE_READ,

								  NULL,

								  OPEN_EXISTING,

								  0,

								  NULL);

	if (m_data->m_handle == INVALID_HANDLE_VALUE)

		return false;

	return true;

}

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

void TUSBScannerIO::close()

{

	if (m_data->m_handle && (m_data->m_handle != INVALID_HANDLE_VALUE))

		CloseHandle(m_data->m_handle);

}

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

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

{

	int bytesLeft = size;

	unsigned char *ptr = buffer;

	DWORD count;

	static int m_maxReadSize = 0x10000;

	do {

		int bytesToRead = bytesLeft;

		notMoreThan<int>(m_maxReadSize, bytesToRead);</int>

		OVERLAPPED overlapped;

		memset(&overlapped, 0, sizeof(OVERLAPPED));

		overlapped.hEvent = CreateEvent(

			NULL, //pointertosecurityattributes,

			//WIN95ignoresthisparameter

			FALSE, //automaticreset

			FALSE, //initializetonotsignaled

			NULL); //pointertotheevent-objectname

		ReadFile(m_data->m_handle, ptr, bytesToRead, &count, &overlapped);

		DWORD waitRC = WaitForSingleObject(overlapped.hEvent, INFINITE);

		if (m_data->m_trace) {

			ostrstream os;

			os.freeze(false);

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

			buf2printable(ptr, count, os);

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

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

		}

		if (count != bytesToRead)

			return 0;

		ptr += count;

		bytesLeft = bytesLeft - count;

	} while (bytesLeft);

	return size;

}

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

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

{

	int bytesLeft = size;

	DWORD count;

	static int m_maxWriteSize = 64;

	//bytesLeft = 64;

	do {

		int bytesToWrite = bytesLeft;

		notMoreThan<int>(m_maxWriteSize, bytesToWrite);</int>

		WriteFile(m_data->m_handle, buffer, bytesToWrite, &count, 0);

		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());

		}

		if (count != bytesToWrite)

			return 0;

		// ptr += count;

		bytesLeft = bytesLeft - count;

	} while (bytesLeft);

	return size;

}

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

void TUSBScannerIO::trace(bool on)

{

	m_data->m_trace = on;

}

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

TUSBScannerIO::~TUSBScannerIO()

{

}