/*
* 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 <statcommon.h>
#include "dlltest_worker.h"
#include <stattask.h>
#include <statexp.h>

//////////////////////////////////////////////////////////////////////////
// Write the contents of a screenshot out to file
bool WriteBitmap(char *file, TBitmapFileHeader *fileheader, TBitmapInfoHeader * bmpHeader, char *bmpBits, unsigned long lSize)
{
	bool success = false;

	// write the whole lot out to file
	HANDLE infile;
	if (INVALID_HANDLE_VALUE != (infile = CreateFile(file,
										   GENERIC_WRITE,
										   0, 
										   NULL, 
										   CREATE_ALWAYS,
										   FILE_ATTRIBUTE_NORMAL,
										   0)))
	{
		DWORD dwBytesWritten = 0;

		// write the file info
		if (WriteFile(infile, (LPVOID *)fileheader, sizeof(TBitmapFileHeader), &dwBytesWritten, NULL) &&
			dwBytesWritten == sizeof(TBitmapFileHeader))
		{
			// write the bitmap info
			if (WriteFile(infile, (LPVOID *)bmpHeader, sizeof(TBitmapInfoHeader), &dwBytesWritten, NULL) &&
				dwBytesWritten == sizeof(TBitmapInfoHeader))
			{
				// write the bitmap data
				if (WriteFile(infile, (LPVOID *)bmpBits, lSize, &dwBytesWritten, NULL) &&
					dwBytesWritten == lSize)
				{
					success = true;
				}
			}
		}

		CloseHandle(infile);
	}

	return success;
}


//////////////////////////////////////////////////////////////////////////
// This thread function handles the processing of a script by a single
// connection
DWORD WINAPI
STATDeviceThreadProcedure(LPVOID lpParameter)
{
	DWORD valid = true;

	STATTASKINFO *pWorker = (STATTASKINFO *)lpParameter;
	if (pWorker)
	{
		int h = ConnectMT(pWorker->connectType, pWorker->szAddress);
		if (h)
		{
			printf("Version %s\r\n", Version());
			valid = SetCommandLogging(h, pWorker->pLogfile, NULL);
			valid = SetCommandDelay(h, pWorker->delay);

			if (valid)
				if (pWorker->verify)
					valid = SetImageVerification(h, pWorker->pRefdir, pWorker->removeImages?true:false, pWorker->fudge);

			if (valid)
			{
				for (int i=0;i<pWorker->iterations;i++)
				{
					//valid = SendRawCommand(h, pWorker->pCommand);
					valid = SendCommandFile(h, pWorker->pCommand);
					if (!valid)
					{
						printf("[%d] bad command(%s)\r\n", h, GetError(h));
						break;
					}

					/*struct TBitmapFileHeader *pFile = NULL;
					struct TBitmapInfoHeader *pInfo = NULL;
					char *pData = NULL;
					unsigned long lSize = 0;

					valid = GetSnapshot(h, &pFile, &pInfo, &pData, &lSize);
					if (valid)
						valid = WriteBitmap(pWorker->pSnapshot, pFile, pInfo, pData, lSize);
					if (!valid)
					{
						printf("[%d] bad command(%s)\r\n", h, GetError(h));
						break;
					}*/
				}
			}

			Disconnect(h);
		}
		else
			printf("Bad connection (%s)\r\n", GetError());
	}
	else
		printf("Bad parameter\r\n");

	return (DWORD)valid;
}


///////////////////////////////////////////////////////////////////////////////////////////////////////////
// Constructor
dlltest_worker::dlltest_worker()
: iterations(1), delay(100), lConectionCount(0), verify(0), removeImages(0), fudge(0)
{
	memset(szLogfile, 0, sizeof(szLogfile));
	memset(szCommand, 0, sizeof(szCommand));
	memset(szSnapshot, 0, sizeof(szSnapshot));
	memset(szRefdir, 0, sizeof(szRefdir));
}


///////////////////////////////////////////////////////////////////////////////////////////////////////////
// Destructor
dlltest_worker::~dlltest_worker()
{
	Finish();
}


