/*

* Copyright (c) 2006-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:

 *

*/

#include "thumbnailfetchedchecker.h"

#include "thumbnaillog.h"

const int KMaxStoredEntries = 100;

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

// CThumbnailFetchedChecker::CThumbnailFetchedChecker()

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

//

CThumbnailFetchedChecker* CThumbnailFetchedChecker::NewL()

    {

    return new (ELeave) CThumbnailFetchedChecker();

    }

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

// CThumbnailFetchedChecker::CThumbnailFetchedChecker()

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

//

CThumbnailFetchedChecker::CThumbnailFetchedChecker()

    {

    }

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

// CThumbnailFetchedChecker::~CThumbnailFetchedChecker()

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

//

CThumbnailFetchedChecker::~CThumbnailFetchedChecker()

    {

    iNotFetched.ResetAndDestroy();

    }

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

// CThumbnailFetchedChecker::LastFetchResult()

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

//

TInt CThumbnailFetchedChecker::LastFetchResult( const TDesC& aUri, const TThumbnailSize aThumbnailSize )

    {

    TN_DEBUG3( "CThumbnailFetchedChecker::LastFetchResult(aUri=%S aThumbnailSize=%d)", &aUri, aThumbnailSize);

    CEntry* entry = NULL;

    TRAPD( err, entry = CEntry::NewL( aUri, aThumbnailSize, KErrNone ) );

    if ( !err && entry )

        {

        TInt ret = iNotFetched.FindInOrder( entry, CEntry::FindCB );

        if ( ret != KErrNotFound )

            {

            TN_DEBUG1( "CThumbnailFetchedChecker::LastFetchResult() -> error found");

            entry = NULL;

            return iNotFetched[ ret ]->iError;

            }

        }

    delete entry;        

    entry = NULL;

    return KErrNone;

    }

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

// CThumbnailFetchedChecker::SetFetchResult()

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

//

void CThumbnailFetchedChecker::SetFetchResult( const TDesC& aUri, const TThumbnailSize aThumbnailSize, TInt aError )

    {

    TN_DEBUG4( "CThumbnailFetchedChecker::SetFetchResult(aUri=%S aThumbnailSize=%d aError=%d)", &aUri, aThumbnailSize, aError);

    if ( aError == KErrNone )

        {

        // Remove successful results from store

        CEntry* entry = NULL;

        TRAPD( err, entry = CEntry::NewL( aUri, aThumbnailSize, aError ) );

        if ( !err && entry )

            {

            TInt i = iNotFetched.FindInOrder( entry, CEntry::FindCB );

            if ( i >= 0 )

                {

                TN_DEBUG2( "CThumbnailFetchedChecker::LastFetchResult() -> Remove successful results from store %d",  iNotFetched.Count() );

                delete iNotFetched[ i ];

                iNotFetched.Remove( i );

                }

            }

        entry = NULL;

        delete entry;

        }

    else

        {

        // Add or update

        CEntry* entry = NULL;

        TRAPD( err, entry = CEntry::NewL( aUri, aThumbnailSize, aError ) );

        if ( !err && entry )

            {

            err = iNotFetched.Find( entry );

            if ( err != KErrNotFound )

                {

                // update existing fetch result

                TInt i = iNotFetched.FindInOrder( entry, CEntry::FindCB );

                if ( i >= 0 )

                    {

                    TN_DEBUG1( "CThumbnailFetchedChecker::LastFetchResult() -> Update fetched tn error" );

                    iNotFetched[ i ]->iError = aError;

                    }

                }

            else 

                {

                if( iNotFetched.Count() < KMaxStoredEntries )

                    {

                    // insert new fetch result

                    TInt err = iNotFetched.InsertInOrder( entry, CEntry::InsertCB );

                    if ( err == KErrNone )

                        {

                        TN_DEBUG2( "CThumbnailFetchedChecker::LastFetchResult() -> Inserted new fetched tn error %d", iNotFetched.Count());	

                        entry = NULL; // owned by array now

                        }

                    }

                }

            delete entry;

            entry = NULL;

            }

        }

    }

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

// CThumbnailFetchedChecker::DeleteFetchResult()

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

//

