/*
* Copyright (c) 2009 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:  Browsing adapter between RemCon an MPX Framework. 
*
*/

// INCLUDE FILES
#include <remconinterfaceselector.h>
#include <mpxcollectionmessagedefs.h>
#include <mpxmessagegeneraldefs.h>
#include <mpxmediageneraldefs.h>
#include <mpxsubscription.h>
#include <mpxcommandgeneraldefs.h>
#include <mpxcollectioncommanddefs.h>
#include <mpxmediacontainerdefs.h>
#include <e32cmn.h>
#include <remconmediaerror.h>

#include "btrccBrowsingAdapter.h"
#include "debug.h"

#ifdef BTRCCTEST_MPXCOLLECTIONSTUB
#include <stubsrv/mpxcollectionstub.h>
#endif


// MODULE DATA STRUCTURES

// ================= MEMBER FUNCTIONS =======================

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CBTRCCBrowsingAdapter* CBTRCCBrowsingAdapter::NewL(CRemConInterfaceSelector& aInterfaceSelector)
    {
    CBTRCCBrowsingAdapter* self = new (ELeave) CBTRCCBrowsingAdapter();
    CleanupStack::PushL(self);
    self->ConstructL(aInterfaceSelector);
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::CBTRCCBrowsingAdapter
// C++ constructor.
// -----------------------------------------------------------------------------
//
CBTRCCBrowsingAdapter::CBTRCCBrowsingAdapter()
    {
    }

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::ConstructL
// Symbian 2nd phase constructor.
// -----------------------------------------------------------------------------
//
void CBTRCCBrowsingAdapter::ConstructL(CRemConInterfaceSelector& aInterfaceSelector)
    {
    TRACE_FUNC
    iMediaBrowseTarget = CRemConDatabaseAwareMediaBrowseTarget::NewL(
                             aInterfaceSelector, *this, *this, EFalse,
                             iMlInterface, iNpInterface, iCookie);

#ifdef BTRCCTEST_MPXCOLLECTIONSTUB
    iCollectionUtility = CMPXCollectionUtilityStubImpl::NewL(this, KMcModeDefault);    
#else
    iCollectionUtility = MMPXCollectionUtility::NewL(this, KMcModeDefault);
#endif

    iCurrentOpenLOp = EOpenLOpOpen;
    iCollectionUtility->Collection().OpenL(EMPXOpenDefault);
    }

// -----------------------------------------------------------------------------
// Destructor.
// -----------------------------------------------------------------------------
//
CBTRCCBrowsingAdapter::~CBTRCCBrowsingAdapter()
    {
    TRACE_FUNC
    delete iMediaBrowseTarget;
    delete iCollectionUtility; 
    }

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::MrcdamlboGetFolderListing
// -----------------------------------------------------------------------------
//
void CBTRCCBrowsingAdapter::MrcdamlboGetFolderListing(TRemConFolderScope aScope,
        TUint /*aStartItem*/, TUint /*aEndItem*/)
    {
    TRACE_FUNC

    // Check that the aScope is in filesystem scope. 
    if (aScope != EBrowseFolder)
        {
        // Not supported. 
        return; 
        }

    // ToDo: Check that we don't have any other operation ongoing. 
    // If we do, put the new operation in queue  

    TInt err = KErrNone;
    CMPXCollectionPath* path = NULL;
    TRAP(err, path = iCollectionUtility->Collection().PathL())
    
    if(!err)
        {
        TRAP(err, path->SelectAllL())
        }
    if(!err)
        {
        RArray<TMPXAttribute> attrs;
        attrs.Append( KMPXMediaGeneralId );
        attrs.Append( KMPXMediaGeneralTitle );
        TRAP(err, iCollectionUtility->Collection().MediaL(*path, attrs.Array()))        
        }
    if(!err)
        {
        iCurrentMediaLOp = EMediaLOpFolderListing;
        }
    TRACE_INFO((_L("Get folder listing %d"), err))


/*    CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();
    CleanupStack::PushL( path );
    if ( path->Levels() == KVcxMpxLevelVideos 
            && path->Count() > aIndex
            && aIndex >= 0 )
        {
        // Marks the item that will be handled
        path->SelectL( aIndex );

        RArray<TMPXAttribute> dummy; // No need to set this parameter
        CleanupClosePushL( dummy );
        iCollectionUtility->Collection().MediaL( *path, dummy.Array() );
        CleanupStack::PopAndDestroy( &dummy );
        }
    CleanupStack::PopAndDestroy( path ); */
    
    }

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::MrcdamlboGetItem
// This function is called to request for indicidual item's properties.  
// -----------------------------------------------------------------------------
//
TInt CBTRCCBrowsingAdapter::MrcdamlboGetItem(TRemConFolderScope /*aScope*/,
        const TRemConItemUid& /*aItemId*/, 
        TMediaAttributeIter& /*aIter*/, 
        TUint16 /*aMediaLibraryStateCookie*/)
    {
    TRACE_FUNC
    
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::MrcdamlboFolderUp
// -----------------------------------------------------------------------------
//
void CBTRCCBrowsingAdapter::MrcdamlboFolderUp(TUint16 aMediaLibraryStateCookie)
    {   
    TRACE_FUNC
    if(aMediaLibraryStateCookie == iCookie)
        {
        TRAPD( err, iCollectionUtility->Collection().BackL() );
        if(err)
            {
            }
        // --> HandleOpenL will called
        }
    else
        {
        
        }
    }

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::MrcdamlboFolderDown
// -----------------------------------------------------------------------------
//
void CBTRCCBrowsingAdapter::MrcdamlboFolderDown(const TRemConItemUid& aFolder,
        TUint16 aMediaLibraryStateCookie)
    {
    TRACE_FUNC
    if(aMediaLibraryStateCookie == iCookie)
        {
        TInt err = KErrNone;
        CMPXCollectionPath* path = NULL;
        TRAP( err, path = iCollectionUtility->Collection().PathL() );
        if(!err)
            {
            TMPXItemId index = path->IdOfIndex((TInt)aFolder);
            if(index != KMPXInvalidItemId)
                {
                TRAP( err, iCollectionUtility->Collection().OpenL(index) );
                // --> HandleOpenL will called.
                }
            }
        }
    else
        {
        
        }
    }

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::MrcdamlboGetPath
// -----------------------------------------------------------------------------
//
void CBTRCCBrowsingAdapter::MrcdamlboGetPath(RPointerArray<HBufC8>& /*aPath*/)
    {
    TRACE_FUNC   
    TInt err = KErrNone;
    CMPXCollectionPath* browsePath = NULL;
    CMPXCollectionPath* container = NULL;
    
    TRAP( err, browsePath = iCollectionUtility->Collection().PathL() );
    
    // Split path into levels until root level is reached.
    TRAP( err, container = browsePath->ContainerPathL() ); 
    
    // Store the path information into received refToPath.
    // --> do something
    
    // Path information stored, inform RemCon
    //iMlInterface->MrcdamlbGetPathResult(TUint aItemCount, TUint16 aMediaLibraryStateCookie, TInt aResult);
    
    delete browsePath;
    delete container;
    }

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::MrcdanpboGetFolderListing
// -----------------------------------------------------------------------------
//
void CBTRCCBrowsingAdapter::MrcdanpboGetFolderListing(TUint /*aStartItem*/, TUint /*aEndItem*/)
    {
    TRACE_FUNC
    // Use the current path to 
//    iCollectionUtility->Collection().MediaL(path, aAttrs, )
    }

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::MrcdanpboGetItem
// -----------------------------------------------------------------------------
//
TInt CBTRCCBrowsingAdapter::MrcdanpboGetItem(const TRemConItemUid& /*aItemId*/, TMediaAttributeIter& /*aIter*/, TUint16 /*aMediaLibraryStateCookie*/)
    {
    TRACE_FUNC
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::MrcdamlboSearch
// -----------------------------------------------------------------------------
//
void CBTRCCBrowsingAdapter::MrcdamlboSearch(const TDesC8& /*aSearch*/)
    {
    TRACE_FUNC
    }

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::HandleCollectionMessage
// -----------------------------------------------------------------------------
//
void CBTRCCBrowsingAdapter::HandleCollectionMessage(CMPXMessage* aMsg, TInt /*aErr*/)
    {
    TRACE_FUNC
    if(iMlInterface && aMsg)
        {
        if( aMsg->IsSupported(KMPXMessageMediaGeneralCategory) &&
            aMsg->IsSupported(KMPXMessageChangeEventType) )
            {
            TInt event( aMsg->ValueTObjectL<TInt>( KMPXMessageMediaGeneralCategory ) );
            TInt op( aMsg->ValueTObjectL<TInt>( KMPXMessageChangeEventType ) );

            if( event == EMPXCollection )
                {
                if( op == EMPXItemDeleted ||
                    op == EMPXItemInserted ||
                    op == EMPXItemModified )
                    {
                    // how cookie is really composed??
                    iCookie = op;
                    iMlInterface->MrcdamlbMediaLibraryStateChange(iCookie);
                    }
                }
            }
        }
    
    /* Example from mpxdeletehelper.cpp
    if( aMessage &&
        aMessage->IsSupported(KMPXMessageGeneralEvent) &&
        aMessage->IsSupported(KMPXMessageGeneralType) )
        {
        TInt event( aMessage->ValueTObjectL<TInt>( KMPXMessageGeneralEvent ) );
        TInt op( aMessage->ValueTObjectL<TInt>( KMPXMessageGeneralType ) );

        MPX_DEBUG3( "CMPXDeleteHelper::HandleCollectionMessageL event = %d, type = %d",
                    event, op );

        if( event == TMPXCollectionMessage::EBroadcastEvent )
            {
            if( op == EMcMsgFormatStart ||
                op == EMcMsgDiskRemoved ||
                op == EMcMsgUSBMassStorageStart ||
                op == EMcMsgUSBMTPStart )
                {
                iCancelled = ETrue;
                Cancel();
                }
            }

        }*/
    }

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::HandleOpenL
// -----------------------------------------------------------------------------
//
void CBTRCCBrowsingAdapter::HandleOpenL(const CMPXMedia& /*aEntries*/, TInt /*aIndex*/, TBool /*aComplete*/, TInt aError)
    {
    // This is called when a folder has been opened. We could store a path here. 
    TRACE_FUNC
    if(!aError)
        {
        switch(iCurrentOpenLOp)
            {
            case EOpenLOpOpen:
                break;
            default:
                break;
            }
        }    
    iCurrentOpenLOp = EOpenLOpIdle;
    }

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::HandleOpenL
// -----------------------------------------------------------------------------
//
void CBTRCCBrowsingAdapter::HandleOpenL(const CMPXCollectionPlaylist& /*aPlaylist*/,TInt /*aError*/)
    {
    TRACE_FUNC
    }

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::HandleCommandComplete
// -----------------------------------------------------------------------------
//
void CBTRCCBrowsingAdapter::HandleCommandComplete(CMPXCommand* /*aCommandResult*/, TInt /*aError*/)
    {
    TRACE_FUNC
    }

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::HandleCollectionMediaL
// -----------------------------------------------------------------------------
//
void CBTRCCBrowsingAdapter::HandleCollectionMediaL(const CMPXMedia& aMedia, TInt aError)
    {
    TRACE_FUNC 
    RArray<TRemConItem> folderListing; 
    TInt cookie = 0; 
    if(!aError)
        {
        switch(iCurrentMediaLOp)
            {
            case EMediaLOpFolderListing:
                {
                TRACE_INFO((_L("CBTRCCBrowsingAdapter::HandleCollectionMediaL, EMediaLOpFolderListing")))
                
                TMPXAttribute mediaArrayAttr( KMPXMediaIdContainer, EMPXMediaArrayContents );
                // Check if there is more than one item in aMedia
                if( aMedia.IsSupported( mediaArrayAttr ) )
                    {
                    TRACE_INFO((_L("CBTRCCBrowsingAdapter::HandleCollectionMediaL, media array is supported.")))
                    const CMPXMediaArray* mediaArray = aMedia.ValueCObjectL<CMPXMediaArray>( mediaArrayAttr ); 
                    //User::LeaveIfNull( const_cast<CMPXMediaArray*>( mediaArray ));
                    
                    TInt error = KErrNone;
                    if(mediaArray)
                        {
                        for(TInt i = 0; i < mediaArray->Count() ; ++i)
                            {
                            CMPXMedia* ptrToElement = mediaArray->AtL(i); 
                            TMPXAttribute uidAttr(KMPXMediaIdGeneral, EMPXMediaGeneralId);
                            TMPXAttribute typeAttr(KMPXMediaIdGeneral, EMPXMediaGeneralType);
                            if( ptrToElement->IsSupported(uidAttr) && ptrToElement->IsSupported(typeAttr) ) 
                                {
                                TRemConItem item;  
                                const TUid& id = ptrToElement->ValueTObjectL<TUid>(uidAttr);
                                item.iUid = id.iUid;  
                                const TMPXGeneralType& type = ptrToElement->ValueTObjectL<TMPXGeneralType>(typeAttr);                               
                                
                                TRACE_INFO((_L("CBTRCCBrowsingAdapter::HandleCollectionMediaL, id %d"), id))
                                TRACE_INFO((_L("CBTRCCBrowsingAdapter::HandleCollectionMediaL, type %d"), type))                                
                                
                                if(type == EMPXGroup)
                                    {
                                    item.iType = ERemConFolderItem;
                                    }
                                else if(type == EMPXItem)
                                    {
                                    item.iType = ERemConMediaItem; 
                                    }
                                else
                                    {
                                    continue; // skip appending if the type wasn't folder or item.  
                                    }
                                TRACE_INFO((_L("CBTRCCBrowsingAdapter::HandleCollectionMediaL, Append data")))
                                folderListing.Append(item); 
                                }
                            else
                                {
                                TRACE_INFO((_L("CBTRCCBrowsingAdapter::HandleCollectionMediaL, Not supported, item index %d."), i))
                                }
                            }
                        TRACE_INFO((_L("CBTRCCBrowsingAdapter::HandleCollectionMediaL, pass media to RemCon")))
                        
                        }
                    else
                        {
                        TRACE_INFO((_L("CBTRCCBrowsingAdapter::HandleCollectionMediaL, No media!")))
                        error = KErrMediaBrowseInvalidOffset;
                        }
                    iMlInterface->MrcdamlbFolderListing(folderListing.Array(), cookie, error);
                    }
                else
                    {
                    TRACE_INFO((_L("CBTRCCBrowsingAdapter::HandleCollectionMediaL, Array Content Not Supported.")))
                    // "Single" elements should handled separately ??
                    }                
                }
                break;
            }
        }
    else
        {
        TRACE_INFO((_L("CBTRCCBrowsingAdapter::HandleCollectionMediaL, error %d"), aError))
        iMlInterface->MrcdamlbFolderListing(folderListing.Array(), cookie, aError);
        //HandleErrorL(aError);
        }
    folderListing.Close(); 
    iCurrentMediaLOp = EMediaLOpIdle;
    }

// -----------------------------------------------------------------------------
// CBTRCCBrowsingAdapter::SubscribeL
// -----------------------------------------------------------------------------
//
void CBTRCCBrowsingAdapter::SubscribeL()
    {
    TRACE_FUNC
    // Create subscription items
    CMPXSubscription* subscription( CMPXSubscription::NewL() );
    CleanupStack::PushL( subscription );

    CMPXSubscriptionItem* subItem1( CMPXSubscriptionItem::NewL() );
    CleanupStack::PushL( subItem1 );   
    
    subItem1->SetTObjectValueL( KMPXMessageCollectionId, KMPXMessageGeneral );
    subItem1->SetTObjectValueL( KMPXMessageMediaGeneralCategory, EMPXCollection );
    subItem1->SetTObjectValueL( KMPXMessageChangeEventType, EMPXItemDeleted );
    subscription->AddItemL( *subItem1 );
    
    CMPXSubscriptionItem* subItem2( CMPXSubscriptionItem::CopyL( *subItem1 ));
    CleanupStack::PushL( subItem2 );
    subItem2->SetTObjectValueL( KMPXMessageChangeEventType, EMPXItemInserted );
    subscription->AddItemL( *subItem2 );
    
    CMPXSubscriptionItem* subItem3( CMPXSubscriptionItem::CopyL( *subItem1 ));
    CleanupStack::PushL( subItem3 );
    subItem3->SetTObjectValueL( KMPXMessageChangeEventType, EMPXItemModified );
    subscription->AddItemL( *subItem3 );
    
    iCollectionUtility->Collection().AddSubscriptionL( *subscription );
    
    CleanupStack::PopAndDestroy( subItem3 );
    CleanupStack::PopAndDestroy( subItem2 );
    CleanupStack::PopAndDestroy( subItem1 );
    CleanupStack::PopAndDestroy( subscription );
    
    /* Example
    // Subscribe to only a few messages from collection utility
    subItem1->SetTObjectValueL( KMPXMessageGeneralId, KMPXMessageGeneral );
    subItem1->SetTObjectValueL( KMPXMessageGeneralEvent, TMPXCollectionMessage::EBroadcastEvent );
    subItem1->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgDiskRemoved );
    subscription->AddItemL( *subItem1 );

    CMPXSubscriptionItem* subItem2( CMPXSubscriptionItem::CopyL( *subItem1 ));
    CleanupStack::PushL( subItem2 );
    subItem2->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgUSBMassStorageStart );
    subscription->AddItemL( *subItem2 );
    CMPXSubscriptionItem* subItem3( CMPXSubscriptionItem::CopyL( *subItem1 ));
    CleanupStack::PushL( subItem3 );
    subItem3->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgUSBMTPStart );
    subscription->AddItemL( *subItem3 );
    CMPXSubscriptionItem* subItem4( CMPXSubscriptionItem::CopyL( *subItem1 ));
    CleanupStack::PushL( subItem4 );
    subItem4->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgFormatStart );
    subscription->AddItemL( *subItem4 );
    CMPXSubscriptionItem* subItem5( CMPXSubscriptionItem::CopyL( *subItem1 ));
    CleanupStack::PushL( subItem5 );
    subItem5->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgUSBMassStorageEnd );
    subscription->AddItemL( *subItem5 );
    CMPXSubscriptionItem* subItem6( CMPXSubscriptionItem::CopyL( *subItem1 ));
    CleanupStack::PushL( subItem6 );
    subItem6->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgUSBMTPEnd );
    subscription->AddItemL( *subItem6 );
    CMPXSubscriptionItem* subItem7( CMPXSubscriptionItem::CopyL( *subItem1 ));
    CleanupStack::PushL( subItem7 );
    subItem7->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgFormatEnd );
    subscription->AddItemL( *subItem7 );
    CMPXSubscriptionItem* subItem8( CMPXSubscriptionItem::NewL() );
    CleanupStack::PushL( subItem8 );
    subItem8->SetTObjectValueL( KMPXMessageGeneralId, KMPXMessageGeneral );
    subItem8->SetTObjectValueL( KMPXMessageGeneralEvent, TMPXCollectionMessage::EPathChanged );
    subItem8->SetTObjectValueL( KMPXMessageGeneralType, EMcPathChangedByOpen );
    subItem8->SetTObjectValueL( KMPXMessageGeneralData, EMcItemOpened );
    subscription->AddItemL( *subItem8 );
    iCollectionUtility->Collection().AddSubscriptionL( *subscription );
    CleanupStack::PopAndDestroy( subItem8 );
    CleanupStack::PopAndDestroy( subItem7 );
    CleanupStack::PopAndDestroy( subItem6 );
    CleanupStack::PopAndDestroy( subItem5 );
    CleanupStack::PopAndDestroy( subItem4 );
    CleanupStack::PopAndDestroy( subItem3 );
    CleanupStack::PopAndDestroy( subItem2 );
    CleanupStack::PopAndDestroy( subItem1 );
    CleanupStack::PopAndDestroy( subscription ); */    
    }