/*

* 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:  Processor 

*

*/

#include <e32base.h>

#include <mdeconstants.h>

#include <centralrepository.h>

#include <mpxcollectionutility.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcollectionmessage.h>

#include <coreapplicationuisdomainpskeys.h> 

#include "thumbagprocessor.h"

#include "thumbnaillog.h"

#include "thumbnailmanagerconstants.h"

#include "thumbnailmanagerprivatecrkeys.h"

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

// CThumbAGProcessor::NewL()

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

//

CThumbAGProcessor* CThumbAGProcessor::NewL()

    {

    TN_DEBUG1( "CThumbAGProcessor::NewL() - begin" );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CThumbAGProcessor::CThumbAGProcessor()

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

//

CThumbAGProcessor::CThumbAGProcessor(): CActive( CActive::EPriorityStandard ), iMMCHarvestingItemsLeftTemp(0), 

        iPHHarvestingItemsLeftTemp(0)

    {

    TN_DEBUG1( "CThumbAGProcessor::CThumbAGProcessor() - begin" );

    CActiveScheduler::Add( this );

    }

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

// CThumbAGProcessor::ConstructL()

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

//

void CThumbAGProcessor::ConstructL()

    {

    TN_DEBUG1( "CThumbAGProcessor::ConstructL() - begin" );

    iShutdown = EFalse;

    iTMSession = CThumbnailManager::NewL( *this );

    iTMSession->SetRequestObserver(*this);

    iQueryAllItems = NULL;

    iQueryPlaceholders = NULL;

    iQuery = NULL;

    iQueryActive = EFalse;

    iModify = EFalse;

    iProcessingCount = 0;

    iActiveCount = 0;

    // set auto create values from cenrep

    CheckAutoCreateValuesL();

    iPeriodicTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    iMountTimer = CPeriodic::NewL(CActive::EPriorityUserInput);

    SetForceRun( EFalse );    

    iFormatObserver = CTMFormatObserver::NewL( *this );

    iFormatting = EFalse;     

    iSessionDied = EFalse;

    iCollectionUtility = NULL;

    iActivityManager = CTMActivityManager::NewL( this, KBackgroundGenerationIdle);

    UpdatePSValues(ETrue, ETrue);

    RProperty::Define(KTAGDPSNotification, KMPXHarvesting, RProperty::EInt);

	//start foreground generation observer

    iForegroundGenerationObserver = CTMRPropertyObserver::NewL( *this, KTAGDPSNotification, KForceBackgroundGeneration, ETrue );  

    TN_DEBUG1( "CThumbAGProcessor::ConstructL() - end" );

    }

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

// CThumbAGProcessor::~CThumbAGProcessor()

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

//

CThumbAGProcessor::~CThumbAGProcessor()

    {

    TN_DEBUG1( "CThumbAGProcessor::~CThumbAGProcessor() - begin" );

    Shutdown();

    Cancel();

    if (iTMSession)

        {

        iTMSession->RemoveRequestObserver();

        delete iTMSession;

        iTMSession = NULL;

        }

    if(iMountTimer)

        {

        iMountTimer->Cancel();

        delete iMountTimer;

        iMountTimer = NULL;

        }

    if(iPeriodicTimer)

        {

        iPeriodicTimer->Cancel();

        delete iPeriodicTimer;

        iPeriodicTimer = NULL;

        }

    if(iActivityManager)

        {

        delete iActivityManager;

        iActivityManager = NULL;

        }

    if (iQuery)

        {

        iQuery->Cancel();

        delete iQuery;

        iQuery = NULL;

        }

    if(iQueryPlaceholders)

        {

        iQueryPlaceholders->Cancel();

        delete iQueryPlaceholders;

        iQueryPlaceholders = NULL;

        }

    if (iQueryAllItems)

       {

       iQueryAllItems->Cancel();

       delete iQueryAllItems;

       iQueryAllItems = NULL;

       }

    if (!iInit)

        {

#ifdef MDS_MODIFY_OBSERVER

        iHarvesterClient.RemoveHarvesterEventObserver(*this);

        iHarvesterClient.Close();

#endif

        }

    if(iForegroundGenerationObserver)

        {

        delete iForegroundGenerationObserver;

        iForegroundGenerationObserver = NULL;

        }

    if(iFormatObserver)

        {

        delete iFormatObserver;

        iFormatObserver = NULL;

        }

    if ( iCollectionUtility )

        {

        iCollectionUtility->Close();

        iCollectionUtility = NULL;

        }

    for(TInt i=0;i<iGenerationQueue.Count();i++)

        {

        delete iGenerationQueue[i].iUri;

        iGenerationQueue[i].iUri = NULL;

        }

    iGenerationQueue.Reset();

    iGenerationQueue.Close();

    iQueryQueue.Close();

    TN_DEBUG1( "CThumbAGProcessor::~CThumbAGProcessor() - end" );

    }

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

// CThumbAGProcessor::Shutdown()

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

//

void CThumbAGProcessor::Shutdown()

    {

    TN_DEBUG1( "CThumbAGProcessor::Shutdown()" );

    iShutdown = ETrue;

    UpdatePSValues(EFalse, EFalse);

    }

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

// CThumbAGProcessor::HandleQueryNewResults()

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

//

void CThumbAGProcessor::HandleQueryNewResults( CMdEQuery& aQuery,

                                               const TInt aFirstNewItemIndex,

                                               const TInt aNewItemCount )

    {

    // PH & AllItems query results are handled here

    if(iShutdown)

        {

        return;

        }

    if (aNewItemCount > 0)

        {

        if(&aQuery == iQueryPlaceholders)

            {

            TN_DEBUG2( "CThumbAGProcessor::HandleQueryNewResults - iQueryPlaceholders, %d new", aNewItemCount);

            for(TInt i = aFirstNewItemIndex; i < iQueryPlaceholders->Count(); i++)

                {    

                const CMdEObject* object = &iQueryPlaceholders->Result(i);

                if(!object)

                    {

                    continue;

                    }

                if(!object->Placeholder())

                    {

                    TN_DEBUG2( "CThumbAGProcessor::HandleQueryNewResults %d not placeholder", object->Id());

                    continue;

                    }

                // ignore if fails

                TThumbnailGenerationItem item;

                item.iItemId = object->Id();

                item.iPlaceholder = ETrue;

                SetGenerationItemType( item, object->Def().Id());

                AppendProcessingQueue( item );

                }  

            }

        else if(&aQuery == iQueryAllItems)

            {

            TN_DEBUG2( "CThumbAGProcessor::HandleQueryNewResults - QueryAllItems, %d new", aNewItemCount);

            for(TInt i = aFirstNewItemIndex; i < iQueryAllItems->Count(); i++)

                {    

                const CMdEObject* object = &iQueryAllItems->Result(i);

                if(!object)

                    {

                    continue;

                    }

                TThumbnailGenerationItem item;

                item.iItemId = object->Id();

                SetGenerationItemType(item, object->Def().Id());

                TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare);

                item.iPlaceholder = object->Placeholder(); 

                AppendProcessingQueue( item );

                }

            }    

        }

    else

        {

        TN_DEBUG1( "CThumbAGProcessor::HandleQueryNewResults - error, no new items");

        }

    }

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

