/*
* Copyright (c) 2008 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:  Dublicate detector for images and videos
*
*/

#include <mdelogiccondition.h>
#include <mdesession.h>
#include <mdccommon.h>
#include <mdeconstants.h>

#include "cmfilllistitem.h"
#include "cmfmitemhandlerobserver.h"
#include "cmfmmdeduplicatedetector.h"
#include "cmfmmpxduplicatedetector.h"
#include "cmfmmain.h"
#include "msdebug.h"    

    

// ---------------------------------------------------------------------------
// CCmFmMdEDuplicateDetector::NewL
// ---------------------------------------------------------------------------
// 
CCmFmMdEDuplicateDetector* CCmFmMdEDuplicateDetector::NewL( 
    MCmFmItemHandlerObserver& aObserver, CMdESession& aSession )
    {
    LOG(_L("[FILL MNGR]\t CCmFmMdEDuplicateDetector::NewL() start"));    
    CCmFmMdEDuplicateDetector* self = 
        CCmFmMdEDuplicateDetector::NewLC( aObserver, aSession );
    CleanupStack::Pop( self );
    LOG(_L("[FILL MNGR]\t CCmFmMdEDuplicateDetector::NewL() end"));
    return self;
    }

// ---------------------------------------------------------------------------
// CCmFmMdEDuplicateDetector::NewLC
// ---------------------------------------------------------------------------
//    
CCmFmMdEDuplicateDetector* CCmFmMdEDuplicateDetector::NewLC( 
    MCmFmItemHandlerObserver& aObserver, CMdESession& aSession )
    {
    LOG(_L("[FILL MNGR]\t CCmFmMdEDuplicateDetector::NewLC() start"));    
    CCmFmMdEDuplicateDetector* self = 
        new ( ELeave ) CCmFmMdEDuplicateDetector( aObserver, aSession );
    CleanupStack::PushL( self );
    self->ConstructL();
    LOG(_L("[FILL MNGR]\t CCmFmMdEDuplicateDetector::NewLC() end"));
    return self;  
    }    

// ---------------------------------------------------------------------------
// CCmFmMdEDuplicateDetector::~CCmFmMdEDuplicateDetector
// ---------------------------------------------------------------------------
// 
CCmFmMdEDuplicateDetector::~CCmFmMdEDuplicateDetector()
    {
    LOG(_L("[FILL MNGR]\t ~CCmFmMdEDuplicateDetector()"));
    delete iTitle;
    delete iDate;
    delete iSize;
    
    delete iQuery;
    delete iMediaTypeDef;
    delete iObjectDef;
    delete iNamespace;
    delete iCheckItem;
    iExistFiles.ResetAndDestroy();
    }

// ---------------------------------------------------------------------------
// CCmFmMdEDuplicateDetector::CCmFmMdEDuplicateDetector
// ---------------------------------------------------------------------------
// 
CCmFmMdEDuplicateDetector::CCmFmMdEDuplicateDetector( 
    MCmFmItemHandlerObserver& aObserver, CMdESession& aSession )
    : iObserver( aObserver ), iSession( aSession )
    {
    LOG(_L("[FILL MNGR]\t CCmFmMdEDuplicateDetector::\
    CCmFmMdEDuplicateDetector"));
    }

// ---------------------------------------------------------------------------
// CCmFmMdEDuplicateDetector::ConstructL
// ---------------------------------------------------------------------------
//     
void CCmFmMdEDuplicateDetector::ConstructL()
    {
    LOG(_L("[FILL MNGR]\t CCmFmMdEDuplicateDetector::ConstructL"));
    }
    
