/*

* 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 "thumbagprocessor.h"

#include "thumbnaillog.h"

#include "thumbnailmanagerconstants.h"

#include "thumbnailmanagerprivatecrkeys.h"

#include "thumbagformatobserver.h"

#include <mpxcollectionutility.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcollectionmessage.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 )

    {

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

    CActiveScheduler::Add( this );

    }

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

// CThumbAGProcessor::ConstructL()

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

//

void CThumbAGProcessor::ConstructL()

    {

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

#ifdef _DEBUG

    iAddCounter = 0;

    iModCounter = 0;

    iDelCounter = 0;

#endif

    iTMSession = CThumbnailManager::NewL( *this );

    iQuery = NULL;

    iQueryActive = EFalse;

    iModify = EFalse;

    iProcessingCount = 0;

    iActiveCount = 0;

    // set auto create values from cenrep

    CheckAutoCreateValuesL();

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

    //do some initializing async in RunL()

    iInit = ETrue;

    iForceRun = EFalse;    

    iActive = EFalse;

    iFormatObserver = CThumbAGFormatObserver::NewL( this );

    iFormatting = EFalse;     

    iSessionDied = EFalse;

    iCollectionUtility = NULL;

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

    }

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

// CThumbAGProcessor::~CThumbAGProcessor()

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

//

CThumbAGProcessor::~CThumbAGProcessor()

    {

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

    if(iPeriodicTimer)

        {

        iPeriodicTimer->Cancel();

        delete iPeriodicTimer;

        }

    if (!iInit)

        {

        iHarvesterClient.RemoveHarvesterEventObserver(*this);

        iHarvesterClient.Close();

        }

    if ( iCollectionUtility )

        {

        iCollectionUtility->Close();

        iCollectionUtility = NULL;

        }

    Cancel();

    if (iQuery)

        {

        iQuery->Cancel();

        delete iQuery;

        iQuery = NULL;

        }

    if (iQueryForPlaceholders)

       {

       iQueryForPlaceholders->Cancel();

       delete iQueryForPlaceholders;

       iQueryForPlaceholders = NULL;

       }

    iAddQueue.Close();

    iModifyQueue.Close();

    iRemoveQueue.Close();

    iQueryQueue.Close();

    iPresentQueue.Close();

    iTempModifyQueue.Close();

    iTempAddQueue.Close();

    iPlaceholderIDs.Close();

    if (iTMSession)

        {

        delete iTMSession;

        iTMSession = NULL;

        }

    delete iFormatObserver;

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

    }

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

// CThumbAGProcessor::HandleQueryNewResults()

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

//

void CThumbAGProcessor::HandleQueryNewResults( CMdEQuery& /*aQuery*/,

                                               const TInt /*aFirstNewItemIndex*/,

                                               const TInt /*aNewItemCount*/ )

    {

    // No implementation required

    }

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

// CThumbAGProcessor::HandleQueryCompleted()

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

//

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

    {

    if( iQueryForPlaceholdersActive && iQueryForPlaceholders)

        {

        TN_DEBUG3( "CThumbAGProcessor::HandleQueryCompletedv2, aError == %d Count== %d", aError, iQueryForPlaceholders->Count());

        // if no errors in query

        if (aError == KErrNone )

            {

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

                {    

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

                if(!object)

                    continue;

                if(!object->Placeholder())

                    {

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

                    continue;

                    }

                if (iPlaceholderIDs.Find( object->Id() ) == KErrNotFound)

                   {

                   TRAP_IGNORE( iPlaceholderIDs.AppendL( object->Id() )); 

                   }

                }

            }

        else

            {

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

            }

        iQueryForPlaceholdersActive = EFalse;

        }

    else if(iQueryActive)

        {

        TN_DEBUG3( "CThumbAGProcessor::HandleQueryCompleted, aError == %d Count== %d", aError, iQuery->Count());

        iQueryReady = ETrue;

        iQueryActive = EFalse;

        // if no errors in query

        if (aError == KErrNone && iQuery)

            {

            iProcessingCount = iQuery->Count();

            }

        else

            {

            iProcessingCount = 0;

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

            }

        }

    else

        {

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

        }

    ActivateAO();

    }

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

// CThumbAGProcessor::ThumbnailPreviewReady()

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

//

void CThumbAGProcessor::ThumbnailPreviewReady( MThumbnailData& /*aThumbnail*/, 

                                               TThumbnailRequestId /*aId*/)

    {

    // No implementation required

    }

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

