/* (C) 2003 XDA Developers  itsme@xs4all.nl
 *
 * $Header$
 */
#include "debug.h"
#include "SerialDevice.h"
#include "CircularBuffer.h"

SerialDevice::SerialDevice() : m_rcv(32768)
{
}
SerialDevice::~SerialDevice()
{
	close();
}

bool SerialDevice::open(const std::string& devicename)
{
    m_hPort= CreateFile(devicename.c_str(), GENERIC_READ | GENERIC_WRITE,
			0,NULL, OPEN_EXISTING, 0, NULL);
	if (m_hPort==NULL || m_hPort==INVALID_HANDLE_VALUE)
	{
		m_hPort= NULL;
		return false;
	}
    SetupComm(m_hPort, 0x8000, 0x8000);
	UpdateCommParams();

	if (!SetCommMask(m_hPort, EV_RXCHAR))
	{
		error("SetCommMask");
		return false;
	}

	m_hThread= CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)MainThreadProc, this, 0, &m_nThreadId);
	if (m_hThread==INVALID_HANDLE_VALUE || m_hThread==NULL)
	{
		error("ERROR creating NHthread\n");

		m_hThread= NULL;
	}
	return true;
}
void SerialDevice::close()
{
	TerminateThread(m_hThread, 0);
	CloseHandle(m_hThread);
	m_hThread= 0;

	CloseHandle(m_hPort);
	m_hPort= 0;
}
DWORD SerialDevice::MainThreadProc(SerialDevice *port)
{
	return port->PortThreadProc();
}

DWORD SerialDevice::PortThreadProc()
{
	DWORD event;
	while (WaitCommEvent(m_hPort, &event, NULL))
	{
		if (event&EV_RXCHAR) handleRXCharEvent();
	}
	error("WaitCommEvent");
	return 0;
}

void SerialDevice::handleRXCharEvent()
{
    ByteVector buf;

	while (true)
    {
        buf.resize(256);
        DWORD nRead;
		if (!ReadFile(m_hPort, vectorptr(buf), buf.size(), &nRead, NULL))
		{
			error("ReadFile");
			return;
		}
        if (nRead==0)
            break;
        buf.resize(nRead);

        m_rcv.Put(buf);
	}
}

bool SerialDevice::ReceiveData(ByteVector& buf, int timeout)
{
    buf.clear();
    m_rcv.Get(buf, timeout);

    return true;
}

bool SerialDevice::SendData(const std::string& str)
{
    if (str.empty())
        return true;
    ByteVector buf(iteratorptr(str.begin()), iteratorptr(str.end()-1)+1);

    return SendData(buf);
}

bool SerialDevice::SendData(const ByteVector& buf)
{
    DWORD ofs= 0;

    while (ofs<buf.size())
    {
        DWORD nWritten;
        if (!WriteFile(m_hPort, vectorptr(buf)+ofs, buf.size()-ofs, &nWritten, NULL))
        {
            error("WriteFile");
            return false;
        }
        ofs += nWritten;
    }
	return true;
}
bool SerialDevice::WriteCommand(const std::string& cmd, std::string& reply)
{
    if (!SendData(cmd))
        return false;

    ByteVector buf;
    return ReceiveData(buf, 500);
}

bool SerialDevice::UpdateCommParams()
{
	if (m_hPort==NULL)
		return false;

	DCB dcb;
	dcb.DCBlength= sizeof(DCB);

	if (!GetCommState(m_hPort, &dcb))
	{
		debug("GetCommState");
		return false;
	}
    dcb.BaudRate= 115200;
    dcb.ByteSize= 8;
    dcb.Parity= NOPARITY;
    dcb.StopBits= ONESTOPBIT;
    
    dcb.fOutxCtsFlow= 0;
    dcb.fDtrControl= DTR_CONTROL_ENABLE;
    dcb.fRtsControl= 0;
    dcb.fAbortOnError= 0;

	if (!SetCommState(m_hPort, &dcb))
	{
		debug("SetCommState");
		return false;
	}
    COMMTIMEOUTS to;

    if (!GetCommTimeouts(m_hPort, &to))
        return false;

    to.ReadIntervalTimeout = 0;
    to.ReadTotalTimeoutMultiplier = 0;
    to.ReadTotalTimeoutConstant = 200;
    to.WriteTotalTimeoutMultiplier = 0;
    to.WriteTotalTimeoutConstant = 20000;

    if (!SetCommTimeouts(m_hPort, &to))
        return false;

	return true;
}