/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

#include "stdafx.h"

#include "TCAPIConnectionJni.h"

#include "TCConstants.h"

#include "TCErrorConstants.h"

#include "ClientManager.h"

#include "ServerClient.h"

#include "TCDebugLog.h"

#include "InputStream.h"

#include "ErrorMonitorData.h"

#include <list>

#include <vector>

extern CClientManager* gManager;

#ifdef _DEBUG

extern BOOL gDoLogging;

char TCDebugMsg[100];

#define TCDEBUGOPEN() if (gDoLogging) { gManager->m_DebugLog->WaitForAccess(); }

#define TCDEBUGLOGS(s) if (gDoLogging) { sprintf(TCDebugMsg,"%s", s); gManager->m_DebugLog->log(TCDebugMsg); }

#define TCDEBUGLOGA1(s, a1) if (gDoLogging) { sprintf(TCDebugMsg, s, a1); gManager->m_DebugLog->log(TCDebugMsg); }

#define TCDEBUGLOGA2(s, a1, a2) if (gDoLogging) { sprintf(TCDebugMsg, s, a1, a2); gManager->m_DebugLog->log(TCDebugMsg); }

#define TCDEBUGLOGA3(s, a1, a2, a3) if (gDoLogging) { sprintf(TCDebugMsg, s, a1, a2, a3); gManager->m_DebugLog->log(TCDebugMsg); }

#define TCDEBUGCLOSE() if (gDoLogging) { gManager->m_DebugLog->ReleaseAccess(); }

#else

#define TCDEBUGOPEN()

#define TCDEBUGLOGS(s)

#define TCDEBUGLOGA1(s, a1)

#define TCDEBUGLOGA2(s, a1, a2)

#define TCDEBUGLOGA3(s, a1, a2, a3)

#define TCDEBUGCLOSE()

#endif

#ifdef _DEBUG

FILE* fLog1 = NULL;

FILE* fLog2 = NULL;

static void OpenLogFile1(char* filename);

static void CloseLogFile1();

static void OpenLogFile2(char* filename);

static void CloseLogFile2();

#define OPENLOGf1(f) OpenLogFile1(f)

#define CLOSELOG1() CloseLogFile1()

#define OPENLOGf2(f) OpenLogFile2(f)

#define CLOSELOG2() CloseLogFile2()

#else

#define OPENLOGf1(f)

#define CLOSELOG1()

#endif

static void ConvertRealSerialSettingsToHost(char* pBaud, char* pDataBits, char* pParity, char* pStopBits, char* pFlowControl, pRealSerialConnectData pData);

static void ConvertRealSerialSettingsToServer(const char* pBaud, const char* pDataBits, const char* pParity, const char* pStopBits, const char* pFlowControl, pRealSerialConnectData pData);

static const char* GetErrorText(unsigned long error);

/*

 * Class:     com_nokia_tcf_impl_TCAPIConnection

 * Method:    nativeConnect

 * Signature: (Ljava/lang/String;[J[Ljava/lang/String;[JLjava/lang/String;[J)J

 */

