#include "TUSBScannerIO.h"
#include "tsystem.h"

#include <windows.h>

#include <strstream>

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, std::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 < std::min(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);

		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) {
			std::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);
		WriteFile(m_data->m_handle, buffer, bytesToWrite, &count, 0);

		if (m_data->m_trace) {
			std::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()
{
}