// CThumbAGProcessor::ThumbnailReady()

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

//

void CThumbAGProcessor::ThumbnailReady( TInt aError, MThumbnailData& /*aThumbnail*/,

                                        TThumbnailRequestId /*aId*/ )

    {

    TN_DEBUG2( "CThumbAGProcessor::ThumbnailReady() aError == %d", aError );

    iActive = EFalse; 

    // TNM server died, delete session

    if( aError == KErrServerTerminated )

        {

        TN_DEBUG1( "CThumbAGProcessor::ThumbnailReady() - **** THUMBNAIL SERVER DIED ****" );

        iSessionDied = ETrue;

        if( !iTimerActive)

            {

            StartTimeout();

			}

        //reset PS idle so that RunL() can startup reopen TNM session and proceed

        TInt ret = RProperty::Set(KServerIdle, KIdle, ETrue);

        TN_DEBUG2( "CThumbAGProcessor::ThumbnailReady() set Idle ret = %d", ret );

        return;

        }

    ActivateAO();

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

    }

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

// CThumbAGProcessor::SetMdESession()

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

//

void CThumbAGProcessor::SetMdESession( CMdESession* aMdESession )

    {

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

    iMdESession = aMdESession;

    TRAPD( err, iDefNamespace = &iMdESession->GetDefaultNamespaceDefL() );

    if (err != KErrNone)

        {

        TN_DEBUG1( "CThumbAGProcessor::SetMdESession - Error: GetDefaultNamespaceDefL leave" );

        }

	ActivateAO();

    }

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

// CThumbAGProcessor::AddToQueue()

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

//

void CThumbAGProcessor::AddToQueueL( TObserverNotificationType aType, 

                                    const RArray<TItemId>& aIDArray, TBool aPresent )

    {

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

    if(aPresent)

        {

        TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - Add to SetPresentQueue" );

        for (int i=0; i<aIDArray.Count(); i++)

             {

             // only add to Present queue if not already in Add or Present queue        

              if (iAddQueue.Find( aIDArray[i] ) == KErrNotFound)

                  {

                  if (iPresentQueue.Find( aIDArray[i] ) == KErrNotFound)

                      {

                      iPresentQueue.AppendL(aIDArray[i]);

                      }

                  }

             }     

        }

    // update queues

    else if (aType == ENotifyAdd)

        {

        TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyAdd" );

        for (int i=0; i<aIDArray.Count(); i++)

            {

            // only add to Add queue if not already in Add queue        

            if (iAddQueue.Find( aIDArray[i] ) == KErrNotFound)

                {

                //if in Present Queue remove from there and and put to add queue

                TInt index = iPresentQueue.Find( aIDArray[i] );

                if( index != KErrNotFound)

                    {

                    iPresentQueue.Remove( index );

                    }

                iAddQueue.AppendL(aIDArray[i]); 

                iTempAddQueue.AppendL(aIDArray[i]);

                }

            }

        }

    else if (aType == ENotifyModify)

        {

        TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyModify" );

        for (int i=0; i<aIDArray.Count(); i++)

             {

             TInt itemIndex = iPlaceholderIDs.Find( aIDArray[i] );

             if(itemIndex >= 0 )

                 {

                 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - harvesting now ended for this placeholder - not Real ENotifyModify" );

                 iPlaceholderIDs.Remove(itemIndex);

                 TN_DEBUG2( "CThumbAGProcessor::AddToQueueL() - placeholders left %d", iPlaceholderIDs.Count() );

                 if (iAddQueue.Find( aIDArray[i] ) == KErrNotFound)

                     {

                     iAddQueue.AppendL(aIDArray[i]);

                     }

                 if (iTempModifyQueue.Find( aIDArray[i] ) == KErrNotFound)

                     {

                     iTempModifyQueue.AppendL( aIDArray[i] );

                     }

                 }

             else if ( iTempAddQueue.Find( aIDArray[i] ) == KErrNotFound)

                 {

                 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - Real ENotifyModify, force run" );

                 iModifyQueue.InsertL( aIDArray[i], 0 );

                 TInt itemIndex = iAddQueue.Find( aIDArray[i] );

                 if(itemIndex >= 0)

                    {

                    iAddQueue.Remove(itemIndex);

                    }

                 itemIndex = iPresentQueue.Find( aIDArray[i] );

                 if(itemIndex >= 0)

                    {

                    iPresentQueue.Remove(itemIndex);

                    }

                 SetForceRun( ETrue );

                 }

             else

                 {

                 if (iTempModifyQueue.Find( aIDArray[i] ) == KErrNotFound)

                     {

                     TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - harvesting now ended for this file - not Real ENotifyModify" );

                     iTempModifyQueue.AppendL( aIDArray[i] );

                     }

                else

                     {

                     TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - harvesting ended allready for this file - Real ENotifyModify, force run" );

                     iModifyQueue.InsertL( aIDArray[i], 0 );

                     TInt itemIndex = iAddQueue.Find( aIDArray[i] );

                     if(itemIndex >= 0)

                        {

                        iAddQueue.Remove(itemIndex);

                        }

                     itemIndex = iPresentQueue.Find( aIDArray[i] );

                     if(itemIndex >= 0)

                        {

                        iPresentQueue.Remove(itemIndex);

                        }

                     SetForceRun( ETrue );

                     }

                 } 

             }        

        }

    else if (aType == ENotifyRemove)

        {

        TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyRemove" );

        for (int i=0; i<aIDArray.Count(); i++)

            {

            // only add to Remove queue if not already in Remove queue        

            if (iRemoveQueue.Find( aIDArray[i] ) == KErrNotFound)

                {

                iRemoveQueue.AppendL(aIDArray[i]);

                }

            // can be removed from Add queue

            TInt itemIndex = iAddQueue.Find( aIDArray[i] );

            if(itemIndex >= 0)

                {

                iAddQueue.Remove(itemIndex);

                }

            // ..and Present Queue

            itemIndex = iPresentQueue.Find( aIDArray[i] );

            if(itemIndex >= 0)

                {

                iPresentQueue.Remove(itemIndex);

                }

            // ..and Modify Queue

            itemIndex = iModifyQueue.Find( aIDArray[i] );

            if(itemIndex >= 0)

                {

                iModifyQueue.Remove(itemIndex);

                }

            }  

        }

    else

        {

        // should not come here

        TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() -  should not come here" );

        return;

        }

    ActivateAO(); 

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

    }

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