// ---------------------------------------------------------------------------
// CCmFmMdEDuplicateDetector::CheckImageOrVideoL
// ---------------------------------------------------------------------------
//
void CCmFmMdEDuplicateDetector::CheckImageOrVideoL( 
    const CCmFillListItem& aItem )
    {
    LOG(_L("[FILL MNGR]\t CCmFmMdEDuplicateDetector::CheckImageOrVideoL"));
    TCmMediaType theType = aItem.MediaType();
    if( iExistFiles.Count() > 0 && iCurrentMediaType == theType )
        {
        CheckImageOrVideoLIfDuplicated( aItem );
        }
    else
        {
        delete iCheckItem;
        iCheckItem = NULL;
        iCheckItem = CCmFillListItem::NewL();
        iCheckItem->SetPrimaryTextL( aItem.PrimaryText() );
        iCheckItem->SetSize( aItem.Size() );
        iCheckItem->SetDate( aItem.Date() );
        delete iQuery;
        iQuery = NULL;
        
        if( !iNamespace )
            {
            iNamespace = &iSession.GetDefaultNamespaceDefL();
            }
        if( iNamespace )
            {
            iObjectDef = 
               &iNamespace->GetObjectDefL( MdeConstants::Object::KBaseObject );
            }
        
        iCurrentMediaType = theType;
        if( ECmImage == theType || ECmOtherImage == theType )
            {
            TRACE(Print(_L("ECmImage == aType")));
            iMediaTypeDef = 
               &iNamespace->GetObjectDefL( MdeConstants::Image::KImageObject );
            }
        else if( ECmVideo == theType || ECmOtherVideo == theType )
            {
            TRACE(Print(_L("ECmVideo == aType")));
            iMediaTypeDef = 
               &iNamespace->GetObjectDefL( MdeConstants::Video::KVideoObject );
            }
        else
            {
            User::Leave( KErrArgument );
            }        
        if( !iObjectDef || !iMediaTypeDef )
            {
            User::Leave( KErrArgument );
            }
    
        iQuery = iSession.NewObjectQueryL( 
                *iNamespace, *iMediaTypeDef, this );
        if( !iQuery )
            {
            User::Leave( KErrArgument );
            }
        SetLogicConditionL( aItem );    
        //iQuery->SetResultMode( EQueryResultModeId );
        iQuery->SetResultMode( EQueryResultModeItem );
        /** Start query, no need to query more than one item */ 
        iQuery->FindL();
        }
    }
        
// ---------------------------------------------------------------------------
// CCmFmMdEDuplicateDetector::HandleQueryNewResults
// ---------------------------------------------------------------------------
// 
void CCmFmMdEDuplicateDetector::HandleQueryNewResults(CMdEQuery& aQuery,
                                       TInt aFirstNewItemIndex,
                                       TInt aNewItemCount)
    {
    TRACE(Print(_L("[FILL MNGR]\t CCmFmMdEDuplicateDetector::\
    HandleQueryNewResultsaNewItemCount %d"), aNewItemCount ));
    CMdEObjectQuery& query = (CMdEObjectQuery &) aQuery;
    iExistFiles.Reset();
    TRACE(Print(_L("[FILL MNGR]\t aNewItemCount %d"), aNewItemCount ));
    if( &query ) 
        {
        for ( TInt i = aFirstNewItemIndex; 
              i < aFirstNewItemIndex+aNewItemCount; 
              i++ )
            {
            CCmFillListItem *itm = CCmFillListItem::NewLC();
            CMdEObject* object = (CMdEObject*)query.TakeOwnershipOfResult(i);
            CMdEProperty* prop;
            TInt propIndex = object->Property( *iTitle, prop );
            if( propIndex != KErrNotFound )
                {
                CMdETextProperty* textprop = (CMdETextProperty*) prop;
                itm->SetPrimaryTextL( textprop->Value() );
                }
            else
                {
                TParsePtrC parser( object->Uri());
                itm->SetPrimaryTextL( parser.Name() );
                }
            
            propIndex = object->Property( *iSize, prop );
            if( propIndex != KErrNotFound )
                {
                itm->SetSize( prop->Uint32ValueL() );
                }
            iExistFiles.AppendL( itm );
            TRACE(Print(_L("[FILL MNGR]\t HandleQueryNewResults [%S][%d]"),
                            &itm->PrimaryText(), itm->Size() ));
            CleanupStack::Pop( itm );
            }
        
        // sort by size
        TLinearOrder<CCmFillListItem> key( CCmFmMain::CompareBySize );
        iExistFiles.Sort( key );
        }
    }
          
