/*
* 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:  Tester class for abstractmediamtpdp plugin
*
*/


#include <e32def.h>
#include <stiftestinterface.h>
#include <settingserverclient.h>
#include <mtp/mtpprotocolconstants.h>
#include <mtp/cmtptypeobjectinfo.h>
#include <mtp/cmtptypefile.h>
#include <mtp/cmtptypestring.h>
#include <mtp/cmtptypearray.h>
#include <mtp/cmtptypeobjectproplist.h>
#include <mtp/cmtptypeobjectpropdesc.h>
#include <bautils.h>
#include <f32file.h>
#include <mpxharvesterutility.h>
#include "cabstractmediamtpdataprovidertester.h"
#include "logging.h"

#ifdef LOGGER
#undef LOGGER
#endif
#define LOGGER iLog

// definitions and constants for the test data

const TUint32 KTestStorageId = 0x10000;
const TInt KTestObjectsCount = 1;
const TUint KTestDirHandle = 1;
const TInt KTestDirDataproviderId = 0;
const TInt KPlaylistsDirParentId = 0;
_LIT( KTempDirPath, "C:\\mtp_testdata\\temp\\" );
_LIT( KTestDirPath, "C:\\mtp_testdata\\temp\\TESTDIR\\" );
_LIT( KPlaylistFileOrigPath, "C:\\mtp_testdata\\PLAYLIST.M3U" );
_LIT( KPlaylistFileTempPath, "C:\\mtp_testdata\\temp\\PLAYLIST.m3u" );
_LIT( KPlaylistFilePath, "C:\\mtp_testdata\\temp\\PLAYLIST.m3u" );
_LIT( KPlaylistsDirPath, "C:\\mtp_testdata\\temp\\Playlists\\" );
_LIT( KTestDirOrigPath, "C:\\mtp_testdata\\TESTDIR\\*" );
_LIT( KTestDirTempPath, "C:\\mtp_testdata\\temp\\TESTDIR\\" );
_LIT( KTestDirPhysicalStorage, "C:\\mtp_testdata\\temp\\" );
_LIT( KTestDirLogicalStorage, "C:\\mtp_testdata\\temp\\" );

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

// ----------------------------------------------------------------------------
// C++ default constructor can NOT contain any code, that might leave.
// ----------------------------------------------------------------------------
//
CAbstractMediaMtpDataProviderTester::CAbstractMediaMtpDataProviderTester()
        : CMmMtpDataProviderTester()
    {
    // no implementation required
    }

// ----------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// ----------------------------------------------------------------------------
//
void CAbstractMediaMtpDataProviderTester::ConstructL()
    {
    TFileName logFileName;
    logFileName.Copy( KMtpDataProviderTestModuleLogFile );
    
    iLog = CStifLogger::NewL( KMtpDataProviderTestModuleLogPath, 
                          logFileName,
                          CStifLogger::ETxt,
                          TRACE_TARGET,
                          ETrue, ETrue, ETrue, EFalse, ETrue );
    PRINTF0( ">CAbstractMediaMtpDataProviderTester::ConstructL" );
    iActiveSchedulerWait = new ( ELeave ) CActiveSchedulerWait();
    iFsSession.Connect();
    iFileMan = CFileMan::NewL( iFsSession );
    PRINTF0( "<CAbstractMediaMtpDataProviderTester::ConstructL" );
    }

// ----------------------------------------------------------------------------
// Destructor.
// ----------------------------------------------------------------------------
//  
CAbstractMediaMtpDataProviderTester::~CAbstractMediaMtpDataProviderTester()
    {
    PRINTF0( ">CAbstractMediaMtpDataProviderTester::~CAbstractMediaMtpDataProviderTester" );
    delete iActiveSchedulerWait;
    delete iFileMan;
    iFsSession.Close();
    PRINTF0( "<CAbstractMediaMtpDataProviderTester::~CAbstractMediaMtpDataProviderTester" );
    delete iLog;
    }