JNIEXPORT jlong JNICALL Java_com_nokia_tcf_impl_TCAPIConnection_nativeConnect

  (JNIEnv *env, jobject pThis, jstring inType, jlongArray inOptions, jobjectArray inSettings, jlongArray inMessageOptions, jstring inFilePath, jlongArray outClientId)

 {

 	// inOptions are connection options

 	// inMessageOptions are client's message options

	// inFilePath will be null if message destination is not DESTINATION_CLIENTFILE 

	long ret = TCAPI_ERR_NONE;

	unsigned long osError = 0;

	long clientId;

	TCDEBUGOPEN();

	TCDEBUGLOGS("nativeConnect\n");

	if (!gManager->IsServerRunning())

	{

		TCDEBUGLOGS("Server not running\n");

		TCDEBUGCLOSE();

		return TCAPI_ERR_COMM_SERVER_RESPONSE_TIMEOUT;

	}

	gManager->m_Server->WaitforServerPipeAccess();

	{

		jboolean isCopy = false;

		// options per connection

		jlong* pOptions = env->GetLongArrayElements(inOptions, &isCopy);

		DWORD retryInterval = (DWORD)pOptions[0];

		DWORD retryTimeout = (DWORD)pOptions[1];

		env->ReleaseLongArrayElements(inOptions, pOptions, 0);

		pOptions = env->GetLongArrayElements(inMessageOptions, &isCopy);

		// options per client

		long unWrapFormat = pOptions[0];

		long ostVersion = pOptions[1];

		env->ReleaseLongArrayElements(inMessageOptions, pOptions, 0);

		TCDEBUGLOGA2(" retryInterval=%d, retryTimeout=%d\n", retryInterval, retryTimeout);

		TCDEBUGLOGA3(" unWrapFormat=%d, ostVersion=%d destination=%s\n", unWrapFormat, ostVersion, ((inFilePath == NULL) ? "stream" : "file"));

		char* pType = (char*)env->GetStringUTFChars(inType, &isCopy);

		TCDEBUGLOGA1("  pType = %s\n", pType);

		if (strcmp(pType, "musti") == 0 || strcmp(pType, "platsim") == 0) 

		{

			jstring addString = (jstring)env->GetObjectArrayElement(inSettings, 0);

			jstring portString = (jstring)env->GetObjectArrayElement(inSettings, 1);

			jstring chanString = (jstring)env->GetObjectArrayElement(inSettings, 2);

			jstring decodeString = (jstring)env->GetObjectArrayElement(inSettings, 3);

			const char* pAddress = env->GetStringUTFChars(addString, NULL);

			const char* pPort = env->GetStringUTFChars(portString, NULL);

			const char* pChan = env->GetStringUTFChars(chanString, NULL);

			const char* pDecode = env->GetStringUTFChars(decodeString, NULL);

			TCDEBUGLOGA2(" TCP: ipAddress=%s, ipPort=%s\n", pAddress, pPort);

			TCDEBUGLOGA2(" TCP: channel=%s, decode=%s\n", pChan, pDecode);

			ServerCommandData cmd;

			cmd.command = eCmdConnect;

			strncpy(cmd.connectSettings.connectType, pType, MAX_CONNECTION_TYPE);

			strncpy(cmd.connectSettings.tcpSettings.ipAddress, pAddress, MAX_IPADDRESS_SIZE);

			strncpy(cmd.connectSettings.tcpSettings.ipPort, pPort, MAX_PORT_SIZE);

			cmd.connectSettings.retryInterval = retryInterval;

			cmd.connectSettings.retryTimeout = retryTimeout;

			strncpy(cmd.connectSettings.decodeFormat, pDecode, MAX_DECODE_FORMAT);

			if (pChan != NULL)

			{

				if (strcmp(pChan, "1") == 0)

				{

					cmd.connectSettings.traceBoxChannel = 1;

				}

				else

				{

					cmd.connectSettings.traceBoxChannel = 2;

				}

			}

			else

			{

				cmd.connectSettings.traceBoxChannel = 2;

			}

			cmd.clientOptions.unWrapFormat = unWrapFormat;

			cmd.clientOptions.ostVersion = ostVersion;

			gManager->m_Server->SendCommand(&cmd);

			gManager->m_Server->GetResponse(&cmd);

			if (cmd.response == eRspError)

			{

				TCDEBUGLOGA1("  from server: ret = %d\n", cmd.error);

				ret = cmd.error;

				osError = cmd.osError;

			}

			else

			{

				TCDEBUGLOGA1("  from server: id = %d\n", cmd.clientId);

				clientId = cmd.clientId;

				gManager->WaitForErrorMonitorListAccess();

				TCDEBUGLOGS(" TODO: create error monitor storage if server connected\n");

				CErrorMonitor* monitor = new CErrorMonitor(clientId);

				if (monitor != NULL)

				{

					monitor->CreateData();

					gManager->AddErrorMonitor(monitor);

				}

				gManager->ReleaseErrorMonitorListAccess();

				TCDEBUGLOGA1(" clientId=%d\n", clientId);

				jlong jClientId = clientId;

				env->SetLongArrayRegion(outClientId, 0, 1, &jClientId);

			}

			env->ReleaseStringUTFChars(addString, pAddress);

			env->ReleaseStringUTFChars(portString, pPort);

			env->ReleaseStringUTFChars(chanString, pChan);

			env->ReleaseStringUTFChars(decodeString, pDecode);

		}

		else if (strcmp(pType, "tcp") == 0)

		{

			jstring addString = (jstring)env->GetObjectArrayElement(inSettings, 0);

			jstring portString = (jstring)env->GetObjectArrayElement(inSettings, 1);

			jstring decodeString = (jstring)env->GetObjectArrayElement(inSettings, 2);

			const char* pAddress = env->GetStringUTFChars(addString, NULL);

			const char* pPort = env->GetStringUTFChars(portString, NULL);

			const char* pDecode = env->GetStringUTFChars(decodeString, NULL);

			TCDEBUGLOGA3(" TCP: ipAddress=%s, ipPort=%s decode=%s\n", pAddress, pPort, pDecode);

			ServerCommandData cmd;

			cmd.command = eCmdConnect;

			strncpy(cmd.connectSettings.connectType, pType, MAX_CONNECTION_TYPE);

			strncpy(cmd.connectSettings.tcpSettings.ipAddress, pAddress, MAX_IPADDRESS_SIZE);

			strncpy(cmd.connectSettings.tcpSettings.ipPort, pPort, MAX_PORT_SIZE);

			cmd.connectSettings.retryInterval = retryInterval;

			cmd.connectSettings.retryTimeout = retryTimeout;

			strncpy(cmd.connectSettings.decodeFormat, pDecode, MAX_DECODE_FORMAT);

			cmd.clientOptions.unWrapFormat = unWrapFormat;

			cmd.clientOptions.ostVersion = ostVersion;

			gManager->m_Server->SendCommand(&cmd);

			gManager->m_Server->GetResponse(&cmd);

			if (cmd.response == eRspError)

			{

				TCDEBUGLOGA1("  from server: ret = %d\n", cmd.error);

				ret = cmd.error;

				osError = cmd.osError;

			}

			else

			{

				TCDEBUGLOGA1("  from server: id = %d\n", cmd.clientId);

				clientId = cmd.clientId;

				gManager->WaitForErrorMonitorListAccess();

				TCDEBUGLOGS(" TODO: create error monitor storage if server connected\n");

				CErrorMonitor* monitor = new CErrorMonitor(clientId);

				if (monitor != NULL)

				{

					monitor->CreateData();

					gManager->AddErrorMonitor(monitor);

				}

				gManager->ReleaseErrorMonitorListAccess();

				TCDEBUGLOGA1(" clientId=%d\n", clientId);

				jlong jClientId = clientId;

				env->SetLongArrayRegion(outClientId, 0, 1, &jClientId);

			}

			env->ReleaseStringUTFChars(addString, pAddress);

			env->ReleaseStringUTFChars(portString, pPort);

			env->ReleaseStringUTFChars(decodeString, pDecode);

		}

		else if (strcmp(pType, "virtualserial") == 0)

		{

			jstring portString = (jstring)env->GetObjectArrayElement(inSettings, 0);

			const char* pPort = env->GetStringUTFChars(portString, NULL);

			jstring decodeString = (jstring)env->GetObjectArrayElement(inSettings, 1);

			const char* pDecode = env->GetStringUTFChars(decodeString, NULL);

			TCDEBUGLOGA2(" vserial: pPort=%s decode=%s\n", pPort, pDecode);

			ServerCommandData cmd;

			cmd.command = eCmdConnect;

			strncpy(cmd.connectSettings.connectType, pType, MAX_CONNECTION_TYPE); 

			strncpy(cmd.connectSettings.virtualSerialSettings.comPort, pPort, MAX_COMPORT_SIZE);

			cmd.connectSettings.retryInterval = retryInterval;

			cmd.connectSettings.retryTimeout = retryTimeout;

			strncpy(cmd.connectSettings.decodeFormat, pDecode, MAX_DECODE_FORMAT);

			cmd.clientOptions.unWrapFormat = unWrapFormat;

			cmd.clientOptions.ostVersion = ostVersion;

			gManager->m_Server->SendCommand(&cmd);

			gManager->m_Server->GetResponse(&cmd);

			if (cmd.response == eRspError)

			{

				TCDEBUGLOGA1("  from server: ret = %d\n", cmd.error);

				ret = cmd.error;

				osError = cmd.osError;

			}

			else

			{

				TCDEBUGLOGA1("  from server: id = %d\n", cmd.clientId);

				clientId = cmd.clientId;

				gManager->WaitForErrorMonitorListAccess();

				CErrorMonitor* monitor = new CErrorMonitor(clientId);

				if (monitor != NULL)

				{

					monitor->CreateData();

					gManager->AddErrorMonitor(monitor);

				}

				gManager->ReleaseErrorMonitorListAccess();

				TCDEBUGLOGA1(" clientId=%d\n", clientId);

				jlong jClientId = clientId;

				env->SetLongArrayRegion(outClientId, 0, 1, &jClientId);

			}

			env->ReleaseStringUTFChars(portString, pPort);

			env->ReleaseStringUTFChars(decodeString, pDecode);

		}

		else if (strcmp(pType, "serial") == 0)

		{

			jstring portString = (jstring)env->GetObjectArrayElement(inSettings, 0);

			const char* pPort = env->GetStringUTFChars(portString, NULL);

			jstring baudString = (jstring)env->GetObjectArrayElement(inSettings, 1);

			const char* pBaud = env->GetStringUTFChars(baudString, NULL);

			jstring dataBitsString = (jstring)env->GetObjectArrayElement(inSettings, 2);

			const char* pDataBits = env->GetStringUTFChars(dataBitsString, NULL);

			jstring parityString = (jstring)env->GetObjectArrayElement(inSettings, 3);

			const char* pParity = env->GetStringUTFChars(parityString, NULL);

			jstring stopBitsString = (jstring)env->GetObjectArrayElement(inSettings, 4);

			const char* pStopBits = env->GetStringUTFChars(stopBitsString, NULL);

			jstring flowControlString = (jstring)env->GetObjectArrayElement(inSettings, 5);

			const char* pFlowControl = env->GetStringUTFChars(flowControlString, NULL);

			jstring decodeString = (jstring)env->GetObjectArrayElement(inSettings, 6);

			const char* pDecode = env->GetStringUTFChars(decodeString, NULL);

			TCDEBUGLOGA3(" real serial: pPort=%s pBaud=%s pDataBits=%s\n", pPort, pBaud, pDataBits);

			ServerCommandData cmd;

			cmd.command = eCmdConnect;

			strncpy(cmd.connectSettings.connectType, pType, MAX_CONNECTION_TYPE); 

			strncpy(cmd.connectSettings.realSerialSettings.comPort, pPort, MAX_COMPORT_SIZE);

			ConvertRealSerialSettingsToServer(pBaud, pDataBits, pParity, pStopBits, pFlowControl, &cmd.connectSettings.realSerialSettings);

			cmd.connectSettings.retryInterval = retryInterval;

			cmd.connectSettings.retryTimeout = retryTimeout;

			strncpy(cmd.connectSettings.decodeFormat, pDecode, MAX_DECODE_FORMAT);

			cmd.clientOptions.unWrapFormat = unWrapFormat;

			cmd.clientOptions.ostVersion = ostVersion;

			gManager->m_Server->SendCommand(&cmd);

			gManager->m_Server->GetResponse(&cmd);

			if (cmd.response == eRspError)

			{

				TCDEBUGLOGA1("  from server: ret = %d\n", cmd.error);

				ret = cmd.error;

				osError = cmd.osError;

			}

			else

			{

				TCDEBUGLOGA1("  from server: id = %d\n", cmd.clientId);

				clientId = cmd.clientId;

				gManager->WaitForErrorMonitorListAccess();

				CErrorMonitor* monitor = new CErrorMonitor(clientId);

				if (monitor != NULL)

				{

					monitor->CreateData();

					gManager->AddErrorMonitor(monitor);

				}

				gManager->ReleaseErrorMonitorListAccess();

				TCDEBUGLOGA1(" clientId=%d\n", clientId);

				jlong jClientId = clientId;

				env->SetLongArrayRegion(outClientId, 0, 1, &jClientId);

			}

			env->ReleaseStringUTFChars(portString, pPort);

			env->ReleaseStringUTFChars(baudString, pBaud);

			env->ReleaseStringUTFChars(dataBitsString, pDataBits);

			env->ReleaseStringUTFChars(parityString, pParity);

			env->ReleaseStringUTFChars(stopBitsString, pStopBits);

			env->ReleaseStringUTFChars(flowControlString, pFlowControl);

			env->ReleaseStringUTFChars(decodeString, pDecode);

		}

		else

		{

			TCDEBUGLOGS(" TCAPI_ERR_MEDIA_NOT_SUPPORTED\n");

			ret = TCAPI_ERR_MEDIA_NOT_SUPPORTED;

		}

		env->ReleaseStringUTFChars(inType, pType);

		// handle message destinations

		//  input stream is done by java on open input stream not here

		//  message file is done here

		if (ret == TCAPI_ERR_NONE)

		{

			long destination = DESTINATION_INPUTSTREAM;

			char* pMessageFile = NULL;

			if (inFilePath != NULL)

			{

				destination = DESTINATION_CLIENTFILE;

				jboolean isCopy=FALSE;

				pMessageFile = (char*)env->GetStringUTFChars(inFilePath, &isCopy);

				// send to TCFServer

				ServerCommandData cmd;

				cmd.command = eCmdOpenMessageFile;

				cmd.clientId = clientId;

				cmd.destinationOptions.destination = eDestinationFile;

				strncpy(cmd.destinationOptions.destinationFile, pMessageFile, MAX_FILEPATH);

				gManager->m_Server->SendCommand(&cmd);

				gManager->m_Server->GetResponse(&cmd);

				env->ReleaseStringUTFChars(inFilePath, pMessageFile);

			}

		}

	}

	gManager->m_Server->ReleaseServerPipeAccess();

	TCDEBUGLOGA3("nativeConnect return ret=%d, osError=%d : %s\n", ret, osError, GetErrorText(osError));

	TCDEBUGCLOSE();

	if (ret != TCAPI_ERR_NONE && osError > 0)

	{

		jclass clazz = env->FindClass("Ljava/lang/Exception;");

		env->ThrowNew(clazz, GetErrorText(osError));

	}

	return ret;

}

