/*
* 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: This file implements class CIpsPlgMruList.
*
*/



#include "emailtrace.h"
#include "ipsplgheaders.h"

const TUint32 KMruListMailboxMask = 0x0000FFFF;
const TUint32 KMruListMailboxPartKey = 0x0;
const TUint32 KMruListValueMask = 0xFFFF0000;
const TUint32 KMruListIncorrectMBoxKey = 0xFFFFFFFF;
const TUint32 KMruListKeyBaseValue = 0x00010000;
// what are actual size in Freestyle framework?
const TInt KMruListPrefDesSize = 40;
const TInt KMruListMaxDesSize = 200;
const TInt KMruListArrayInitSize = 8;

// <cmail>
const TInt KIpsSmtpOperationCharLessThan = '<';
const TInt KIpsSmtpOperationCharMoreThan = '>';
// </cmail>

// ---------------------------------------------------------------------------
// CIpsPlgMruList::NewL( )
// ---------------------------------------------------------------------------
//
CIpsPlgMruList* CIpsPlgMruList::NewL( )
    {
    FUNC_LOG;
    CIpsPlgMruList* self = new( ELeave ) CIpsPlgMruList( );
    CleanupStack::PushL( self );
    self->ConstructL( );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CIpsPlgMruList::~CIpsPlgMruList()
// ---------------------------------------------------------------------------
//
CIpsPlgMruList::~CIpsPlgMruList()
    {
    FUNC_LOG;
    delete iRepository;
    iHbufArray.ResetAndDestroy();
    iHbufArray.Close();
    iKeys.Reset();
    iKeys.Close();
    }

// ---------------------------------------------------------------------------
// CIpsPlgMruList::CIpsPlgMruList()
// ---------------------------------------------------------------------------
//
CIpsPlgMruList::CIpsPlgMruList( )
    : iRepository( NULL )
    {
    FUNC_LOG;

    }

// ---------------------------------------------------------------------------
// CIpsPlgMruList::ConstructL( )
// ---------------------------------------------------------------------------
//
void CIpsPlgMruList::ConstructL( )
    {
    FUNC_LOG;
    }

// ---------------------------------------------------------------------------
// CIpsPlgMruList::GetMruListL
// ---------------------------------------------------------------------------
//
CDesCArrayFlat* CIpsPlgMruList::GetMruListL( const TFSMailMsgId& aMailbox )
    {
    FUNC_LOG;
    // create iRepository if not yet created
    CreateRepositoryL( iRepository );

    TBool returnEmpty( EFalse );

    // Do not cache anything, there are multiple plugin instances
    iKeys.Reset();
    TUint32 mboxKey;
    if ( KErrNone != GetMailboxKeyFromRepositoryL( aMailbox.Id(), mboxKey, iKeys ) )
        {
        returnEmpty = ETrue;
        }
    iKeys.Reset();

    // get correct mailbox key and fill corresponding name and address keys
    // in keys array
    if ( !returnEmpty )
        {
        if ( KErrNone != iRepository->FindL( mboxKey, KMruListValueMask, iKeys ) )
            {
            returnEmpty = ETrue;
            }
        }

    // if we have found correct key find all keys that
    // maches pattern 0xMKEY**** key array should contain
    // at least 3 items, and size shoud be odd
    // or array is empty or corrupted
    TInt keyCount( iKeys.Count() );
    if ( !returnEmpty && keyCount >= 3 && ( keyCount%2 ) == 1 )
        {
        iHbufArray.ResetAndDestroy();
        iKeys.SortUnsigned();
        TInt i(0);

        // first item in array should be mbox key
        if ( iKeys[0] == mboxKey )
            {
            // index to first name key
            i = 1;
            // store name and address in one loop cycle
            while ( !returnEmpty && i <= ( keyCount-2 ) )
                {
                TUint key = iKeys[i];
                // name is always in odd and address in even key
                if ( (key%2==1) && (iKeys[i+1]==key+1) )
                    {
                    // adding name and email to hbuf array
                    if ( StoreToArrayL(iKeys[i]) != KErrNone )
                        {
                        // something went wrong in name store
                        // just break the loop and return empty
                        HandleRepositoryError( mboxKey, KErrCorrupt );
                        returnEmpty = ETrue;
                        }
                    if ( StoreToArrayL(iKeys[i+1]) != KErrNone )
                        {
                        // store is corrupted
                        HandleRepositoryError( mboxKey, KErrCorrupt );
                        returnEmpty = ETrue;
                        }
                    }
                i = i+2;
                }
            }
        else
            {
            // first item was not mailbox key
            // centrep data is corrupted
            HandleRepositoryError( mboxKey, KErrCorrupt );
            returnEmpty = ETrue;
            }
        }
    else if ( !returnEmpty )
        {
        // mailbox found but there is no data or centrep is corrupted,
        // return empty
        HandleRepositoryError( mboxKey, KErrCorrupt );
        returnEmpty = ETrue;
        }

    // create and return des array
    CDesCArrayFlat* retArr = NULL;

    if ( !returnEmpty )
        {
        retArr = new ( ELeave ) CDesCArrayFlat( KMruListArrayInitSize );
        CleanupStack::PushL( retArr );

        TInt count( iHbufArray.Count() );
        // fill descriptor array
        for ( TInt i(0); i < count; i++ )
            {
            HBufC* app = iHbufArray[i];
            retArr->AppendL(*app);
            }
        CleanupStack::Pop( retArr );
        }
    else
        {
        iHbufArray.ResetAndDestroy();
        retArr = new ( ELeave ) CDesCArrayFlat( KMruListArrayInitSize );
        }

    return retArr;
    }

// ---------------------------------------------------------------------------
// CIpsPlgMruList::SetMruListL
// ---------------------------------------------------------------------------
//
void CIpsPlgMruList::SetMruListL( const TFSMailMsgId& aMailBoxId,
    MDesCArray*  aNewMruList )
    {
    FUNC_LOG;
    // create iRepository if not yet created
    CreateRepositoryL( iRepository );

    TUint32 mboxKey = KMruListIncorrectMBoxKey;
    iKeys.Reset();
    // get mailbox keys to keys array and
    // check if mailboxid is already stored in some key
    TInt error = GetMailboxKeyFromRepositoryL(
        aMailBoxId.Id(), mboxKey, iKeys );

    if ( KErrNone == error )
        {
        // mailbox found
        TUint32 errorKey;
        error = iRepository->Delete( mboxKey, KMruListValueMask, errorKey );
        HandleRepositoryError( mboxKey, error );
        }
    else
        {
        // mailbox not found, create new key
        mboxKey = GetUnusedMboxKey( iKeys );
        }

    // set new values to central repository
    // create mailboxid key
    error = iRepository->Create( mboxKey, TInt( aMailBoxId.Id() ) );
    // handle error
    TInt count( aNewMruList->MdcaCount() );
    // <cmail>
    for ( TInt i(0); error == KErrNone && i < count; i += 2 )
        {
        if( i + 1 < count )
            {
            TPtrC displayName  = aNewMruList->MdcaPoint(i);
            TPtrC emailAddress = aNewMruList->MdcaPoint(i + 1);

            // Need to locate angle brackets from end of the data, if there
            // is display name with special characters
            TInt start( emailAddress.LocateReverse( KIpsSmtpOperationCharLessThan ) ); 
            TInt end( emailAddress.LocateReverse( KIpsSmtpOperationCharMoreThan ) );
            
            if ( KErrNotFound != start && KErrNotFound != end && start < end )
                {
                start += 1;
                emailAddress.Set( aNewMruList->MdcaPoint(i + 1).Mid( start, ( end - start ) ) );
                }

            // check validity of email before saving diplay name and address
            if( IpsSetUtils::IsValidEmailAddressL(emailAddress) )
                {
                // set values to ascending keys
                mboxKey++;

                if ( aNewMruList->MdcaPoint(i).Length() <= KMruListMaxDesSize )
                    {
                    error = iRepository->Create( mboxKey, aNewMruList->MdcaPoint(i) );
                    // handle errors
                    }
                else
                    {
                    TDesC des = aNewMruList->MdcaPoint(i);
                    error = iRepository->Create(
                        mboxKey, des.Mid(0,KMruListMaxDesSize) );
                    }
                
                mboxKey++;

                if( error == KErrNone )
                    {
                    if ( aNewMruList->MdcaPoint(i + 1).Length() <= KMruListMaxDesSize )
                        {
                        error = iRepository->Create( mboxKey, aNewMruList->MdcaPoint(i + 1) );
                        }
                    else
                        {
                        TDesC des = aNewMruList->MdcaPoint(i + 1);
                        error = iRepository->Create(
                            mboxKey, des.Mid(0,KMruListMaxDesSize) );
                        }
                    }
                }
            }
        }
    // </cmail>

    if ( KErrNone != error )
        {
        HandleRepositoryError( mboxKey, error );
        }
    }

// ---------------------------------------------------------------------------
// CIpsPlgMruList::ClearDataL
// ---------------------------------------------------------------------------
//
void CIpsPlgMruList::ClearDataL( const TFSMailMsgId& aMailBoxId )
	{
    FUNC_LOG;
	CreateRepositoryL( iRepository );

    TUint32 mboxKey = KMruListIncorrectMBoxKey;
    iKeys.Reset();
    // get mailbox keys to keys array and
    // check if mailboxid is already sotred in some key
    TInt error = GetMailboxKeyFromRepositoryL(
        aMailBoxId.Id(), mboxKey, iKeys );

    // we have found correct mboxKey
    if ( KErrNone == error )
        {
        TUint32 errorKey;
        error = iRepository->Delete( mboxKey, KMruListValueMask, errorKey );
        HandleRepositoryError( mboxKey, error );
        }
	}

// ---------------------------------------------------------------------------
// CIpsPlgMruList::StoreToArrayL
// ---------------------------------------------------------------------------
//
TInt CIpsPlgMruList::StoreToArrayL( TUint32 aKey )
    {
    FUNC_LOG;
    HBufC* hbuf = HBufC::NewLC( KMruListPrefDesSize );

    TPtr pdes = hbuf->Des();
    TInt actualSize(0);

    TInt error = iRepository->Get( aKey, pdes, actualSize );

    // the case descriptor is larger than pref size
    if ( error == KErrOverflow )
        {
        if ( actualSize > KMruListMaxDesSize )
            {
            // centrep contains too large descriptors
            // impossible if centrep is edited only by this code,
            // set corrupted
            error = KErrCorrupt;
            }
        else
            {
            CleanupStack::PopAndDestroy( hbuf );
            hbuf = HBufC::NewLC( actualSize );
            TPtr pdes2 = hbuf->Des();
            error = iRepository->Get( aKey, pdes2 );
            }
        }

    // add or delete
    if ( KErrNone == error )
        {
        iHbufArray.AppendL( hbuf );
        CleanupStack::Pop( hbuf );
        }
    else
        {
        CleanupStack::PopAndDestroy( hbuf );
        }
    return error;
    }

// ---------------------------------------------------------------------------
// CIpsPlgMruList::GetMailboxKeyFromRepositoryL
// ---------------------------------------------------------------------------
//
TInt CIpsPlgMruList::GetMailboxKeyFromRepositoryL(
    TInt aMboxId,
    TUint32& aMboxKey,
    RArray<TUint32>& aArray )
    {
    FUNC_LOG;
    // keys is found from centrep with partkey 0x0 and mask 0x0000FFFF
    // result is array of keys that maches to pattern 0x****0000
    TInt error = iRepository->FindL(
        KMruListMailboxPartKey, KMruListMailboxMask, aArray );

    // No need to handle other errors than not found,
    // this function should only return KErrNone or KErrNotFound
    TInt tempId;
    error = KErrNotFound;

    //find correct mailbox key from array:
    for ( TInt i = 0; error == KErrNotFound && i < aArray.Count(); i++ )
        {
        if ( iRepository->Get( aArray[i], tempId ) == KErrNone
            && tempId == aMboxId )
            {
            aMboxKey = aArray[i];
            error = KErrNone;
            }
        }

    return error;
    }

// ---------------------------------------------------------------------------
// CIpsPlgMruList::GetUnusedMboxKey
// ---------------------------------------------------------------------------
//
TUint32 CIpsPlgMruList::GetUnusedMboxKey( RArray<TUint32>& aKeys )
    {
    FUNC_LOG;
    // Warning: this function is complex and may contain bugs!!!

    TUint32 newKey = aKeys.Count()*KMruListKeyBaseValue;

    if ( aKeys.Count() > 1 )
        {
        // this loop finds smallest unused key from sorted key array,
        // if array[i] == i*basekey at every i when i == 0...count-1
        // then newKey is not changed
        aKeys.SortUnsigned();
        TUint32 tempKey = newKey;
        for ( TInt i = 0; tempKey == newKey && i < ( aKeys.Count() - 1); i++ )
            {
            if ( aKeys[i] + KMruListKeyBaseValue != aKeys[i+1] )
                {
                tempKey = aKeys[i] + KMruListKeyBaseValue;
                }
            }
        newKey = tempKey;
        }
    else if ( aKeys.Count() == 1 && aKeys[0] == KMruListKeyBaseValue )
        {
        newKey = 0;
        }


    return newKey;
    }

// ---------------------------------------------------------------------------
// CIpsPlgMruList::HandleRepositoryError
// ---------------------------------------------------------------------------
//
void CIpsPlgMruList::HandleRepositoryError( TUint32 aMboxKey, TInt aError )
    {
    FUNC_LOG;
    TBool doClear = EFalse;
    switch ( aError )
        {
            // log these error cases
        case KErrNone:
            // no error
            break;
        case KErrNotFound:
            // no serious error
            break;
        case KErrPermissionDenied:
            // this should be panic because application has no
            // privileges for mru repository
            break;
        case KErrAbort:
            // transaction has previously failed
            // clear mailbox data if it helps...
            doClear = ETrue;
            break;
        case KErrArgument:
            // error in argument, for ex. trying to put integer to descriptor
            // key, solution clear all keys matching aMailbox
            doClear = ETrue;
            break;
        case KErrCorrupt:
            // just clear all keys matching aMailbox
            doClear = ETrue;
            break;
        case KErrAlreadyExists:
            // should handle elsewhere, if ends here clear data
            doClear = ETrue;
            break;
        default:
            // something wrong , clear data
            doClear = ETrue;
            break;
        }

    if ( doClear )
        {
        // don't care about errors...
        TUint32 errorKey;
        TInt error = iRepository->Delete( aMboxKey, KMruListValueMask, errorKey );
        }
    }


// End of file