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

  (C)2005 HUDSON SOFT

  $Header: /home/cvsroot/SDK/build/demos/hio2demo/vc++/simple/simple.cpp,v 1.5 2007/11/26 13:57:26 iwai_yuma Exp $

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

#include "stdafx.h"

#include <revolution/hio2.h>
#include "Hio2DllIf.h"
#include "multi.h"		// Divert to generate send data
#include "simple.h"

//-----------------------------------------------------------------------------
// Local symbol definition

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

// HIO2 API handle
static HIO2Handle	l_hHIO2 = HIO2_INVALID_HANDLE_VALUE;

// 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 err );

///////////////////////////////////////////////////////////////////////////////
//
// 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_cHio2Dll.Close(h);
		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, sizeof( buffer ), &l_stRecvBuffer );
			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);

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

	// When the device could not 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;
	errno_t err;

	_time64(&lTime);

	err = _localtime64_s( &pLocalTime, &lTime );
//	pLocalTime = _localtime64(&lTime);

	stPacket.mon	= pLocalTime.tm_mon + 1;
	stPacket.mday	= pLocalTime.tm_mday;
	stPacket.hour	= pLocalTime.tm_hour;
	stPacket.min	= pLocalTime.tm_min;
	stPacket.sec	= pLocalTime.tm_sec;
	stPacket.msec	= 0;
	
	strcpy_s( stPacket.string, sizeof( stPacket.string ), "PC TIME" );
//	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 )
{
	if ( l_hHIO2 != HIO2_INVALID_HANDLE_VALUE ) l_cHio2Dll.Close(l_hHIO2);
	l_cHio2Dll.Exit();

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

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

//-----------------------------------------------------------------------------
void	__Halt( SIMPLE_ERROR err )
{
	// After displaying an error message, perform shutdown processing for HIO2
	printf( simpleErrorMessage[err], l_cHio2Dll.GetLastError() );

	__HIO2Exit();

	exit(1);
}

// End of simple.cpp