TInt CAbstractMediaMtpDataProviderTester::PrepareEnvironmentL()
    {
    PRINTF0( ">CAbstractMediaMtpDataProviderTester::PrepareEnvironmentL" );
    TInt result = KErrNone;
    
    result = iFileMan->RmDir( KTempDirPath );
    if ( result == KErrNone )
        {
        PRINTN0( "Warning: old temp directory found, deleted" );
        }
    result = KErrNone;
    
    // create the temp dir if it doesn't exist
    BaflUtils::EnsurePathExistsL( iFsSession, KTempDirPath );
    
    // copy the test data to temp dir
    result = iFileMan->Copy( KPlaylistFileOrigPath, KPlaylistFileTempPath );
    if ( result != KErrNone ) 
        {
        PRINTE1( "Failed to copy playlist file, error %d", result );
        }
    else
        {
        result = iFileMan->Copy( KTestDirOrigPath, KTestDirTempPath,
                CFileMan::EOverWrite | CFileMan::ERecurse );
        if ( result != KErrNone ) 
            {
            PRINTE1( "Failed to copy test dir, error %d", result );
            }
        }
    
    MMPXHarvesterUtility* harvester = CMPXHarvesterFactory::NewL();
    CleanupClosePushL( *harvester );
    PRINTN0( "Starting to import playlist to mpx" );
    iTestObserver->SetPendingOperation( CTestObserver::EHarvesterAddObject );
    harvester->AddFileL(KPlaylistFilePath, iTestObserver);
    
    // waiting for asynchronous operation to complete
    result = iTestObserver->WaitForPendingOperation(); 
    if ( result != KErrNone )
        {
        PRINTE1( "Importing playlist to mpx failed with result %d", result );
        }
    harvester->CloseTransactionL();
    CleanupStack::PopAndDestroy( harvester );
    PRINTF1( "<CAbstractMediaMtpDataProviderTester::PrepareEnvironmentL result = %d", result );
    return result;
    }

TInt CAbstractMediaMtpDataProviderTester::CleanEnvironmentL()
    {
    PRINTF0( ">CAbstractMediaMtpDataProviderTester::CleanEnvironmentL" );
    TInt result = KErrNone;
    TMTPObjectMgrQueryParams queryParams ( KMTPStorageAll, KMTPFormatsAll,
            KMTPHandleNone );
    RMTPObjectMgrQueryContext context;
    RArray<TUint> handles;
    CleanupClosePushL( handles );
    
    PRINTN0( "Starting to delete entries from mpx" );
    MMPXHarvesterUtility* harvester = CMPXHarvesterFactory::NewL();
    CleanupClosePushL( *harvester );
    
    iTestObserver->ObjectMgr().GetObjectHandlesL( queryParams, context,
            handles );
    PRINTV1( "Handle count: %d", handles.Count() );
    context.Close();
    
    CMTPObjectMetaData* metadata = CMTPObjectMetaData::NewLC();
    for ( TInt i = 0; i < handles.Count(); i++ )
        {
        TUint handle = handles[i];
        if ( handle != KTestDirHandle )
            {
            iTestObserver->ObjectMgr().ObjectL( handles[i], *metadata );
            TPtrC fileName = metadata->DesC( CMTPObjectMetaData::ESuid );
            PRINTV1( "Handle: %d", handles[i] );
            PRINTV1( "File name: %S", &fileName );
            
            PRINTN0( "Starting to delete the file from mpx" );
            iTestObserver->SetPendingOperation( CTestObserver::EHarvesterDeleteObject );
            harvester->DeleteFileL( fileName, iTestObserver );
            User::After( 1000000 );
            // waiting for asynchronous operation to complete
            result = iTestObserver->WaitForPendingOperation();
            if ( result != KErrNone )
                {
                PRINTE1( "Warning: failed to delete from mpx, error %d", result );
                result = KErrNone; // ignore for now, there are problems after DeleteObject
                }
            }
        }
    CleanupStack::PopAndDestroy( 3 ); // metadata, harvester, handles
    PRINTN0( "Finished deleting entries from mpx" );
    
    if ( result == KErrNone )
        {
        PRINTN0( "Deleting temp directory" );
        result = iFileMan->RmDir( KTempDirPath );
        if ( result != KErrNone )
            {
            PRINTE1( "Warning: failed to delete temp directory, error %d", result );
            result = KErrNone;
            }
        }
    
    PRINTF1( "<CAbstractMediaMtpDataProviderTester::CleanEnvironmentL result = %d", result );
    return result;
    }