// ---------------------------------------------------------------------------
// CCmFmMdEDuplicateDetector::HandleQueryCompleted
// ---------------------------------------------------------------------------
// 
#ifdef _DEBUG
void CCmFmMdEDuplicateDetector::HandleQueryCompleted( CMdEQuery& /*aQuery*/, 
                                        TInt aError )
#else
void CCmFmMdEDuplicateDetector::HandleQueryCompleted( CMdEQuery& /*aQuery*/, 
                                        TInt /*aError*/ )
#endif                                        
    {
    TRACE(Print(_L("[FILL MNGR]\t HandleQueryCompleted error = %d"), 
        aError ));
    if( iCheckItem )
        {
        CheckImageOrVideoLIfDuplicated( *iCheckItem );
        }
    }          

// ---------------------------------------------------------------------------
// CCmFmMdEDuplicateDetector::SetLogicConditionL
// ---------------------------------------------------------------------------
// 
void CCmFmMdEDuplicateDetector::SetLogicConditionL( 
    const CCmFillListItem& /*aItem*/ )
    {
    LOG(_L("[FILL MNGR]\t SetLogicConditionL"));
    CMdELogicCondition& rootCondition = iQuery->Conditions();
    CMdELogicCondition* contentCondition = &rootCondition;
    CMdELogicCondition& logicCondition = 
        contentCondition->AddLogicConditionL( ELogicConditionOperatorOr );
    logicCondition.AddObjectConditionL( *iMediaTypeDef );
   
    iTitle = &iMediaTypeDef->GetPropertyDefL( 
            MdeConstants::Object::KTitleProperty );
    iSize = &iMediaTypeDef->GetPropertyDefL( 
            MdeConstants::Object::KSizeProperty );
    iDate = &iMediaTypeDef->GetPropertyDefL(  
            MdeConstants::Object::KCreationDateProperty );
    iQuery->AddPropertyFilterL( iTitle );      
    iQuery->AddPropertyFilterL( iSize );      
    iQuery->AddPropertyFilterL( iDate );
    }

// ---------------------------------------------------------------------------
// CCmFmMdEDuplicateDetector::CheckImageOrVideoLIfDuplicated
// ---------------------------------------------------------------------------
// 
void CCmFmMdEDuplicateDetector::CheckImageOrVideoLIfDuplicated( 
        const CCmFillListItem& aItem )
    {
    TInt count( iExistFiles.Count() );
    TBool dup( EFalse );
    for( TInt i = 0; i < count; i++ )
        {
        if( iExistFiles[i]->Size() > aItem.Size() )
            {
            //quit loop
            i = count;
            }
        else if( iExistFiles[i]->Size() == aItem.Size() && KErrNone == 
            iExistFiles[i]->PrimaryText().CompareF( aItem.PrimaryText() ) )
            {
            //quit loop
            i = count;
            dup = ETrue;
            }
        }
    iObserver.DuplicateL( dup );
    }

// ---------------------------------------------------------------------------
// CCmFmMdEDuplicateDetector::AppendToArray
// ---------------------------------------------------------------------------
// 
void CCmFmMdEDuplicateDetector::AppendToArrayL( const CCmFillListItem& aItem )
    {
    CCmFillListItem* p = CCmFillListItem::NewLC();
    p->SetPrimaryTextL( aItem.PrimaryText() );
    p->SetSize( aItem.Size() );
    iExistFiles.AppendL( p );
    CleanupStack::Pop( p );
    
    // sort by size
    TLinearOrder<CCmFillListItem> key( CCmFmMain::CompareBySize );
    iExistFiles.Sort( key );
    }

// ---------------------------------------------------------------------------
// CCmFmMdEDuplicateDetector::ResetArrayL
// ---------------------------------------------------------------------------
// 
void CCmFmMdEDuplicateDetector::ResetArray()
    {
    iExistFiles.Reset();
    }

// End of file