/*
* 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 "statlist.h"

////////////////////////////////////////////////////////////////////////////////////////
// The one and only connection list
STATDLLList aList;

//////////////////////////////////////////////////////////////////////////////////////////
// Constructor
STATDLLList::STATDLLList()
: ListStart(0)
{
	InitializeCriticalSection(&CriticalSection);

	memset(szVersion, 0, sizeof(szVersion));
	sprintf(szVersion, "%s.%s.%s", STAT_VERSION_MAJOR, STAT_VERSION_MINOR, STAT_VERSION_PATCH);

}


//////////////////////////////////////////////////////////////////////////////////////////
// Destructor
//
STATDLLList::~STATDLLList()
{
	// release list members (passing 0 will return the last member in the list)
	STATDLLMember* pMember = Member(0);
	while(pMember)
	{
		RemoveListMember((DWORD)pMember);
		pMember = Member(0);
	}

	StopLogging();
	DeleteCriticalSection(&CriticalSection);
}


//////////////////////////////////////////////////////////////////////////////////////////
// Turns on logging for STAT multiple connection management.
//
int
STATDLLList::SetLogging(const char *path)
{
	bool valid = false;
	if (!oRep.active())
	{
		// split path into folder/file
		char folder[MAX_PATH + 1] = {0};
		strcpy(folder, path);
		char *ptr = strrchr(folder, '\\');
		if (ptr)
		{
			char file[MAX_PATH + 1] = {0};
			strcpy(file, ptr + 1);
			(*ptr) = (char)0;

			if (*file)
			{
				if (oRep.init(STAT_APPNAME, RPT_ALL, RPT_FILE, folder, file))
				{
					oRep.dash();
					oRep.header("%s", STAT_APPNAME);
					valid = true;
				}
				else
					strcpy(szErrorText, "Connection logging failed (file system error).");
			}
			else
				strcpy(szErrorText, "Connection logging failed (invalid filename).");
		}
		else
			strcpy(szErrorText, "Connection logging failed (invalid path).");
	}
	else
		strcpy(szErrorText, "Connection logging is already initialised.");

	return valid;
}


//////////////////////////////////////////////////////////////////////////////////////////
// Turns off logging
//
void
STATDLLList::StopLogging()
{
	if (oRep.active())
		oRep.kill();
}


//////////////////////////////////////////////////////////////////////////////////////////
// Open a connection with a new list member
//
DWORD
STATDLLList::CreateListMember(const STATCONNECTTYPE iConnectType, const char *pszPlatformType)
{
	bool valid = false;

	(*szErrorText) = (char)0;
	oRep.info("Creating new list member (%d : %s)...", iConnectType, pszPlatformType);

	STATDLLMember *ptr = new STATDLLMember(iConnectType, pszPlatformType, &oRep);
	if (ptr)
	{
		if (ptr->GetErrorCode() == ITS_OK)
		{
			// add to list
			if (ListStart)
			{
				ptr->lPrevConnection = Member(0);				// returns last member in list
				ptr->lPrevConnection->lNextConnection = ptr;
				ptr->lNextConnection = NULL;
			}
			else
			{
				ListStart = ptr;
			}

//			WalkList();

			oRep.info("Member %ld (%d : %s) created", ptr, iConnectType, pszPlatformType);
			valid = true;
		}
		else
		{
			// save the error thrown
			strcpy(szErrorText, ptr->GetErrorText());
			delete ptr;
			ptr = NULL;
		}
	}

	if (!ptr || !valid)
		oRep.error("ERROR: Could not create new member");

	return (DWORD)ptr;
}


//////////////////////////////////////////////////////////////////////////////////////////
// Find and return a member connection
// If 0 or bad pointer is passed, will return the last position in the list
// If nothing in list, will return NULL
//
STATDLLMember*
STATDLLList::Member(const DWORD dwHandle)
{
	STATDLLMember *current = 0, *next = 0;
	next = ListStart;
	while (next)
	{
		current = next;
		if (current == (STATDLLMember *)dwHandle)
			break;

		next = current->lNextConnection;
	}

	return current;
}


//////////////////////////////////////////////////////////////////////////////////////////
// Close a member connection
//
bool
STATDLLList::RemoveListMember(const DWORD dwHandle)
{
	STATDLLMember *current = Member(dwHandle);
	oRep.info("Removing list member %ld...", dwHandle);
	bool valid = false;

	// remove from list
	if (current)
	{
		// something before
		if (current->lPrevConnection)
			current->lPrevConnection->lNextConnection = current->lNextConnection;
		else
			ListStart = current->lNextConnection;

		// something after
		if (current->lNextConnection)
			current->lNextConnection->lPrevConnection = current->lPrevConnection;

		delete current;
		oRep.info("Member removed");

//		WalkList();

		valid = true;
	}
	else
		oRep.error("ERROR: Could not remove");

	return valid;
}


//////////////////////////////////////////////////////////////////////////////////////////
// Private Methods
//////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////
// walks the list for debug purposes
//
void
STATDLLList::WalkList()
{
	if (ListStart)
		oRep.dash();

	STATDLLMember *current = 0, *next = 0;
	next = ListStart;
	while (next)
	{
		current = next;

		oRep.info("Member details: Previous:%ld this:%ld Next:%ld",
			current->lPrevConnection, current, current->lNextConnection);

		next = current->lNextConnection;
	}

	if (ListStart)
		oRep.dash();
}