/*
* 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:  
*
*/




#include "stdafx.h"
#include "statexp.h"
#include "statlist.h"

//////////////////////////////////////////////////////////////////////////
// our thread-safe mechanism for list manipulation and back-end processing
CRITICAL_SECTION CriticalSection;
//////////////////////////////////////////////////////////////////////////

// get the version
STAT_EXPORT const char * __cdecl Version()
{
	return aList.Version();
}

// set logging for main STAT connection interface
STAT_EXPORT int __cdecl SetConnectionLogging(const char *pszLogPath)
{
	EnterCriticalSection(&CriticalSection);

	int valid = aList.SetLogging(pszLogPath);

	LeaveCriticalSection(&CriticalSection);
	return valid;
}

// set logging for main STAT connection interface
STAT_EXPORT void __cdecl CloseConnectionLogging()
{
	EnterCriticalSection(&CriticalSection);

	aList.StopLogging();

	LeaveCriticalSection(&CriticalSection);
}

// connect to the remote target
STAT_EXPORT int __cdecl Connect(const STATCONNECTTYPE iConnectType, const char *pszPlatformType, void *Reserved1, void *Reserved2)
{
	EnterCriticalSection(&CriticalSection);

	int valid = false;

	// unused parameters
	(void)Reserved1;
	(void)Reserved2;

	if (iConnectType && pszPlatformType && (*pszPlatformType))
		valid = aList.CreateListMember(iConnectType, pszPlatformType);
	else
		strcpy(aList.szErrorText, "Invalid or missing parameter(s)");

	LeaveCriticalSection(&CriticalSection);
	return valid;
}

STAT_EXPORT int __cdecl ConnectMT(const STATCONNECTTYPE iConnectType, const char *pszPlatformType)
{
	EnterCriticalSection(&CriticalSection);

	int valid = Connect(iConnectType, pszPlatformType);
	if (valid)
	{
		aList.Member(valid)->SetMultithreaded();
	}

	LeaveCriticalSection(&CriticalSection);
	return valid;
}

// set the delay between executed commands
STAT_EXPORT int __cdecl SetCommandDelay(const int handle, const unsigned int iMillisecondDelay)
{
	EnterCriticalSection(&CriticalSection);

	int valid = false;

	if (handle && aList.ListExists())
		valid = aList.Member(handle)->SetCommandDelay(iMillisecondDelay);
	else
		strcpy(aList.szErrorText, "Invalid parameter(s) or connection does not exist");

	LeaveCriticalSection(&CriticalSection);
	return valid;
}

// set logging for individual STAT connection command processing
STAT_EXPORT int __cdecl SetCommandLogging(const int handle,
						   const char *pszLogPath,
						   MessageReporter *const aMessageReporter,
						   const STATLOGLEVEL iLevel,
					       const bool bAppend,
						   void* Reserved1,
						   void* Reserved2)
{
	EnterCriticalSection(&CriticalSection);

	int valid = false;

	// unused parameters
	(void)iLevel;
	(void)Reserved1;
	(void)Reserved2;

	if (handle && aList.ListExists())
		valid = aList.Member(handle)->SetLogging(STATDLLMember::ToUnicode(pszLogPath), bAppend, aMessageReporter);
	else
		strcpy(aList.szErrorText, "Invalid handle or connection does not exist");

	LeaveCriticalSection(&CriticalSection);
	return valid;
}

// set image verification settings
STAT_EXPORT int __cdecl SetImageVerification(const int handle, const char * pszRefDir, const bool bRemoveOldImages, const int iFactor)
{
	EnterCriticalSection(&CriticalSection);

	int valid = false;

	if (handle && aList.ListExists())
		valid = aList.Member(handle)->SetImageVerification(STATDLLMember::ToUnicode(pszRefDir), bRemoveOldImages, iFactor);
	else
		strcpy(aList.szErrorText, "Invalid parameter(s) or connection does not exist");

	LeaveCriticalSection(&CriticalSection);
	return valid;
}

// open a script file within the member
STAT_EXPORT int __cdecl OpenScriptFile(const int handle, const char *pszText, bool bIsFile)
{
	if (handle && aList.ListExists())
		return aList.Member(handle)->OpenScriptFile(STATDLLMember::ToUnicode(pszText), bIsFile);

	strcpy(aList.szErrorText, "Invalid parameter(s) or connection does not exist");
	return false;
}