// CThumbAGProcessor::CreateThumbnailsL()

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

//

void CThumbAGProcessor::CreateThumbnailsL( const CMdEObject* aObject )

    {

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

    if( iModify )

        {

        TInt orientationVal = 0;

        TInt64 modifiedVal = 0;

        CMdEProperty* orientation = NULL;

        CMdEObjectDef& objDef = iDefNamespace->GetObjectDefL( MdeConstants::Image::KImageObject );       

        TInt orientErr = aObject->Property( objDef.GetPropertyDefL( MdeConstants::Image::KOrientationProperty ), orientation, 0 );

        if (orientErr == KErrNone)

            {

            orientationVal = orientation->Uint16ValueL();

            }

        CMdEProperty* modified = NULL;

        CMdEObjectDef& objDef2 = iDefNamespace->GetObjectDefL( MdeConstants::Object::KBaseObject );       

        TInt modifyErr = aObject->Property( objDef2.GetPropertyDefL( MdeConstants::Object::KLastModifiedDateProperty ), modified, 0 );

        if (modifyErr >= 0)

            {

            modifiedVal = modified->TimeValueL().Int64();

            }

        // modify existing thumbs

        if (iTMSession)

            {

			// run as lower priority than getting but higher that creating thumbnails

            TRAPD(err, iTMSession->UpdateThumbnailsL(aObject->Id(), aObject->Uri(), orientationVal, modifiedVal, CActive::EPriorityIdle ));

            if ( err != KErrNone )

                {

                TN_DEBUG2( "CThumbAGProcessor::UpdateThumbnailsL, iTMSession error == %d", err );

                iSessionDied = ETrue;

                iActive = EFalse;

                ActivateAO();

                } 

            else

                {

                iActive = ETrue;

                }

            }

        else

            {

            ActivateAO();

            }

#ifdef _DEBUG

        iModCounter++;

#endif     

        }

    else

        {

        CThumbnailObjectSource* source = NULL;

        CMdEProperty* mimeType = NULL;

        CMdEObjectDef& objDef = iDefNamespace->GetObjectDefL( MdeConstants::Object::KBaseObject );       

        TInt mime = aObject->Property( objDef.GetPropertyDefL( MdeConstants::Object::KItemTypeProperty ), mimeType, 0 );

        // create new thumbs

        if (mime != KErrNotFound)

            {

            source = CThumbnailObjectSource::NewLC(aObject->Uri(), aObject->Id(), mimeType->TextValueL());

            }