///////////////////////////////////////////////////////////////////////////////////////////////////////////
// Get the settings and start the worker threads
bool dlltest_worker::Prepare()
{
	CStatIniFile statIniFile;
	statIniFile.SetIniFileName(STAT_INI_NAME);
	if(statIniFile.SectionExists(ST_TEST_KEY) )
	{
		CString setting;
		TCHAR szBuffer[2048];
		long lCount = 0;
		*(szBuffer) = (TCHAR)0;

		setting.Empty();
		setting=statIniFile.GetKeyValue(ST_ITERATIONS,ST_TEST_KEY);
		if(!setting.IsEmpty())
		{
			if (_ttoi(setting)<1)
				setting=_T("1");

			iterations=_ttoi(setting);
		}

		setting=statIniFile.GetKeyValue(ST_DELAY,ST_TEST_KEY);
		if(!setting.IsEmpty())
		{
			int iPos = _ttoi(setting);
			if (iPos < 100)
				setting= _T("100");

			if (iPos > 30000)
				setting= _T("30000");

			delay=_ttoi(setting);
		}

	// logging settings
		strcpy(szLogfile,(LPCSTR)statIniFile.GetKeyValue(ST_LOGFILE,ST_TEST_KEY));

	// raw command
		strcpy(szCommand,(LPCSTR)statIniFile.GetKeyValue(ST_CMDFILE,ST_TEST_KEY));

	// snapshot settings
		strcpy(szSnapshot,(LPCSTR)statIniFile.GetKeyValue(ST_SNAPSHOT,ST_TEST_KEY));

	// image verification settings
		verify=0;
		setting=statIniFile.GetKeyValue(ST_CHKVERIF,ST_TEST_KEY);
		if(!setting.IsEmpty())
		{
			verify=_ttol(setting);

		}
		removeImages=0;
		setting=statIniFile.GetKeyValue(ST_VERIFYREMOVEIMAGES,ST_TEST_KEY);
		if(!setting.IsEmpty())
		{
			removeImages=_ttol(setting);

		}
		strcpy(szRefdir,(LPCSTR)	statIniFile.GetKeyValue(ST_REFDIR,ST_TEST_KEY));
		setting.Empty();
		setting=statIniFile.GetKeyValue(ST_FUDGE,ST_TEST_KEY);
		if(!setting.IsEmpty())
			fudge = _ttoi(setting);

	// connection settings

		lConectionCount = 0;
		setting.Empty();
		setting=statIniFile.GetKeyValue(ST_CONNECTIONIDX,ST_TEST_KEY);
		if(!setting.IsEmpty())
		{
			lConectionCount = _ttol(setting);

		}
		if(statIniFile.SectionExists(ST_CONNECTION_LIST) )
		{
			for( int i=0;i<lConectionCount;++i)
			{
				TCHAR buf[6];
				_ltot(i+1, buf, 10);
				setting.Empty();
				setting=statIniFile.GetKeyValue(buf,ST_CONNECTION_LIST);
				if(!setting.IsEmpty())
					strcpy(szConections[i],(LPCSTR)(setting));
			}
		}
	}
	// turn on high-level logging
	SetConnectionLogging(szLogfile);

	// start the threads
	int i;
	for (i=0;i<lConectionCount;i++)
	{
		GetTaskInfo(i);
		pDeviceTask[i] = new STATTask(STATDeviceThreadProcedure, &TaskInfo[i]);
		if (pDeviceTask[i])
		{
			if (!pDeviceTask[i]->Start())
			{
				delete pDeviceTask[i];
				pDeviceTask[i] = NULL;
			}
		}
	}

	// wait a bit to allow the threads to start
	Sleep(500);

	return true;
}


/////////////////////////////////////////////////////////////////////////
// Check to see if all our jobs have finished
int dlltest_worker::WorkPending()
{
	int i;
	int count = 0;
	for (i=0;i<lConectionCount;i++)
	{
		if (pDeviceTask[i] && pDeviceTask[i]->StillActive())
		{
			count++;
		}
	}

	return count;
}

/////////////////////////////////////////////////////////////////////////
// Release any resources
void dlltest_worker::Finish()
{
	// kill the threads
	int i;
	for (i=0;i<lConectionCount;i++)
	{
		if (pDeviceTask[i])
		{
			pDeviceTask[i]->Kill();
			delete pDeviceTask[i];
			pDeviceTask[i] = NULL;
		}
	}

	// turn off high-level logging
	CloseConnectionLogging();
}


/////////////////////////////////////////////////////////////////////////
// PRIVATE METHODS
/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////
// Set task information for a single thread
void dlltest_worker::GetTaskInfo(int index)
{
	STATCONNECTTYPE type;
	char *addr;
	ParseConnection(szConections[index], &type, &addr);

	TaskInfo[index].connectType = type;
	TaskInfo[index].delay = delay;
	TaskInfo[index].fudge = fudge;
	TaskInfo[index].iterations = iterations;
	TaskInfo[index].removeImages = removeImages;
	TaskInfo[index].pCommand = szCommand;
	TaskInfo[index].pLogfile = szLogfile;
	TaskInfo[index].pRefdir = szRefdir;
	TaskInfo[index].pSnapshot = szSnapshot;
	TaskInfo[index].verify = verify;
	strcpy(TaskInfo[index].szAddress, addr);
}


//////////////////////////////////////////////////////////////////////////////////////
// Split a connection registry entry into its respective parts
void dlltest_worker::ParseConnection(char *pConnection, STATCONNECTTYPE *pType, char **ppAddress)
{
	(*pType) = SymbianInvalid;
	(*ppAddress) = NULL;

	static char szConnection[256];
	memset(szConnection, 0, sizeof(szConnection));
	strcpy(szConnection, pConnection);

	char *p = strchr(szConnection, ':');
	if (p)
	{
		(*p) = (char)0;
		(*ppAddress) = p + 1;

		if (stricmp(szConnection, "SymbianSocket") == 0)
		{
			(*pType) = SymbianSocket;
		}
		else if (stricmp(szConnection, "SymbianSerial") == 0)
		{
			(*pType) = SymbianSerial;
		}
		else if (stricmp(szConnection, "SymbianInfrared") == 0)
		{
			(*pType) = SymbianInfrared;
		}
		else if (stricmp(szConnection, "SymbianBluetooth") == 0)
		{
			(*pType) = SymbianBluetooth;
		}
		else if (stricmp(szConnection, "SymbianUSB") == 0)
		{
			(*pType) = SymbianUSB;
		}

		(*p) = ':';
	}
}