// run a command in the script engine
STAT_EXPORT int __cdecl RunScript(const int handle, ScriptProgressMonitor *const monitor)
{
	if (handle && aList.ListExists())
		return aList.Member(handle)->RunScript(monitor);

	strcpy(aList.szErrorText, "Invalid parameter(s) or connection does not exist");
	return false;
}

// send a command to the remote target
STAT_EXPORT int __cdecl SendRawCommand(const int handle, const char *pszText, ScriptProgressMonitor *const monitor)
{
	if (handle && aList.ListExists())
		return aList.Member(handle)->SendRawCommand(STATDLLMember::ToUnicode(pszText), monitor);

	strcpy(aList.szErrorText, "Invalid parameter(s) or connection does not exist");
	return false;
}

// send a command to the remote target
STAT_EXPORT int __cdecl SendCommandFile(const int handle, const char *pszText, ScriptProgressMonitor *const monitor)
{
	if (handle && aList.ListExists())
		return aList.Member(handle)->SendCommandFile(STATDLLMember::ToUnicode(pszText), monitor);

	strcpy(aList.szErrorText, "Invalid parameter(s) or connection does not exist");
	return false;
}

// get the number of commands in the current script
STAT_EXPORT int __cdecl GetCommandCount(const int handle, const char *pszFile, int *commandCount)
{
	if (handle && aList.ListExists())
		return aList.Member(handle)->GetCommandCount(pszFile, commandCount);

	strcpy(aList.szErrorText, "Invalid parameter(s) or connection does not exist");
	return false;
}

// get the number of current command
STAT_EXPORT int __cdecl GetCurrentCommandNumber(const int handle, int *commandNumber)
{
	if (handle && aList.ListExists())
		return aList.Member(handle)->GetCurrentCommandNumber(commandNumber);

	strcpy(aList.szErrorText, "Invalid parameter(s) or connection does not exist");
	return false;
}

// get the text received by the last command
STAT_EXPORT const char* __cdecl GetReceivedData(const int handle)
{
	if (handle && aList.ListExists())
		return aList.Member(handle)->GetReceivedData();

	strcpy(aList.szErrorText, "Invalid parameter(s) or connection does not exist");
	return NULL;
}

// stop processing the current command on the remote target
STAT_EXPORT int __cdecl StopProcessing(int handle)
{
	if (handle && aList.ListExists())
		return aList.Member(handle)->StopProcessing();

	strcpy(aList.szErrorText, "Invalid parameter(s) or connection does not exist");
	return false;
}

// get a bitmap snapshot of the remote target
STAT_EXPORT int __cdecl GetSnapshot(const int handle, TBitmapFileHeader **ppFile, TBitmapInfoHeader **ppBitmap, char **ppData, unsigned long *pSize)
{
	if (handle && aList.ListExists())
		return aList.Member(handle)->GetSnapshot(ppFile, ppBitmap, ppData, pSize);

	strcpy(aList.szErrorText, "Invalid parameter(s) or connection does not exist");
	return false;
}

// disconnect from the remote target
STAT_EXPORT int __cdecl Disconnect(const int handle)
{
	EnterCriticalSection(&CriticalSection);

	int valid = false;

	if (handle && aList.ListExists())
		valid = aList.RemoveListMember(handle);
	else
		strcpy(aList.szErrorText, "Invalid handle or connection does not exist");

	LeaveCriticalSection(&CriticalSection);
	return valid;
}

// get the last error thrown
STAT_EXPORT const char * __cdecl GetError(const int handle)
{
	if (handle && aList.ListExists())
		return aList.Member(handle)->GetErrorText();

	return aList.szErrorText;
}

// get the error text for a particular error code
STAT_EXPORT const char * __cdecl GetErrorText(const int handle, int errorCode)
{
	if (handle && aList.ListExists())
		return aList.Member(handle)->GetErrorText(errorCode);

	return aList.szErrorText;
}