// CThumbAGProcessor::HandleQueryCompleted()

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

//

void CThumbAGProcessor::HandleQueryCompleted( CMdEQuery& aQuery, const TInt aError )

    {

    TN_DEBUG3( "CThumbAGProcessor::HandleQueryCompleted, aError == %d Count== %d", aError, aQuery.Count());

    if(iShutdown)

        {

        return;

        }

    if(&aQuery == iQueryPlaceholders)

        {

        TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - iQueryPlaceholders completed");

        //free query

        delete iQueryPlaceholders;

        iQueryPlaceholders = NULL;

        if(iDoQueryAllItems)

            {

            iDoQueryAllItems = EFalse;

            TRAP_IGNORE(QueryAllItemsL());

            }

        }

    else if(&aQuery == iQueryAllItems)

        {

        TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - QueryAllItems completed");

#ifdef _DEBUG

TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted IN-COUNTERS---------- Amount: %d, Add",iQueryAllItems->Count());

#endif

        //free query

        delete iQueryAllItems;

        iQueryAllItems = NULL;

        }

    else if(&aQuery == iQuery ) 

        {

        TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - Query completed");

        if(iQueryActive)

            {

            iQueryReady = ETrue;

            iQueryActive = EFalse;

            }

        // if no errors in query

        if (aError == KErrNone && iQuery)

            {

            iProcessingCount = iQuery->Count();

            if(iProcessingCount != iQueryQueue.Count() )

                {

                TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted() some result items missing");

                RArray<TItemId> queryQueueDelta;

                    //search delta items which were queried, but not found

                     for(TInt queryItem =0; queryItem < iQueryQueue.Count();queryItem++)

                         {

                         TBool found(EFalse);

                         for(TInt queryResult = 0; queryResult < iQuery->Count(); queryResult++)

                            {    

                            const CMdEObject* object = &iQuery->Result(queryResult);

                            if( iQueryQueue[queryItem] == object->Id())

                                {

                                found = ETrue;

                                break;

                                }

                            }

                         if(!found)

                             {

                             TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() %d missing from query results", iQueryQueue[queryItem] );

                             // ignore if fails

                             queryQueueDelta.InsertInOrder(iQueryQueue[queryItem], CompareId);

                             }

                         }

                     TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() missing items found %d", queryQueueDelta.Count()); 

                     //cleanup from previous queue it item is not found from MDS

                     while(queryQueueDelta.Count())

                         {

                         TThumbnailGenerationItem item;

                         item.iItemId = queryQueueDelta[0];

                         TInt itemIndex = iQueryQueue.FindInOrder(item.iItemId, CompareId);

                         if(itemIndex >= 0)

                             {

                             TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove %d from iQueryQueue", queryQueueDelta[0]);

                             iQueryQueue.Remove( itemIndex );

                             //remove from procesing queue

                             itemIndex = iGenerationQueue.FindInOrder(item, Compare);

                             if(itemIndex >= 0)

                                 {

                                 if( iUnknown )

                                     {

                                     TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() mark %d as EGenerationItemTypeNotFound in iGenerationQueue", queryQueueDelta[0]);

                                     //mark to be removed, cleanup is done below

                                     iGenerationQueue[itemIndex].iItemType = EGenerationItemTypeNotFound;

                                     }

                                 else

                                     {

                                     TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove %d from iGenerationQueue", queryQueueDelta[0]);

                                     iGenerationQueue.Remove( itemIndex );

                                     }

                                 }

                             }

                         queryQueueDelta.Remove(0);

                         }

                     queryQueueDelta.Close();

                    }

                if(iUnknown)

                    {

                    for(TInt i = 0; i < iQuery->Count(); i++)

                      {    

                      const CMdEObject* object = &iQuery->Result(i);

                      if(!object)

                          {

                          continue;

                          }

                          TThumbnailGenerationItem tempItem;

                          tempItem.iItemId = object->Id();

                          TInt itemIndex = iGenerationQueue.FindInOrder(tempItem, Compare);

                        if(itemIndex >= 0)

                            {

                            TThumbnailGenerationItem& item = iGenerationQueue[itemIndex]; 

                            if(iGenerationQueue[itemIndex].iItemType == EGenerationItemTypeNotFound)

                                {

                                TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove EGenerationItemTypeNotFound %d item from iGenerationQueue", item.iItemId);

                                iGenerationQueue.Remove(itemIndex);

                                continue;

                                }

                                SetGenerationItemType(item, object->Def().Id());

                                if(item.iItemType == EGenerationItemTypeUnknown )

                                  {

                                  TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove unknown item %d", item.iItemId);

                                  iGenerationQueue.Remove(itemIndex);

                                  continue;

                                  }

                              item.iPlaceholder = object->Placeholder(); 

                            }

                        }

                        iQueryQueue.Reset();

                        iProcessingCount = 0;

                        iUnknown = EFalse;

                    }

            // no results, reset query

            if( !iProcessingCount )

                {

                delete iQuery;

                iQuery = NULL;

                iModify = EFalse;

                }

            }

        else

            {

            //Delete and cancel query, do not return items back to original queue

            DeleteAndCancelQuery( EFalse );

            TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted() Query FAILED!"); 

            }

        }

    else

        {

        TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted() - NO QUERY ACTIVE"); 

        __ASSERT_DEBUG((EFalse), User::Panic(_L("CThumbAGProcessor::HandleQueryCompleted()"), -1));

        }

    ActivateAO();

    }