void CThumbnailFetchedChecker::DeleteFetchResult( const TDesC& aUri )

    {

    TN_DEBUG2( "CThumbnailFetchedChecker::DeleteFetchResult(%S)", &aUri);

    // delete all entries of passed uri

    TInt ret;

    do

        {

        ret = iNotFetched.FindInOrder( aUri, CEntry::FindCBUri );

        if ( ret >= 0 )

            {

            TN_DEBUG1( "CThumbnailFetchedChecker::DeleteFetchResult() -> Deteled URI from fetched list" );	

            delete iNotFetched[ ret ];

            iNotFetched.Remove( ret );

            }

        }

    while(ret != KErrNotFound );

    }

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

// CThumbnailFetchedChecker::LastFetchResult()

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

//

void CThumbnailFetchedChecker::RenameFetchResultL( const TDesC& aNewUri, const TDesC& aOldUri )

    {

    TN_DEBUG3( "CThumbnailFetchedChecker::RenameFetchResult(aNewUri=%S aOldUri=%S)", &aNewUri, &aOldUri);

    // change every occurence of passed uri

    TInt ret;

    do

        {

        ret = iNotFetched.FindInOrder( aOldUri, CEntry::FindCBUri );

        if ( ret >= 0 )

            {

            delete iNotFetched[ ret ]->iUri;

            iNotFetched[ ret ]->iUri = NULL;

            iNotFetched[ ret ]->iUri = aNewUri.AllocL();

            TN_DEBUG1( "CThumbnailFetchedChecker::RenameeFetchResult() -> Renamed URI in fetched list" );	

            }

        }

    while(ret != KErrNotFound );

    }

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

// CThumbnailFetchedChecker::Reset()

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

//

void CThumbnailFetchedChecker::Reset()

    {

    TN_DEBUG1( "CThumbnailFetchedChecker::Reset()");

    iNotFetched.ResetAndDestroy();

    }

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

// CThumbnailFetchedChecker::CEntry::NewL()

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

//

CThumbnailFetchedChecker::CEntry* CThumbnailFetchedChecker::CEntry::NewL(

        const TDesC& aUri, const TThumbnailSize aThumbnailSize, TInt aError )

    {

    TN_DEBUG4( "CThumbnailFetchedChecker::CEntry::NewL(aUri=%S aThumbnailSize=%d aError=%d)", &aUri, aThumbnailSize, aError);

    CEntry* self  = new (ELeave) CEntry();

    if ( self )

        {

        self->iUri = aUri.AllocL();

        self->iSize = aThumbnailSize;

        self->iError = aError;

        if ( !self->iUri )

            {

            delete self;

            self = NULL;

            }

        }

    return self;

    }

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

// CThumbnailFetchedChecker::CEntry::FindCB()

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

//

TInt CThumbnailFetchedChecker::CEntry::FindCB(

        const CThumbnailFetchedChecker::CEntry& aEntry, const CThumbnailFetchedChecker::CEntry& aEntry1 )

    {

    TN_DEBUG1( "CThumbnailFetchedChecker::CEntry::FindCB");

    if( aEntry1.iSize == aEntry.iSize)

        {

        // return index if size and uri matches

        return aEntry.iUri->CompareF( *( aEntry1.iUri ) );

        }

    else 

        {

        return KErrNotFound;

        }

    }

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

// CThumbnailFetchedChecker::CEntry::FindCBUri()

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

//

TInt CThumbnailFetchedChecker::CEntry::FindCBUri(

        const TDesC* aUri, const CThumbnailFetchedChecker::CEntry& aEntry )

    {

    TN_DEBUG2( "CThumbnailFetchedChecker::CEntry::FindCBUri(aUri=%S", &aUri);

    return aUri->CompareF( *( aEntry.iUri ) );

    }

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

// CThumbnailFetchedChecker::CEntry::InsertCB()

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

//

TInt CThumbnailFetchedChecker::CEntry::InsertCB(

        const CThumbnailFetchedChecker::CEntry& aEntry1,

        const CThumbnailFetchedChecker::CEntry& aEntry2 )

    {

    TN_DEBUG1( "CThumbnailFetchedChecker::CEntry::InsertCB");

    if( aEntry1.iSize == aEntry2.iSize)

        {

        // return index if size and uri matches

        return aEntry1.iUri->CompareF( *( aEntry2.iUri ) );

        }

    else 

        {

        return KErrNotFound;

        }

    }

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

// CThumbnailFetchedChecker::CEntry::CEntry()

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

//

CThumbnailFetchedChecker::CEntry::CEntry()

    {

    }

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

// CThumbnailFetchedChecker::CEntry::~CEntry()

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

//

CThumbnailFetchedChecker::CEntry::~CEntry()

    {

    delete iUri;

    }