// get the TEF Shared Data
STAT_EXPORT const char * __cdecl GetTEFSharedData(const int handle)
{
	if (handle && aList.ListExists())
		return aList.Member(handle)->GetTEFSharedData();

	return NULL;
}

///////////////////////////////////////////////////////////////////////////////////////
// STD CALL ENTRYPOINTS
///////////////////////////////////////////////////////////////////////////////////////

STAT_EXPORT const char * __stdcall StdVersion()
{
	return Version();
}

STAT_EXPORT const char * __stdcall StdGetError(const int handle)
{
	return GetError(handle);
}

STAT_EXPORT const char * __stdcall StdGetErrorText(const int handle, int errorCode)
{
	return GetErrorText(handle, errorCode);
}

STAT_EXPORT const char * __stdcall StdGetTEFSharedData(const int handle)
{
	return GetTEFSharedData(handle);
}

STAT_EXPORT int __stdcall StdSetConnectionLogging(const char *filename)
{
	return (SetConnectionLogging(filename));
}

STAT_EXPORT void __stdcall StdCloseConnectionLogging()
{
	CloseConnectionLogging();
}

STAT_EXPORT int __stdcall StdConnect(const STATCONNECTTYPE iConnectType, const char *pszPlatformType, void *Reserved1, void *Reserved2)
{
	return (Connect(iConnectType, pszPlatformType, Reserved1, Reserved2));
}

STAT_EXPORT int __stdcall StdConnectMT(const STATCONNECTTYPE iConnectType, const char *pszPlatformType)
{
	return (ConnectMT(iConnectType, pszPlatformType));
}

STAT_EXPORT int __stdcall StdDisconnect(const int handle)
{
	return Disconnect(handle);
}

STAT_EXPORT int __stdcall StdSetCommandDelay(const int handle, const unsigned int iMillisecondDelay)
{
	return SetCommandDelay(handle, iMillisecondDelay);
}

STAT_EXPORT int __stdcall StdSetCommandLogging(const int handle, 
											const char *pszLogPath,
											MessageReporter *const aMessageReporter,
											const STATLOGLEVEL iLevel,
											const bool bAppend,
											void* Reserved1,
											void* Reserved2)
{ 
	return SetCommandLogging(handle,
							pszLogPath,
							aMessageReporter,
							iLevel,
							bAppend,
							Reserved1,
							Reserved2);
}

STAT_EXPORT int __stdcall StdSetImageVerification(const int handle, const char *pszRefDir, const bool bRemoveOldImages, const int iFactor)
{
	return SetImageVerification(handle, pszRefDir, bRemoveOldImages, iFactor);
}

STAT_EXPORT int __stdcall StdOpenScriptFile(const int handle, LPCTSTR pszText, bool bIsFile)
{
	return OpenScriptFile(handle, pszText, bIsFile);
}

STAT_EXPORT int __stdcall StdRunScript(const int handle, ScriptProgressMonitor *const monitor)
{
	return RunScript(handle, monitor);
}

STAT_EXPORT int __stdcall StdSendRawCommand(const int handle, const char *pszText, ScriptProgressMonitor *const monitor)
{
	return SendRawCommand(handle, pszText, monitor);
}

STAT_EXPORT int __stdcall StdSendCommandFile(const int handle, const char *pszFile, ScriptProgressMonitor *const monitor)
{
	return SendCommandFile(handle, pszFile, monitor);
}

STAT_EXPORT int __stdcall StdGetCommandCount(const int handle, const char *pszFile, int *commandCount)
{
	return GetCommandCount(handle, pszFile, commandCount);
}

STAT_EXPORT int __stdcall StdGetCurrentCommandNumber(const int handle, int *commandNumber)
{
	return GetCurrentCommandNumber(handle, commandNumber);
}

STAT_EXPORT const char* __stdcall StdGetReceivedData(const int handle)
{
	return GetReceivedData(handle);
}

STAT_EXPORT int __stdcall StdStopProcessing(int handle)
{
	return StopProcessing(handle);
}

STAT_EXPORT int __stdcall StdGetSnapshot(int handle, TBitmapFileHeader **ppFile, TBitmapInfoHeader **ppBitmap, char **ppData, unsigned long *pSize)
{
	return GetSnapshot(handle, ppFile, ppBitmap, ppData, pSize);
}