/*
* 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 "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 <memspy/engine/memspyenginehelperserver.h>

// Driver includes
#include <memspy/driver/memspydriverclient.h>
#include <memspy/driver/memspydriverconstants.h>

// User includes
#include <memspy/engine/memspyengine.h>
#include <memspy/engine/memspyengineoutputsink.h>
#include <memspy/engine/memspyengineobjectthread.h>
#include <memspy/engine/memspyengineobjectprocess.h>
#include <memspy/engine/memspyengineobjectcontainer.h>
#include <memspy/engine/memspyenginehelperchunk.h>

// Literal constants
_LIT( KMemSpyEngineServListOutputComma, ", " );



CMemSpyEngineHelperServer::CMemSpyEngineHelperServer( CMemSpyEngine& aEngine )
:   iEngine( aEngine )
    {
    }

    
CMemSpyEngineHelperServer::~CMemSpyEngineHelperServer()
    {
    }


void CMemSpyEngineHelperServer::ConstructL()
    {
    }


CMemSpyEngineHelperServer* CMemSpyEngineHelperServer::NewL( CMemSpyEngine& aEngine )
    {
    CMemSpyEngineHelperServer* self = new(ELeave) CMemSpyEngineHelperServer( aEngine );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }


EXPORT_C void CMemSpyEngineHelperServer::GetServerSessionsL( TAny* aServerHandle, RArray<TMemSpyDriverServerSessionInfo>& aSessions )
    {
	const TInt KMaxCount = 256;
	TAny* handles[KMaxCount];
	TInt c = KMaxCount;

	TInt r = iEngine.Driver().GetServerSessionHandles( aServerHandle, handles, c );
	if  ( r == KErrNone )
    	{
        if  ( c > 0 )
            {
        	if (c > KMaxCount)
        		{
        		c = KMaxCount;
        		}

        	TMemSpyDriverServerSessionInfo info;
        	for (TInt i=0; i<c; i++)
        		{
        		r = iEngine.Driver().GetServerSessionInfo( handles[i], info );
        		if (r == KErrNone)
        			{
        			aSessions.AppendL( info );
        			}
        		}
            }
        }
    }


EXPORT_C void CMemSpyEngineHelperServer::GetServerSessionsL( const TMemSpyDriverHandleInfoGeneric& aServerDetails, RArray<TMemSpyDriverServerSessionInfo>& aSessions )
    {
    GetServerSessionsL( aServerDetails.iHandle, aSessions );
    }


EXPORT_C void CMemSpyEngineHelperServer::GetServerListL( RArray<TMemSpyDriverHandleInfoGeneric>& aServers )
    {
	const TInt KMaxCount = 256;
	TAny* handles[KMaxCount];
	TInt c = KMaxCount;

	TInt r = iEngine.Driver().GetContainerHandles( EMemSpyDriverContainerTypeServer, handles, c );
	if  ( r == KErrNone )
    	{
        if  ( c > 0 )
            {
        	if (c > KMaxCount)
        		{
        		c = KMaxCount;
        		}

        	TMemSpyDriverHandleInfoGeneric info;
        	for (TInt i=0; i<c; i++)
        		{
        		r = iEngine.Driver().GetGenericHandleInfo( KMemSpyDriverEnumerateContainerHandles, EMemSpyDriverContainerTypeServer, handles[i], info );
        		if (r == KErrNone)
        			{
        			aServers.AppendL( info );
        			}
        		}
            }
        }
    }


EXPORT_C CMemSpyEngineServerList* CMemSpyEngineHelperServer::ServerListL()
    {
    CMemSpyEngineServerList* list = CMemSpyEngineServerList::NewLC();
    //
    RArray<TMemSpyDriverHandleInfoGeneric> servers;
    CleanupClosePushL( servers );
    //
    GetServerListL( servers );
    //
    const TInt count = servers.Count();
    for( TInt i=0; i<count; i++ )
        {
        const TMemSpyDriverHandleInfoGeneric& details = servers[ i ];
        //
        CMemSpyEngineServerEntry* serverEntry = CMemSpyEngineServerEntry::NewLC( details );
        list->AddItemL( serverEntry );
        CleanupStack::Pop( serverEntry );
        }
    //
    CleanupStack::PopAndDestroy( &servers );

    // Sort the list by session count
    list->SortBySessionCountL();

    // Done
    CleanupStack::Pop( list );
    return list;
    }


CMemSpyEngine& CMemSpyEngineHelperServer::Engine() const
    {
    return iEngine;
    }



































CMemSpyEngineServerList::CMemSpyEngineServerList()
    {
    }


EXPORT_C CMemSpyEngineServerList::~CMemSpyEngineServerList()
    {
    iItems.ResetAndDestroy();
    iItems.Close();
    }


void CMemSpyEngineServerList::ConstructL()
    {
    }


CMemSpyEngineServerList* CMemSpyEngineServerList::NewLC()
    {
    CMemSpyEngineServerList* self = new(ELeave) CMemSpyEngineServerList();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


EXPORT_C TInt CMemSpyEngineServerList::Count() const
    {
    return iItems.Count();
    }


EXPORT_C const CMemSpyEngineServerEntry& CMemSpyEngineServerList::At( TInt aIndex ) const
    {
    return *iItems[ aIndex ];
    }


EXPORT_C void CMemSpyEngineServerList::SortByNameL()
    {
    TLinearOrder< CMemSpyEngineServerEntry > comparer( CompareByName );
    iItems.Sort( comparer );
    }


EXPORT_C void CMemSpyEngineServerList::SortBySessionCountL()
    {
    TLinearOrder< CMemSpyEngineServerEntry > comparer( CompareBySessionCount );
    iItems.Sort( comparer );
    }


EXPORT_C TInt CMemSpyEngineServerList::ItemIndex( const CMemSpyEngineServerEntry& aEntry ) const
    {
    TInt ret = KErrNotFound;
    //
    const TInt count = Count();
    for( TInt i=0; i<count; i++ )
        {
        const CMemSpyEngineServerEntry* item = iItems[ i ];
        //
        if  ( item == &aEntry )
            {
            ret = i;
            break;
            }
        }
    //
    return ret;
    }


EXPORT_C void CMemSpyEngineServerList::OutputDataColumnsL( CMemSpyEngine& aEngine, TBool aClientThreadColumns )
    {
    HBufC* columns = HBufC::NewLC( 1024 );
    TPtr pColumns( columns->Des() );
    //
    _LIT(KCol1, "Thread/Process Id");
    pColumns.Append( KCol1 );
    pColumns.Append( KMemSpyEngineServListOutputComma );
    //
    _LIT(KCol2, "Name");
    pColumns.Append( KCol2 );
    pColumns.Append( KMemSpyEngineServListOutputComma );
    //
    _LIT(KCol3, "Connected Session Count");
    pColumns.Append( KCol3 );
    //
    if  ( aClientThreadColumns )
        {
        _LIT(KCol4, "Connected Client");
        pColumns.Append( KMemSpyEngineServListOutputComma );
        pColumns.Append( KCol4 );
        }
    //
    aEngine.Sink().OutputLineL( pColumns );
    CleanupStack::PopAndDestroy( columns );
    }


void CMemSpyEngineServerList::AddItemL( CMemSpyEngineServerEntry* aItem )
    {
    iItems.AppendL( aItem );
    }


EXPORT_C TInt CMemSpyEngineServerList::MdcaCount() const
    {
    return Count();
    }


EXPORT_C TPtrC CMemSpyEngineServerList::MdcaPoint( TInt aIndex ) const
    {
    const CMemSpyEngineServerEntry& item = At( aIndex );
    return TPtrC( item.Caption() );
    }


TInt CMemSpyEngineServerList::CompareByName( const CMemSpyEngineServerEntry& aLeft, const CMemSpyEngineServerEntry& aRight )
    {
    const TInt ret = aLeft.Name().CompareF( aRight.Name() );
    return ret;
    }


TInt CMemSpyEngineServerList::CompareBySessionCount( const CMemSpyEngineServerEntry& aLeft, const CMemSpyEngineServerEntry& aRight )
    {
    TInt ret = -1;
    //
    if  ( aLeft.SessionCount() < aRight.SessionCount() )
        {
        ret = 1;
        }
    else if ( aLeft.SessionCount() == aRight.SessionCount() )
        {
        ret = 0;
        }
    //
    return ret;
    }



















CMemSpyEngineServerEntry::CMemSpyEngineServerEntry()
    {
    }


EXPORT_C CMemSpyEngineServerEntry::~CMemSpyEngineServerEntry()
    {
    delete iCaption;
    delete iName;
    }


void CMemSpyEngineServerEntry::ConstructL( const TMemSpyDriverHandleInfoGeneric& aInfo )
    {
    iName = HBufC::NewL( aInfo.iName.Length() );
    iName->Des().Copy( aInfo.iName );
    iSessionCount = aInfo.iCount;
    iId = aInfo.iId;
    iHandle = aInfo.iHandle;

    // Make caption
    _LIT(KServerListFormat, "\t%S\t\t%d session");
    TBuf<KMaxFullName + 128> item;
    //
    item.Format( KServerListFormat, iName, iSessionCount );
    //
    if  ( iSessionCount != 1 )
        {
        // Add missing 's' 
        item.Append( TChar('s') );
        }
    //
    iCaption = item.AllocL();
    }


CMemSpyEngineServerEntry* CMemSpyEngineServerEntry::NewLC( const TMemSpyDriverHandleInfoGeneric& aInfo )
    {
    CMemSpyEngineServerEntry* self = new(ELeave) CMemSpyEngineServerEntry();
    CleanupStack::PushL( self );
    self->ConstructL( aInfo );
    return self;
    }


EXPORT_C void CMemSpyEngineServerEntry::OutputDataL( CMemSpyEngineHelperServer& aHelper, TBool aClientThreadColumns ) const
    {
    _LIT(KMemSpyEngineServListOutputDecimal, "%d");
    _LIT(KMemSpyEngineServListOutputString, "%S");
    //
    HBufC* columns = HBufC::NewLC( 1024 );
    TPtr pColumns( columns->Des() );
    //
    pColumns.AppendFormat( KMemSpyEngineServListOutputDecimal, Id() );
    pColumns.Append( KMemSpyEngineServListOutputComma );
    //
    pColumns.AppendFormat( KMemSpyEngineServListOutputString, &Name() );
    pColumns.Append( KMemSpyEngineServListOutputComma );
    //
    pColumns.AppendFormat( KMemSpyEngineServListOutputDecimal, SessionCount() );
    //
    aHelper.Engine().Sink().OutputLineL( pColumns );

    if  ( aClientThreadColumns )
        {
        RArray<TMemSpyDriverServerSessionInfo> sessions;
        CleanupClosePushL( sessions );

        // Get the sessions
        GetSessionsL( aHelper, sessions );

        // Output an additional line per entry
        const TInt count = sessions.Count();
        for( TInt i=0; i<count; i++ )
            {
            const TMemSpyDriverServerSessionInfo& session = sessions[ i ];
            //
            pColumns.Copy( session.iName );
            pColumns.Insert( 0, KMemSpyEngineServListOutputComma );
            pColumns.Insert( 0, KMemSpyEngineServListOutputComma );
            pColumns.Insert( 0, KMemSpyEngineServListOutputComma );
            //
            aHelper.Engine().Sink().OutputLineL( pColumns );
            }
        //
        CleanupStack::PopAndDestroy( &sessions );
        }

    CleanupStack::PopAndDestroy( columns );
    }


EXPORT_C void CMemSpyEngineServerEntry::GetSessionsL( CMemSpyEngineHelperServer& aHelper, RArray<TMemSpyDriverServerSessionInfo>& aSessions ) const
    {
    aHelper.GetServerSessionsL( Handle(), aSessions );
    }