TBool CAbstractMediaMtpDataProviderTester::ObjectEnumerationL_prepare(
        CMTPStorageMetaData* aPhysicalStorage,
        CMTPStorageMetaData* aLogicalStorage )
    {
    PRINTF0( ">CAbstractMediaMtpDataProviderTester::ObjectEnumerationL_prepare" );
    
    TBool result = ETrue;
    aPhysicalStorage->SetDesCL( CMTPStorageMetaData::EStorageSuid,
            KTestDirPhysicalStorage() );
    aPhysicalStorage->SetUint( CMTPStorageMetaData::EStorageSystemType,
            CMTPStorageMetaData::ESystemTypeDefaultFileSystem );
    
    aLogicalStorage->SetDesCL( CMTPStorageMetaData::EStorageSuid,
            KTestDirLogicalStorage() );
    aLogicalStorage->SetUint( CMTPStorageMetaData::EStorageSystemType,
            CMTPStorageMetaData::ESystemTypeDefaultFileSystem );
    
    // insert TESTDIR object manually
    CMTPObjectMetaData* object( CMTPObjectMetaData::NewLC( 0,
            EMTPFormatCodeAssociation, // a folder object
            KTestStorageId, KTestDirPath ) );
    // object is in storage root
    object->SetInt( CMTPObjectMetaData::EParentId, KErrNotFound );
    
    iTestObserver->ObjectMgr().InsertObjectL( *object );
    CleanupStack::PopAndDestroy( object );
    
    PRINTF1( "<CAbstractMediaMtpDataProviderTester::ObjectEnumerationL_prepare result = %d", result );
    return result;
    }

