/*

* Copyright (c) 2007 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:  Used to collect various presence related information for the

*                extension.

*

*/

// INCLUDE FILES

#include "clogspresencetablemanager.h"

#include "clogspresenceindextableentry.h"

#include "clogspresencestatustableentry.h"

#include "clogsextlogidpresidmapping.h"

#include "MLogsEventGetter.h"

#include "logsextconsts.h"

#include "MLogsModel.h"

#include "simpledebug.h"

// ---------------------------------------------------------------------------

// NewL

// ---------------------------------------------------------------------------

//

CLogsPresenceTableManager* CLogsPresenceTableManager::NewL()

    {

    CLogsPresenceTableManager* self = CLogsPresenceTableManager::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// NewLC

// ---------------------------------------------------------------------------

//    

CLogsPresenceTableManager* CLogsPresenceTableManager::NewLC()

    {

    CLogsPresenceTableManager* self = new( ELeave ) CLogsPresenceTableManager;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//    

CLogsPresenceTableManager::~CLogsPresenceTableManager()

    {

    _LOG("CLogsPresenceTableManager::~CLogsPresenceTableManager: begin")

    iPresenceStatusTable.ResetAndDestroy();

    iPresenceIndexTable.ResetAndDestroy();

    iLogIdPresIdMappingArray.ResetAndDestroy();

    _LOG("CLogsPresenceTableManager::~CLogsPresenceTableManager: end")

    }

// ---------------------------------------------------------------------------

// ConstructL

// ---------------------------------------------------------------------------

//    

void CLogsPresenceTableManager::ConstructL()

    {

    _LOG("CLogsPresenceTableManager::ConstructL(): begin")    

    _LOG("CLogsPresenceTableManager::ConstructL(): end")

    }

// ---------------------------------------------------------------------------

// Constructor

// ---------------------------------------------------------------------------

//

CLogsPresenceTableManager::CLogsPresenceTableManager():

    iPresenceStatusTable( KPresenceTableManagerGranularity ),

    iPresenceIndexTable( KPresenceTableManagerGranularity ),

    iLogIdPresIdMappingArray( KLogIdPresIdMappingArrayGranularity )

    {    

    _LOG("CLogsPresenceTableManager::CLogsPresenceTableManager(): begin")

    _LOG("CLogsPresenceTableManager::CLogsPresenceTableManager(): end")

    }    

// ---------------------------------------------------------------------------

//  Gets the index of a certain icon in the listbox's icon array.

// ---------------------------------------------------------------------------

//

TInt CLogsPresenceTableManager::GetIndex( 

    const TUint32 aServiceId, 

    const TDesC& aPresentityId, 

    TInt& aIndex )

    {    

    _LOG("CLogsPresenceTableManager::GetIndex: begin")

    TInt error( KErrNotFound );    

    TDesC* status = GetStatusFromStatusTable( aServiceId, aPresentityId );

    if ( status )

        {        

        TInt index( KErrNotFound );

        error = GetIndexFromIndexTable( aServiceId, *status, index );

        if ( KErrNone == error )

            {            

            if ( index >= 0 )

                {

                aIndex = index;

                error = KErrNone;

                }            

            else 

                {

                error = KErrNotFound;

                }            

            }

        else if ( KErrNotFound == error )

            {

            error = KErrNotReady;

            }

        }

    _LOGP("CLogsPresenceTableManager::GetIndex: end (error==%d)",error)    

    return error;

    }

// ---------------------------------------------------------------------------

// Gets the index of a certain icon in the listbox's icon array from the

// index table. 

// ---------------------------------------------------------------------------

//

TInt CLogsPresenceTableManager::GetIndexFromIndexTable( 

    const TUint32 aServiceId, 

    const TDesC& aPresenceStatusString, 

    TInt& aIndex )

    {

    _LOG("CLogsPresenceTableManager::GetIndexFromIndexTable: begin")    

    TInt error( KErrNotFound );

    for ( TInt i( 0 ); i < IndexTableEntriesCount(); i++ )

        {

        CLogsPresenceIndexTableEntry* entry = iPresenceIndexTable[i];

        if ( entry 

            && entry->ServiceId() == aServiceId 

            && entry->PresenceStatusString() == aPresenceStatusString )

            {

            aIndex = entry->PresenceIconIndex();

            error = KErrNone;

            }        

        }    

    _LOGP("CLogsPresenceTableManager::GetIndexFromIndexTable: end (error=%d)",

        error)        

    return error;       

    }

// ---------------------------------------------------------------------------

// Gets the status of a status entry from the status table. 

// ---------------------------------------------------------------------------

//

TDesC* CLogsPresenceTableManager::GetStatusFromStatusTable( 

    const TUint32 aServiceId, 

    const TDesC& aPresentityId )

    {

    _LOG("CLogsPresenceTableManager::GetStatusFromStatusTable: begin")        

    TDesC* presenceStatus = NULL;

    _LOGP("CLogsPresenceTableManager::GetStatusFromStatusTable: count=%d",

        StatusTableEntriesCount())

    TBool found( EFalse );

    for ( TInt i( 0 ); !found && i < StatusTableEntriesCount(); i++ )

        {

        CLogsPresenceStatusTableEntry* entry = iPresenceStatusTable[i];

        _LOGP("CLogsPresenceTableManager::GetStatusFromStatusTable: i=%d",i)        

        if ( entry

            && entry->ServiceId() == aServiceId 

            && entry->PresentityId() == aPresentityId

            && entry->DisplayPresence() 

            && entry->PresenceStatusString() )

            {

            _LOG("CLogsPresenceTableManager::GetStatusFromStatusTable:...")

            _LOGPP("...INSIDE IF i=%d presenceString=%S",

                i , entry->PresenceStatusString() )                   

            presenceStatus = entry->PresenceStatusString();

            found = ETrue;            

            }                    

        }

    return presenceStatus;

    }

// ---------------------------------------------------------------------------

// Creates a new CLogsStatusTableEntry object and adds it to the manager's

// status table (which is iPresenceStatusTable). Before adding an entry to

// the table it is checked whether the entry already exists in the table 

// to avoid duplicates. Entries with the same service id and presentity id

// are considered to be duplicates.

// Note: Since the presence status might not being known when adding the

//       entry it is possible to leave it unspecified.

// ---------------------------------------------------------------------------

//

TInt CLogsPresenceTableManager::AddEntryToStatusTable( 

    const TUint32 aServiceId, 

    const TDesC& aPresentityId,

    TBool aShowStatus )

    {

    _LOG("CLogsPresenceTableManager::AddEntryToStatusTable: begin")        

    TInt error( KErrNotFound );

    // if entry does not exist -> create it.

    if ( !StatusEntryExists( aServiceId, aPresentityId ) )

        {

        CLogsPresenceStatusTableEntry* entry = NULL;

        TRAP( error, entry = 

                        CLogsPresenceStatusTableEntry::NewL(

                                                           aServiceId,

                                                           aPresentityId,

                                                           aShowStatus ); );

        if ( KErrNone == error )

            {

            error = iPresenceStatusTable.Append( entry );

            if ( KErrNone != error )

                {

                delete entry;

                entry = NULL;

                error = KErrNoMemory;

                }            

            }        

        }

    // if entry already exists -> dont create it again.

    else 

        {

        //entry exists already

        error = KErrAlreadyExists;

        }

    _LOGP("CLogsPresenceTableManager::AddEntryToStatusTable: end (error=%d)",

        error )                

    return error;

    } 

// ---------------------------------------------------------------------------

// Creates a new CLogsIndexTableEntry object and adds it to the manager's

// index table (which is iPresenceIndexTable). Before adding an entry to

// the table it is checked whether the entry already exists in the table 

// to avoid duplicates. Entries with the same service id and presence

// status are considered to be duplicates.

// Note: Since the index might not being known when adding the

//       entry it is possible to leave it unspecified.

// ---------------------------------------------------------------------------

//

TInt CLogsPresenceTableManager::AddEntryToIndexTable( 

    const TUint32 aServiceId, 

    const TDesC& aPresenceStatusString )

    {

    _LOGP("CLogsPresenceTableManager::AddEntryToIndexTable: aServiceId=%d", 

            aServiceId )

    TInt error( KErrNotFound );

    // if entry does not exist -> create it.

    TBool entryexists( ETrue );

    entryexists = IndexEntryExists( aServiceId, aPresenceStatusString );

    if ( !entryexists )

        {        

        CLogsPresenceIndexTableEntry* entry = NULL;

        TRAP( error, 

              entry = CLogsPresenceIndexTableEntry::NewL( aServiceId, 

                                                    aPresenceStatusString ) );

        if ( KErrNone == error )

            {

            error = iPresenceIndexTable.Append( entry );

            if ( KErrNone != error )

                {

                delete entry;

                entry = NULL;

                error = KErrNoMemory;

                }            

            }        

        }

    // if entry already exists -> dont create it again.

    else 

        {

        //entry exists already

        error = KErrAlreadyExists;

        }

    _LOGP("CLogsPresenceTableManager::AddEntryToIndexTable: end (error==%d)",

            error)                    

    return error;

    }

// ---------------------------------------------------------------------------

// Check whether the presence icon index is available or not.

// ---------------------------------------------------------------------------

//

TBool CLogsPresenceTableManager::PresenceIconIndexAvailable( 

    const TUint32 aServiceId,

    const TDesC& aPresentityId )

    {

    _LOG("CLogsPresenceTableManager::PresenceIconIndexAvailable: begin")        

    TBool IsIndexAvailable( EFalse );

    TInt index( KErrNotFound );

    TInt error ( GetIndex( aServiceId, aPresentityId, index ) );    

    switch( error )

        {

        case KErrNone:

            {

            if ( index >= 0 )

                {

                IsIndexAvailable = ETrue;

                }            

            break;

            }

        case KErrNotReady:

        case KErrNotFound:

        default:

            {

            IsIndexAvailable = EFalse;

            }        

        }

    if ( IsIndexAvailable )

        {

        _LOG("CLogsPresenceTableManager::PresenceIconIndexAvailable: end...")

        _LOG("... PresenceIndex => available")

        }

    else

        {

        _LOG("CLogsPresenceTableManager::PresenceIconIndexAvailable: end...")

        _LOG("... PresenceIndex => NOT available")

        }

    return IsIndexAvailable;

    }

// ---------------------------------------------------------------------------

// Sets the status of a certain status entry of the status table.

// ---------------------------------------------------------------------------

//   

TInt CLogsPresenceTableManager::SetStatusInStatusTable( 

    const TUint32 aServiceId,

    const TDesC& aPresentityId,

    const TDesC& aPresenceStatusString,

    TBool aShowStatus )

    {

    _LOG("CLogsPresenceTableManager::SetStatusInStatusTable: begin")        

    TInt error( KErrGeneral );

    TBool found( EFalse );

    for ( TInt i( 0 ); !found && i < StatusTableEntriesCount(); i++ )

        {

        CLogsPresenceStatusTableEntry* entry = iPresenceStatusTable[i];

        if ( entry 

            && entry->ServiceId() == aServiceId 

            && entry->PresentityId() == aPresentityId )

            {

            found = ETrue;

            entry->SetDisplayPresence( aShowStatus );

            error = entry->SetPresenceStatusString( aPresenceStatusString );

            }        

        }

    _LOGP("CLogsPresenceTableManager::SetStatusInStatusTable: end (error=%d)",

            error)                 

    return error;

    }

// ---------------------------------------------------------------------------

// Sets the status of a certain status entry of the status table to the 

// initial value. Presense status is not displayed.

// ---------------------------------------------------------------------------

//   

TInt CLogsPresenceTableManager::UpdateStatusTableEntry( 

    const TUint32 aServiceId,

    const TDesC& aPresentityId,

    TBool aShowStatus )

    {

    _LOG("CLogsPresenceTableManager::ResetStatusTableEntry: begin")        

    TInt error( KErrNotFound );

    TBool found( EFalse );

    for ( TInt i( 0 ); !found && i < StatusTableEntriesCount(); i++ )

        {

        CLogsPresenceStatusTableEntry* entry = iPresenceStatusTable[i];

        if ( entry 

            && entry->ServiceId() == aServiceId 

            && entry->PresentityId() == aPresentityId )

            {            

            entry->SetDisplayPresence( aShowStatus );

            found = ETrue;

            error = KErrNone;

            }        

        }

    _LOGP("CLogsPresenceTableManager::ResetStatusTableEntry: end (error==%d)",

            error)                 

    return error;

    }

// ---------------------------------------------------------------------------

// Sets the status of all status entries of the status table to the initial 

// value.

// ---------------------------------------------------------------------------

//   

void CLogsPresenceTableManager::ResetStatusTableEntries()

    {

    _LOG("CLogsPresenceTableManager::ResetStatusTableEntries: begin")        

    for ( TInt i( 0 ); i < StatusTableEntriesCount(); i++ )

        {

        CLogsPresenceStatusTableEntry* entry = iPresenceStatusTable[i];

        if ( entry )

            {            

            entry->ResetPresenceStatusString();

            entry->SetDisplayPresence( EFalse );

            }        

        }

    _LOG("CLogsPresenceTableManager::ResetStatusTableEntries: end")                 

    }

// ---------------------------------------------------------------------------

// Sets the presence icon index values to initial values.

// ---------------------------------------------------------------------------

//  

void CLogsPresenceTableManager::ResetState()

    {

    _LOG("CLogsPresenceTableManager::ResetIndexTableEntries: begin")  

    iPresenceIndexTable.ResetAndDestroy();

    iPresenceStatusTable.ResetAndDestroy();

    iLogIdPresIdMappingArray.ResetAndDestroy();

    _LOG("CLogsPresenceTableManager::ResetIndexTableEntries: end")  

    }

// ---------------------------------------------------------------------------

// Sets the index of a certain index entry of the index table.

// ---------------------------------------------------------------------------

//     

TInt CLogsPresenceTableManager::SetIndexInIndexTable( 

    const TUint32 aServiceId,

    const TDesC& aPresenceStatusString,

    const TInt aIndex )

    {

    _LOG("CLogsPresenceTableManager::SetIndexInIndexTable: begin")        

    TInt error( KErrGeneral );

    TBool found( EFalse );

    for ( TInt i( 0 ); !found && i < IndexTableEntriesCount() ; i++ )

        {

        CLogsPresenceIndexTableEntry* entry = iPresenceIndexTable[i];

        if ( entry 

            && entry->ServiceId() == aServiceId 

            && entry->PresenceStatusString() == aPresenceStatusString )

            {

            found = ETrue;            

            error = entry->SetPresenceIconIndex( aIndex );            

            }        

        }

    _LOGP("CLogsPresenceTableManager::SetIndexInIndexTable: end (error==%d)",

            error)

    return error; 

    }

// ---------------------------------------------------------------------------

// Checks the existance of a status entry with the specified arguments.

// ---------------------------------------------------------------------------

//

TBool CLogsPresenceTableManager::StatusEntryExists( 

        const TUint32 aServiceId,

        const TDesC& aPresentityId )

    {

    _LOG("CLogsPresenceTableManager::StatusEntryExists: begin")        

    TBool exists( EFalse );

    for ( TInt i( 0 ); !exists && i < StatusTableEntriesCount(); i++ )

        {

        CLogsPresenceStatusTableEntry* entry = iPresenceStatusTable[i];

        if ( entry 

            && entry->ServiceId() == aServiceId 

            && entry->PresentityId() == aPresentityId )

            {

            _LOG("CLogsPresenceTableManager::StatusEntryExists: entry exists")

            exists = ETrue;            

            }

        }

    _LOG("CLogsPresenceTableManager::StatusEntryExists: end")

    return exists;     

    }

// ---------------------------------------------------------------------------

// Checks the existance of a index entry with the specified arguments.

// ---------------------------------------------------------------------------

//

TBool CLogsPresenceTableManager::IndexEntryExists( 

        const TUint32 aServiceId,

        const TDesC& aPresenceStatus )