/*

 * Class:     com_nokia_tcf_impl_TCAPIConnection

 * Method:    nativeDisconnect

 * Signature: (J)J

 */

JNIEXPORT jlong JNICALL Java_com_nokia_tcf_impl_TCAPIConnection_nativeDisconnect

  (JNIEnv *env, jobject pThis, jlong inClientId)

{

	long ret = TCAPI_ERR_NONE;

	TCDEBUGOPEN();

	TCDEBUGLOGS("nativeDisconnect\n");

	if (gManager->m_Server == NULL)

	{

		TCDEBUGLOGS(" TCAPI_ERR_INVALID_HANDLE - gServer NULL\n");

		ret = TCAPI_ERR_INVALID_HANDLE;

	}

	else if (inClientId <= 0)

	{

		TCDEBUGLOGS(" TCAPI_ERR_INVALID_HANDLE - inClientId <= 0\n");

		ret = TCAPI_ERR_INVALID_HANDLE;

	}

	else

	{

		gManager->m_Server->WaitforServerPipeAccess();

		BOOL found = FALSE;

		long id = inClientId;

		TCDEBUGLOGA1(" look for clientId=%d\n", id);

		TCDEBUGLOGS(" TODO: tell server to disconnect this client\n");

		ServerCommandData cmdrsp;

		pServerCommandData pCmdrsp = &cmdrsp;

		pCmdrsp->command = eCmdDisconnect;

		pCmdrsp->clientId = id;

		gManager->m_Server->SendCommand(pCmdrsp);

		gManager->m_Server->GetResponse(pCmdrsp);

		if (pCmdrsp->response == eRspError)

		{

			ret = pCmdrsp->error;

		}

		{

			gManager->WaitForErrorMonitorListAccess();

			TCDEBUGLOGS(" TODO: destroy error monitor for this client\n");

			CErrorMonitor *monitor = gManager->FindErrorMonitor(id);

			if (monitor != NULL)

			{

				gManager->RemoveErrorMonitor(monitor);

				delete monitor;

			}

			gManager->ReleaseErrorMonitorListAccess();

		}

		gManager->m_Server->ReleaseServerPipeAccess();

	}

	TCDEBUGLOGA1(" return ret=%d\n", ret);

	TCDEBUGCLOSE();

	return ret;

}

/*

 * Class:     com_nokia_tcf_impl_TCAPIConnection

 * Method:    nativeGetNumberConnections

 * Signature: ([J)J

 */

JNIEXPORT jlong JNICALL Java_com_nokia_tcf_impl_TCAPIConnection_nativeGetNumberConnections

  (JNIEnv *env, jobject pThis, jlongArray outNumber)

{

	long ret = TCAPI_ERR_NONE;

	long number = 0;

	TCDEBUGOPEN();

	gManager->m_Server->WaitforServerPipeAccess();

	TCDEBUGLOGS("nativeGetNumberConnections\n");

	ServerCommandData cmdrsp;

	pServerCommandData pCmdrsp = &cmdrsp;

	pCmdrsp->command = eCmdGetNumberConnections;

	BOOL sent = gManager->m_Server->SendCommand(pCmdrsp);

	BOOL recd = gManager->m_Server->GetResponse(pCmdrsp);

	if (pCmdrsp->response == eRspError)

	{

		ret = pCmdrsp->error;

	}

	else

	{

		number = pCmdrsp->numConnections;