TInt CAbstractMediaMtpDataProviderTester::ObjectEnumerationL_checkresults(
        MMTPObjectMgr& aObjectManager )
    {
    PRINTF0( ">CAbstractMediaMtpDataProviderTester::ObjectEnumerationL_checkresults" );
    
    TInt result = KErrNone;
    
    TMTPObjectMgrQueryParams queryParams ( KMTPStorageAll, KMTPFormatsAll,
            KMTPHandleNone );
    RMTPObjectMgrQueryContext context;
    RArray<TUint> handles;
    CleanupClosePushL( handles );
    MMPXHarvesterUtility* harvester = CMPXHarvesterFactory::NewL();
    CleanupClosePushL( *harvester );
    
    aObjectManager.GetObjectHandlesL( queryParams, context, handles );
    context.Close();
    TInt count = handles.Count();
    PRINTV1( "Handle count: %d", count );
    if ( count != KTestObjectsCount ) 
        {
        PRINTE2( "Wrong number of handles: %d != %d", count, KTestObjectsCount );
        result = KErrGeneral;
        }
    
    CMTPObjectMetaData* metadata = CMTPObjectMetaData::NewLC();
    for ( TInt i = 0; i < count; i++ )
        {
        TUint handle = handles[i];
        aObjectManager.ObjectL( handle, *metadata );
        TPtrC suid = metadata->DesC( CMTPObjectMetaData::ESuid );
        TUint formatCode = metadata->Uint( CMTPObjectMetaData::EFormatCode );
        TUint dataproviderId = metadata->Uint( CMTPObjectMetaData::EDataProviderId );
        TUint storageId = metadata->Uint( CMTPObjectMetaData::EStorageId );
        TInt parentId = metadata->Int( CMTPObjectMetaData::EParentId );
        
        PRINTN1( "Handle: %d", handle );
        PRINTN1( "Suid: %S", &suid );
        
        if ( dataproviderId != KTestDirDataproviderId )
            {
            PRINTE2( "Wrong dataprovider id: %d != %d", dataproviderId, KTestDirDataproviderId );
            result = KErrGeneral;
            }
        if ( storageId != KTestStorageId )
            {
            PRINTE2( "Wrong storage id: %d != %d", storageId, KTestStorageId );
            result = KErrGeneral;
            }
        switch ( handle )
            {
            case 1:
                {
                if ( suid.Match( KTestDirPath ) != 0 )
                    {
                    PRINTE2( "Wrong test dir path: %S != %S", &suid, &KTestDirPath );
                    result = KErrGeneral;
                    }
                if ( formatCode != EMTPFormatCodeAssociation )
                    {
                    PRINTE2( "Wrong format code: 0x%x != 0x%x", formatCode, EMTPFormatCodeAssociation );
                    result = KErrGeneral;
                    }
                if ( parentId != KErrNotFound )
                    {
                    PRINTE2( "Wrong parent id: %d != %d", parentId, KErrNotFound );
                    result = KErrGeneral;
                    }
                break;
                }
            case 2:
                {
                if ( suid.Match( KPlaylistsDirPath ) != 0 )
                    {
                    PRINTE2( "Wrong test object 1 path: %S != %S", &suid, &KPlaylistsDirPath );
                    result = KErrGeneral;
                    }
                if ( formatCode != EMTPFormatCodeAssociation )
                    {
                    PRINTE2( "Wrong format code: 0x%x != 0x%x", formatCode, EMTPFormatCodeAssociation );
                    result = KErrGeneral;
                    }
                if ( parentId != KPlaylistsDirParentId )
                    {
                    PRINTE2( "Wrong parent id: %d != %d", parentId, KPlaylistsDirParentId );
                    result = KErrGeneral;
                    }
                break;
                }
            default:
                {
                PRINTE1( "Unexpected handle: %d", handle );
                result = KErrGeneral;
                }
            }
        /*
        if ( ( result == KErrNone ) && ( handle != KTestDirHandle ) )
            {
            PRINTN0( "Starting to harvest the file" );
            iTestObserver->SetPendingOperation( CTestObserver::EHarvesterAddObject );
            harvester->AddFileL( metadata->DesC( CMTPObjectMetaData::ESuid ), iTestObserver );
            PRINTN0( "Waiting for harvesting to complete" );
            result = iTestObserver->WaitForPendingOperation();
            if ( result != KErrNone )
                {
                PRINTE1( "Harvesting error: %d", result );
                }
            }
        */
        }
    CleanupStack::PopAndDestroy( 3 ); // handles, harvester, metadata
    PRINTF1( "<CAbstractMediaMtpDataProviderTester::ObjectEnumerationL_checkresults result = %d", result );
    return result;
    }

TInt CAbstractMediaMtpDataProviderTester::DeleteObjectL_checkresults(
        MMTPObjectMgr& aObjectManager )
    {
    PRINTF0( ">CAbstractMediaMtpDataProviderTester::DeleteObjectL_checkresults" );
    TInt result = KErrNone;
    // check that everything has been deleted from the file system
    if ( BaflUtils::FileExists( iFsSession, KPlaylistFilePath ) ) 
        {
        PRINTE0( "Playlist file was not deleted successfully" );
        // playlist file is not enumerated, so it cannot be deleted
        //result = KErrGeneral;
        }
    PRINTF1( ">CAbstractMediaMtpDataProviderTester::DeleteObjectL_checkresults result = %d", result );
    return result;
    }