/*---------------------------------------------------------------------------*
  Project:  HIO2 demos - simple
  File:     simple.c

  (C)2005 HUDSON SOFT

  $Header: /home/cvsroot/SDK/build/demos/hio2demo/vc++/simple/simple.cpp,v 1.3 2006/03/15 06:31:27 mitu Exp $

  $NoKeywords: $
 *---------------------------------------------------------------------------*/

#include "stdafx.h"

#include <revolution/hio2.h>
#include "Hio2DllIf.h"
#include "multi.h"		// divert to generation of sent data
#include "simple.h"

//-----------------------------------------------------------------------------
// local symbol definition

// hio2[D].dll interface
static CHio2DllIf	l_cHio2Dll;

// HIO2 API handle
static HIO2Handle	l_hHIO2;

// EXI-USB device path
static TCHAR	l_lpszDevicePathBuffer[_MAX_PATH];
static HIO2DevicePath	l_pDevicePath = l_lpszDevicePathBuffer;

// NNGC connection state
static volatile BOOL	l_bConnect = FALSE;

// receive data from NNGC
static volatile	BOOL	l_bReceived = FALSE;

// send flag
static volatile BOOL	l_bSend = FALSE;

// Buffer for received data
static MULTI_PACKET	l_stRecvBuffer;

// termination flag
static BOOL	l_bExit = FALSE;

//-----------------------------------------------------------------------------
// local function declared

static void	__HIO2Init( void );
static void	__HIO2Send( void );
static void	__HIO2Exit( void );
static void	__Halt( SIMPLE_ERROR errno );

///////////////////////////////////////////////////////////////////////////////
//
// callback
//

// enum devices
static
BOOL	__EnumCallback(HIO2DevicePath pathName, void* param)
{
	lstrcpy(l_lpszDevicePathBuffer, pathName);
	return TRUE;
}

// receive
static
void	__ReceiveCallback( HIO2Handle h )
{
	u32 mail;

	if ( l_bExit ) return ;

	if ( !l_cHio2Dll.ReadMailbox(h, &mail) )
		__Halt(SIMPLE_ERR_HIO2_READ_MAILBOX);

	switch ( mail )
	{
	case SIMPLE_MAIL_OPEN:		// open notification from connection target
		if ( !l_cHio2Dll.WriteMailbox(h, SIMPLE_MAIL_OPEN_RESULT) )
			__Halt(SIMPLE_ERR_HIO2_WRITE_MAILBOX);
		l_bConnect = TRUE;
		break;
	case SIMPLE_MAIL_RECV:		// receive data from connection target
		if ( !l_cHio2Dll.Read(h, SIMPLE_NNGC2PC_ADDR, &l_stRecvBuffer,
					   sizeof(l_stRecvBuffer)) )
			__Halt(SIMPLE_ERR_HIO2_READ);
		l_bReceived = TRUE;
		break;
	case SIMPLE_MAIL_CHANGE:	// switch send/receive
		l_bSend = !l_bSend; break;
	case SIMPLE_MAIL_EXIT:		// termination notification from connection target
		l_bExit = TRUE; break;
	}
}


///////////////////////////////////////////////////////////////////////////////
//
// simple application
//

int _tmain(int argc, _TCHAR* argv[])
{
	// load hio2[D].dll
	if ( !l_cHio2Dll.Create() )
	{
		printf("hio2[D].dll load error.\n");
		return -1;
	}

	// HIO2 API initialization
	__HIO2Init();

	printf("HIO2 DEMO - simple\n\n");
	printf("press ESC key to exit\n\n");

	while ( !l_bExit )
	{
		Sleep(1);

		BOOL sendPossible = FALSE;
		{
			u32 status;
			// get HIO2 status
			if ( !l_cHio2Dll.ReadStatus(l_hHIO2, &status) )
				__Halt(SIMPLE_ERR_HIO2_READ_STATUS);
			sendPossible = !(status & HIO2_STATUS_TX);
		}

		// terminate when the ESC key is input
		if ( (_kbhit() != 0) && (tolower(_getch()) == 0x1B) )
		{
			// termination notification to NNGC when mail can be sent
			{
				if ( !l_cHio2Dll.WriteMailbox(l_hHIO2, SIMPLE_MAIL_EXIT) )
					__Halt(SIMPLE_ERR_HIO2_WRITE_MAILBOX);
				l_bExit = TRUE;
				break;
			}
		}

		// send data to NNGC during send state
		if ( sendPossible && l_bSend ) __HIO2Send();

		// data received
		if ( l_bReceived )
		{
			TCHAR buffer[128];
			int n;

			MultiPacketToString(buffer, &l_stRecvBuffer);
			n = printf("%s",buffer);
			while (n-- > 0) printf("\x08");
			fflush(stdout);

			l_bReceived = FALSE;
		}

	}

	__HIO2Exit();

	return 0;
}

//-----------------------------------------------------------------------------
static
void	__HIO2Init( void )
{
	// initialization
	if ( !l_cHio2Dll.Init() ) __Halt(SIMPLE_ERR_HIO2_INIT);

	// device list
	int nDevCount = l_cHio2Dll.EnumDevices(__EnumCallback, NULL);
	if ( nDevCount == -1 ) __Halt(SIMPLE_ERR_HIO2_ENUMDEVICES);

	// if device cannot be found
	if ( nDevCount == 0 ) __Halt(SIMPLE_ERR_EXI2USB_NOT_FIND);

	// device open
	if ( (l_hHIO2=l_cHio2Dll.Open(l_pDevicePath, __ReceiveCallback, NULL, NULL))
		== HIO2_INVALID_HANDLE_VALUE )
		__Halt(SIMPLE_ERR_HIO2_OPEN);
}

//-----------------------------------------------------------------------------
static
void	__HIO2Send( void )
{
	MULTI_PACKET stPacket;
	struct tm *pLocalTime;
	__time64_t lTime;

	_time64(&lTime);
	pLocalTime = _localtime64(&lTime);

	stPacket.mon	= pLocalTime->tm_mon;
	stPacket.mday	= pLocalTime->tm_mday;
	stPacket.hour	= pLocalTime->tm_hour;
	stPacket.min	= pLocalTime->tm_min;
	stPacket.sec	= pLocalTime->tm_sec;
	stPacket.msec	= 0;
	strcpy(stPacket.string, "PC TIME");

	int a = sizeof(stPacket);
	if ( !l_cHio2Dll.Write(l_hHIO2, SIMPLE_PC2NNGC_ADDR, &stPacket,
		sizeof(stPacket)) )
		__Halt(SIMPLE_ERR_HIO2_WRITE);

	if ( !l_cHio2Dll.WriteMailbox(l_hHIO2, SIMPLE_MAIL_RECV) )
		__Halt(SIMPLE_ERR_HIO2_WRITE_MAILBOX);
}

//-----------------------------------------------------------------------------
static
void	__HIO2Exit( void )
{
	l_cHio2Dll.Close(l_hHIO2);
	l_cHio2Dll.Exit();

	// hio2[D].dll deallocated
	l_cHio2Dll.Release();

	printf("HIO2 DEMO - simple done.        \n");
}

//-----------------------------------------------------------------------------
void	__Halt( SIMPLE_ERROR errno )
{
	// after displaying the error message deallocate hio2[D].dll
	printf(simpleErrorMessage[errno], l_cHio2Dll.GetLastError());
	l_cHio2Dll.Release();

	exit(1);
}

// end of simple.cpp