/*
* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  
* System Includes
*
*/



#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>


/*************************************************************************************
 *
 * Local Includes
 *
 ************************************************************************************/
#include "CSerialTcpRelay.h"


/*************************************************************************************
 *
 * Definitions
 *
 ************************************************************************************/
#define TO_RETRY					(1000)
#define TO_TIMEWAIT					(3000)
#define INITIALSTRINGBUFFERSIZE		(64)


/*************************************************************************************
 *
 * Prototypes
 *
 ************************************************************************************/
void Relay( SOCKADDR_IN aSocketAddress, char *aSerialPortName );
void RelaySession( SOCKADDR_IN aSocketAddress, CSerialPort *aSerialPort );
void PrintRelayError( TRelayError aRelayError, int aErrCode );


/*************************************************************************************
 *
 * main()
 *
 ************************************************************************************/
int main( int argc, char *argv[] )
{
	char *serial_port_name;
	SOCKADDR_IN socket_address;
	WORD version;
	WSADATA wsaData;
	int err;

	// check params
	if( argc < 3 ) {
		fprintf( stderr, "usage: %s <tcp_host> <tcp_port> <serial_port>\n", argv[0] );
		return -1;
	}

	// process the params
	memset( &socket_address, 0, sizeof(socket_address) );
	socket_address.sin_family = AF_INET;
	socket_address.sin_port = htons( atoi(argv[2]) );
	socket_address.sin_addr.S_un.S_addr = inet_addr( argv[1] );
	serial_port_name = argv[3];

	// start the socket subsystem
	version = MAKEWORD( 2, 2 );
	err = WSAStartup( version, &wsaData );
	assert( err == 0 );

	// start the relay
	Relay( socket_address, serial_port_name );

	// done
	WSACleanup();
	return 0;
}


/*************************************************************************************
 *
 * Relay()
 *
 ************************************************************************************/
void Relay( SOCKADDR_IN aSocketAddress, char *aSerialPortName )
{
	int err;
	CSerialPort serial_port;

	// repeat...
	while( 1 ) {

		// open the serial port - if this fails then pause and retry
		err = serial_port.OpenPort( aSerialPortName );
		if( err != 0 ) {
			fprintf( stderr, "Failed to open serial port %s (%d)\n", aSerialPortName, err );
			Sleep( TO_RETRY );
			continue;
		}

		// try and establish a session (might succeed, might fail, makes no difference here)
		RelaySession( aSocketAddress, &serial_port );

		// close the port
		serial_port.ClosePort();
	}

	// done
	return;
}


/*************************************************************************************
 *
 * RelaySession()
 *
 ************************************************************************************/
void RelaySession( SOCKADDR_IN aSocketAddress, CSerialPort *aSerialPort )
{
	char recv_buffer;
	int err, errcode, bytes_read = 0, slen, initial_string_buffer_length;
	CSerialTcpRelay relay;
	TRelayError rerr;

	int current_at_state = 0;
	char expected_at_char[] = { 'A', 'T', 0x0d, 0 };
	char initial_string_buffer[INITIALSTRINGBUFFERSIZE] = { 0 };

	// wait for some bytes to arrive on the port
	fprintf( stdout, "Waiting for new session\n" );
	while( 1 ) {

		// read from the serial port - if there is an error then exit
		bytes_read = 1;
		err = aSerialPort->ReceiveBytes( &recv_buffer, &bytes_read );
		if( err != 0 ) {
			fprintf( stderr, "Error reading from the serial port (%s)\n", strerror(err) );
			break;
		}

		// if nothing was read then just continue
		if( bytes_read == 0 ) {
			continue;
		}

		// if we read a char that does not match the ignore string then try and
		// create a session
		if( recv_buffer != expected_at_char[current_at_state] ) {
			strncpy( initial_string_buffer, expected_at_char, INITIALSTRINGBUFFERSIZE );
			initial_string_buffer[current_at_state] = 0;
			slen = strlen( initial_string_buffer );
			assert( slen < (INITIALSTRINGBUFFERSIZE-2) );
			initial_string_buffer[slen] = recv_buffer;
			initial_string_buffer[slen+1] = 0;
			initial_string_buffer_length = strlen( initial_string_buffer );
			break;
		}

		// otherwise update the at_state
		current_at_state += 1;
		current_at_state = ((expected_at_char[current_at_state] == 0) ? 0 : current_at_state);
	}
	
	// some data was received - try and start a session
	rerr = relay.InitialiseRelay( aSerialPort, aSocketAddress, initial_string_buffer, initial_string_buffer_length, &errcode );
	if( rerr != RE_SUCCESS ) {
		PrintRelayError( rerr, errcode );
		return;
	}
	fprintf( stdout, "Session established\n" );

	// session established - execute
	rerr = relay.ExecuteRelay();
	if( rerr != RE_SUCCESS ) {
		fprintf( stderr, "ExecuteRelay returned %d\n", rerr );
	}
	fprintf( stdout, "Session closed\n" );
	
	// do time-wait 
	Sleep( TO_TIMEWAIT );
}


/*************************************************************************************
 *
 * PrintRelayError()
 *
 ************************************************************************************/
void PrintRelayError( TRelayError aRelayError, int aErrCode )
{
	char *relay_error_string[] = { NULL, "socket() failed", "connect() failed", "initial send() failed" };
	fprintf( stderr, "Failed to initialise the relay - %s - %d\n", relay_error_string[aRelayError], aErrCode );
}