// Copyright (c) 2004-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:
//

/**
 @file
 @internalComponent
*/

#include <bluetooth/logger.h>
#include "connectionhistory.h"
#include "connections.h"
#include "utils.h"

#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, LOG_COMPONENT_REMCON_SERVER);
#endif

#ifdef _DEBUG
PANICCATEGORY("connhist");
#endif

#ifdef __FLOG_ACTIVE
#define LOGCOLLECTIONPOOL	LogCollectionPool()
#define LOGADDRESSPOOL		LogAddressPool()
#else
#define LOGCOLLECTIONPOOL
#define LOGADDRESSPOOL
#endif // __FLOG_ACTIVE

CConnectionHistory* CConnectionHistory::NewL()
	{
	LOG_STATIC_FUNC
	CConnectionHistory* self = new(ELeave) CConnectionHistory();
	CleanupStack::PushL(self);
	self->ConstructL();
	CLEANUPSTACK_POP1(self);
	return self;
	}

CConnectionHistory::CConnectionHistory()
 :	iHistory(_FOFF(CConnections, iLink)),
	iConnectionsPool(_FOFF(CConnections, iLink)),
	iAddressPool(_FOFF(TRemConAddress, iLink))
	{
	LOG_FUNC
	}

void CConnectionHistory::ConstructL()
	{
	LOG_FUNC;

	// Start the history off with the start-up state of the system- no 
	// connections.
	CConnections* const conns = CConnections::NewL();
	iHistory.AddLast(*conns);

	LogConnectionHistory();
	}

CConnectionHistory::~CConnectionHistory()
	{
	LOG_FUNC;
	LogConnectionHistory();
	LOGCOLLECTIONPOOL;
	LOGADDRESSPOOL;

	// Clean up all the collections of everything!

	LOG(_L("\tdestroying history..."));
		{
		TSglQueIter<CConnections> iter1(iHistory);
		CConnections* conns1;
		while ( ( conns1 = iter1++ ) != NULL )
			{
			iHistory.Remove(*conns1);
			delete conns1;
			}
		}

	LOG(_L("\tdestroying connections pool..."));
		{
		TSglQueIter<CConnections> iter2(iConnectionsPool);
		CConnections* conns2;
		while ( ( conns2 = iter2++ ) != NULL )
			{
			iConnectionsPool.Remove(*conns2);
			delete conns2;
			}
		}

	LOG(_L("\tdestroying address pool..."));
		{
		TSglQueIter<TRemConAddress> iter3(iAddressPool);
		TRemConAddress* addr;		 
		while ( ( addr = iter3++ ) != NULL )
			{
			iAddressPool.Remove(*addr);
			delete addr;
			}
		}
	
	// Can't LogConnectionHistory here because it breaks our invariant (we've 
	// deleted all the history items, so it's empty and Count == 0).
	LOGCOLLECTIONPOOL;
	LOGADDRESSPOOL;
	}

void CConnectionHistory::DestroyFirst()
	{
	LOG_FUNC;
	LogConnectionHistory();

	ASSERT_DEBUG(!iHistory.IsEmpty());
	CConnections* conn = iHistory.First();
	ASSERT_DEBUG(conn);
	iHistory.Remove(*conn);
	delete conn;
	ASSERT_DEBUG(!iHistory.IsEmpty());

	LogConnectionHistory();
	}

TUint CConnectionHistory::Count() const
	{
	TUint count = 0;

	TSglQueIter<CConnections> iter(const_cast<CConnectionHistory*>(this)->iHistory);
	while ( iter++ != NULL )
		{
		++count;
		}

	ASSERT_DEBUG(count >= 1);
	return count;
	}

const CConnections& CConnectionHistory::operator[](TUint aIndex)
	{
	TSglQueIter<CConnections> iter(iHistory);
	CConnections* conn;
	TUint count = 0;
	while ( ( conn = iter++ ) != NULL )
		{
		if ( count == aIndex )
			{
			break;
			}
		++count;
		}
	ASSERT_DEBUG(conn);
	return *conn;
	}

CConnections& CConnectionHistory::Last()
	{
	// The connection history should never be empty. It should always hold at 
	// least the current connection set.
	ASSERT_DEBUG(!iHistory.IsEmpty());

	CConnections* last = iHistory.Last();
	ASSERT_DEBUG(last);
	return *last;
	}

TInt CConnectionHistory::NewConnection(const TRemConAddress& aAddr)
	{
	LOG_FUNC;
	LogConnectionHistory();
	LOGCOLLECTIONPOOL;
	LOGADDRESSPOOL;

	TRAPD(err, NewConnectionL(aAddr));
	LOG1(_L("\terr = %d"), err);
	
	LogConnectionHistory();
	LOGCOLLECTIONPOOL;
	LOGADDRESSPOOL;

	return err;
	}

void CConnectionHistory::NewConnectionL(const TRemConAddress& aAddr)
	{
	// Called to handle a new connection by updating the connection history.
	// Create a copy of the Last item (CConnections) in the history, add the 
	// new address to it, and add that (the new CConnections) to the end of 
	// the history.
	// Then, in order to guarantee that any subsequent disconnection will 
	// work, allocate a new CConnections and add it to the pool of 
	// CConnections iConnectionsPool. Also allocate N TRemConAddresses and add 
	// them to the pool iAddressPool, where N is the number of remotes in the 
	// old head CConnections. 
	// When a disconnection occurs, the new CConnections will be got from 
	// iConnectionsPool, and the required TRemConAddresses will be got from 
	// iAddressPool- without failing.
	// If any of this fails, roll us back to how we were at the beginning of 
	// the call and leave.
	// At the end the history will have a new Last, with one new item in it. 

	// Make a new item for the history...
	CConnections* const newSetOfConnections = CConnections::CopyL(Last());
	CleanupStack::PushL(newSetOfConnections);
	TRemConAddress* const addr = new(ELeave) TRemConAddress;
	*addr = aAddr;
	newSetOfConnections->Append(*addr);
	// Leave newSetOfConnections on the cleanup stack so if we leave it gets 
	// destroyed automatically.
	
	// ...and pre-allocate memory.
	CConnections* conn = CConnections::NewL();
	CleanupStack::PushL(conn); // leave this on the cleanup stack so it gets 
	// dealt with if we leave.

	// Get the number of TRemConAddresses we need to pre-allocate.
	const TUint count = Last().Count();
	for ( TUint ii = 0 ; ii < count ; ++ii )
		{
		TRemConAddress* preAllocAddr = new TRemConAddress;
		if ( preAllocAddr )
			{
			iAddressPool.AddLast(*preAllocAddr);
			}
		else
			{
			// We couldn't pre-allocate as much as we needed... destroy as 
			// many TRemConAddresses as we have already made and leave. 
			for ( TUint jj = 0 ; jj < ii ; ++jj )
				{
				ASSERT_DEBUG(!iAddressPool.IsEmpty());
				TRemConAddress* removeAddr = iAddressPool.Last();
				ASSERT_DEBUG(removeAddr);
				iAddressPool.Remove(*removeAddr);
				delete removeAddr;
				}
			// This leave will clean up the pre-allocated CConnections and the 
			// new 'real' CConnections.
			LEAVEIFERRORL(KErrNoMemory);
			}
		}

	// If we got to here, do some sanity checking, clean up the cleanup stack 
	// (!) and finally add the new history item.
	CLEANUPSTACK_POP1(conn);
	iConnectionsPool.AddLast(*conn);
	
	ASSERT_DEBUG(newSetOfConnections->Count() == Last().Count() + 1);
	
	CLEANUPSTACK_POP1(newSetOfConnections);
	iHistory.AddLast(*newSetOfConnections); 
	}

void CConnectionHistory::Disconnection(const TRemConAddress& aAddr)
	{
	LOG_FUNC;
	LogConnectionHistory();
	LOGCOLLECTIONPOOL;
	LOGADDRESSPOOL;
	
	// Called to handle a disconnection by updating the connection history.
	// In order for this operation to be guaranteed to work, we must take a 
	// CConnections from the pool iConnectionsPool, and, for each 
	// TRemConAddress in Last, _except the one being disconnected in this 
	// call_, copy it into a TRemConAddress taken from the iAddressPool, and 
	// add it to the reclaimed CConnections. Finally add the CConnections to 
	// the history.
	// At the end the history will have a new Last with one less remote in it 
	// than the previous.

	// Get a CConnections from the pool.
	ASSERT_DEBUG(!iConnectionsPool.IsEmpty());
	CConnections* newSetOfConnections = iConnectionsPool.Last();
	ASSERT_DEBUG(newSetOfConnections);
	iConnectionsPool.Remove(*newSetOfConnections);

	// Copy addresses from Last into newSetOfConnections, except the one being 
	// disconnected.
	CConnections& last = Last();
	TSglQueIter<TRemConAddress>& iter = last.SetToFirst();
	TRemConAddress* conn = NULL;
	while ( ( conn = iter++ ) != NULL )
		{
		if ( !(*conn == aAddr) )
			{
			ASSERT_DEBUG(!iAddressPool.IsEmpty());
			TRemConAddress* const newAddr = iAddressPool.Last();
			ASSERT_DEBUG(newAddr);
			iAddressPool.Remove(*newAddr);
			*newAddr = *conn;
			newSetOfConnections->Append(*newAddr);
			}
		}

	// Sanity check and finally add the new CConnections to the history.
	ASSERT_DEBUG(newSetOfConnections->Count() == Last().Count() - 1);
	iHistory.AddLast(*newSetOfConnections);

	LogConnectionHistory();
	LOGCOLLECTIONPOOL;
	LOGADDRESSPOOL;
	}

void CConnectionHistory::LogConnectionHistory() const
	{
#ifdef __FLOG_ACTIVE

	const TUint count = Count();
	LOG1(_L("\tNumber of items in history = %d"), count);
	TSglQueIter<CConnections> iter(const_cast<CConnectionHistory*>(this)->iHistory);
	CConnections* conns;
	while ( ( conns = iter++ ) != NULL )
		{
		LOG1(_L("\t\titem [0x%08x]:"), conns);
		conns->LogConnections();
		}

#endif // __FLOG_ACTIVE
	}

#ifdef __FLOG_ACTIVE
void CConnectionHistory::LogCollectionPool() const
	{
	LOG(_L("\tLogging pre-allocated connections pool"));
	TSglQueIter<CConnections> iter(const_cast<CConnectionHistory*>(this)->iConnectionsPool);
	CConnections* conns;
	while ( ( conns = iter++ ) != NULL )
		{
		LOG1(_L("\t\titem [0x%08x]:"), conns);
		}
	}

void CConnectionHistory::LogAddressPool() const
	{
	LOG(_L("\tLogging pre-allocated address pool"));
	TSglQueIter<TRemConAddress> iter(const_cast<CConnectionHistory*>(this)->iAddressPool);
	TRemConAddress* addr;
	while ( ( addr = iter++ ) != NULL )
		{
		LOG1(_L("\t\titem [0x%08x]:"), addr);
		}
	}
#endif // __FLOG_ACTIVE