/*

* Copyright (c) 2006 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:  Interface for the Recorded chats UI to interact with the engine

*

*/

#include    "MCALoggerHeadersInterface.h"

#include    "CCARecordedChatsPC.h"

#include    "MCARecordedChatsArrayPC.h"

#include	"ChatDefinitions.h"

#include	"IMDialogUtils.h"

#include    "IMUtils.h"

#include    "CCAStorageManagerFactory.h"

#include 	"MCAStoredContacts.h"

#include    "MCAMessagesWriteInterface.h"

#include    "MCAStoredGroups.h"

#include    "MCAStoredGroup.h"

#include    "CCAServerContactsArrayPC.h"

#include	"MCALoggerMessageHeader.h"

#include	"MCAMessagesReadInterface.h"

#include    <bamdesca.h> // MDesCArray

#include    <avkon.rsg>

#include    <chatNG.rsg>

#include    <e32base.h>

#include    <StringLoader.h>

#include    <sendui.h>

#include    <s32mem.h>   //CBufStore

#include    <s32file.h>

#include    <txtrich.h>

#include    <avkon.hrh>

#include    <eikmenup.h>

#include	<aknutils.h>

#include    <senduiconsts.h>

#include    <CMessageData.h>

#include    <pathinfo.h>

#ifdef RD_MULTIPLE_DRIVE

#include "CCAProcessManagerFactory.h"

#include "MCAProcessManager.h"

#include "CCAEngine.h"

#endif

_LIT( KCAHistoryTempDirectory, ":\\system\\temp\\IMTemp\\" );

_LIT( KLineFeedFormat, "%c" );

/* list of forbidden characters which which are removed when

 * file name is created

 */

_LIT( KForbiddenCharacters, "\\/:*?\"<>|" );

/*

 * This is for log names which are not good for filename

 */

_LIT( KGeneralSendFilename, "Badlogname" );

_LIT( KNotepadFileExtension, ".txt" );

_LIT( KFileFooterFormat, " ( %d )" );

//CONSTANTS

const TInt KOneSelected = 1;

const TInt KFileFooterLength = 6;

const TInt KLengthOfPathEnd = 1;

const TInt KFileCount = 2;

//recommended minimimun amount of granularity for segmented buffer is 16

const TInt KSegmentGranularity = 16;

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

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

// CCARecordedChatsPC::CCARecordedChatsPC

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

//

CCARecordedChatsPC::CCARecordedChatsPC( MCALoggerHeadersInterface& aLoggerHeadersInterface,

                                        MCARecordedChatsArrayPC& aRecordedChatsArrayPC )

        : iLoggerHeadersInterface( aLoggerHeadersInterface ),

        iRecordedChatsArrayPC( aRecordedChatsArrayPC )

    {

    // since we can not appui fromave to pc

    // hence codescanner warning can be ignored

    iEikonEn = CEikonEnv::Static();

    }

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

// CCARecordedChatsPC::~CCARecordedChatsPC

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

//

CCARecordedChatsPC::~CCARecordedChatsPC()

    {

    delete iSendAppUi;

    iItemsForDeletion.Close();

    delete iHistoryTempDir;

    }

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

// CCARecordedChatsPC::NewL

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

//

CCARecordedChatsPC* CCARecordedChatsPC::NewL( MCALoggerHeadersInterface& aLoggerHeadersInterface,

                                              MCARecordedChatsArrayPC& aRecordedChatsArrayPC )

    {

    CCARecordedChatsPC* self = new ( ELeave ) CCARecordedChatsPC( aLoggerHeadersInterface,

                                                                  aRecordedChatsArrayPC );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCARecordedChatsPC::ConstructL

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

//

void CCARecordedChatsPC::ConstructL()

    {

    //To store the history on a temp file in D: drive

    RFs &fileSession = iEikonEn->FsSession();

    TChar dDrive;

    User::LeaveIfError( fileSession.DriveToChar( EDriveD, dDrive ) );

    // +1 for dirve letter

    iHistoryTempDir = HBufC::NewL( 1 + KCAHistoryTempDirectory().Length() );

    TPtr ptr( iHistoryTempDir->Des() );

    ptr.Append( dDrive );

    ptr.Append( KCAHistoryTempDirectory );

    TFileName historyTempDir;

    historyTempDir.Copy( ( *iHistoryTempDir ).Left( historyTempDir.MaxLength() ) );

    //Ensure, that there is no file named IMHistory beforehand. Ignore errors

    fileSession.Delete( historyTempDir.Left(

                            historyTempDir.Length() - KLengthOfPathEnd ) );

    TInt createDirError( fileSession.MkDirAll( historyTempDir ) );

    if ( createDirError != KErrNone && createDirError != KErrAlreadyExists )

        {

        User::LeaveIfError( createDirError );

        }

    }

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

// CCARecordedChatsPC::DeleteRecordedChatContainerL

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

//

void CCARecordedChatsPC::DeleteRecordedChatContainerL()

    {

    iLoggerHeadersInterface.DeleteRecordedChatContainerL();

    }

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

// CCARecordedChatsPC::DeleteHistoryFilesL

// Delete history file. One or many.

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

//

void CCARecordedChatsPC::DeleteHistoryFilesL( TInt aIndex, TBool aDeleteCurrentChat )

    {

    // This method is called from container, and container should initialize

    // iSelectedItems. If not initialized, leave with KErrArgument

    if ( !iSelectedItems )

        {

        User::Leave( KErrArgument );

        }

    TInt markedCount( iSelectedItems->Count() );

    iRecordedChatsArrayPC.SetProgressCount( 0 );

    InitDeleteArrayL();

    if ( markedCount == 0 ) //one item

        {

        // If flag is on for current chat deletion. Change index.

        // This can occur only when markedCount is 0, so check is not

        // needed in else branch

        if ( aDeleteCurrentChat )

            {

            aIndex = iRecordedChatsArrayPC.GetCurrentItemIndex();

            }

        else    //This is for keeping track of current item.

            {

            iRecordedChatsArrayPC.SetCurrentItemIndex( aIndex );

            }

        __ASSERT_ALWAYS( aIndex >= 0,

                         User::Panic( KPanicText, EAccessArrayOutOfBounds ) );

        __ASSERT_ALWAYS( aIndex <= iRecordedChatsArrayPC.MdcaCount(),

                         User::Panic( KPanicText, EAccessArrayOutOfBounds ) );

        iRecordedChatsArrayPC.SetNextIndex( aIndex );

        }

    else

        {

        TInt progressCount = iRecordedChatsArrayPC.GetProgressCount();

        if ( progressCount >= 0 && progressCount < iItemsForDeletion.Count() )

            {

            iRecordedChatsArrayPC.SetNextIndex( iItemsForDeletion[ progressCount ] );

            }

        }

    }

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

//  CCARecordedChatsPC::DeleteHistoryFileL

//  Delete one file and update index.

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

//

TBool CCARecordedChatsPC::DeleteHistoryFileL( )

    {

    // This method is called from container, and container should initialize

    // iSelectedItems. If not initialized, leave with KErrArgument

    if ( !iSelectedItems )

        {

        User::Leave( KErrArgument );

        }

    TInt curItemIndex = iRecordedChatsArrayPC.GetCurrentItemIndex();

    TInt nextIndex = iRecordedChatsArrayPC.GetNextIndex();

    //Keep track of current item index

    if ( (  curItemIndex  >  nextIndex ||

            curItemIndex == nextIndex &&

            curItemIndex == iLoggerHeadersInterface.HeaderCount() - 1 ) &&

         curItemIndex != 0 )

        {

        iRecordedChatsArrayPC.SetCurrentItemIndex( curItemIndex - 1 );

        }

    iLoggerHeadersInterface.DeleteHistoryFileL( iRecordedChatsArrayPC.GetNextIndex() );

    TInt progressCount = iRecordedChatsArrayPC.GetProgressCount();

    iRecordedChatsArrayPC.SetProgressCount( progressCount + 1 );

    progressCount = iRecordedChatsArrayPC.GetProgressCount();

    if ( iItemsForDeletion.Count() <= progressCount )

        {

        return EFalse;

        }

    iRecordedChatsArrayPC.SetNextIndex( iItemsForDeletion[ progressCount ] );

    return ETrue;

    }

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

// CCARecordedChatsPC::CheckAndCorrectMTMFilename

// Check and correct proposed filename for MTM sending purposes.

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

//

void CCARecordedChatsPC::CheckAndCorrectMtmFilename( TFileName& aFilename,

                                                     MDesCArray& aArray )

    {

    TBool successFlag;

    // remove forbidden characters

    TInt len( aFilename.Length() );

    // Start from end of data

    for ( TInt i( len - 1 ); i >= 0; --i )

        {

        // now all the specials get removed

        TPtrC c = aFilename.Mid( i, 1 );  // next character

        TInt position = ( KForbiddenCharacters() ).FindC( c );

        if ( position != KErrNotFound )

            {

            // the current character is a FORBIDDEN CHARACTER,

            // remove it

            aFilename.Delete( i, 1 );

            }

        }

    // Sanity check. We removed characters, but still checking if there

    // is anything in the string

    if ( aFilename.Length() < 1 )

        {

        aFilename.Append( KGeneralSendFilename );

        }

    // Insert path in begin of file

    RFs &fileSession = iEikonEn->FsSession();

    TFileName tempFileName;

    tempFileName.Copy( ( *iHistoryTempDir ).Left( tempFileName.MaxLength() ) );

    tempFileName.Append( aFilename );

    aFilename = tempFileName;

    //start from two, because there is one with same name

    //filename -> filename ( 2 )

    TInt fileIndex( KFileCount );

    TInt arrayCount( aArray.MdcaCount() );

    do

        {

        successFlag = ETrue;

        for ( TInt b( 0 ); b < arrayCount && successFlag; ++b )

            {

            if ( tempFileName.CompareC( aArray.MdcaPoint( b ) ) == 0 )

                {

                TBuf< KFileFooterLength > filenameFooter;

                filenameFooter.Format( KFileFooterFormat, fileIndex++ );

                tempFileName = aFilename;

                tempFileName.Append( filenameFooter );

                successFlag = EFalse;

                }

            }

        }

    while ( !successFlag );

    aFilename = tempFileName;

    }

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

// CCARecordedChatsPC::SelectedItemsCount

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

//

TInt CCARecordedChatsPC::SelectedItemsCount() const

    {

    return iSelectedItems->Count();

    }

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

// CCARecordedChatsPC::ValidSelectedItems

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

//

TBool CCARecordedChatsPC::ValidSelectedItems() const

    {

    if ( iSelectedItems )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

// CCARecordedChatsPC::PrepareArrayForSendingMtmL

// Prepares MTM launch component, if not yet prepared.

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

//

void CCARecordedChatsPC::PrepareArrayForSendingMtmL()

    {

    if ( !iSendAppUi )

        {

        //no meaning for command id for us in here so zero passed because

        //command id is mandatory parameter for CSendUi::NewL method.

        iSendAppUi = CSendUi::NewL();

        }

    }

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

// CCARecordedChatsPC::IsMarked

// Returns items marked status

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

//

TBool CCARecordedChatsPC::IsMarked( TInt aIndex )

    {

    __ASSERT_ALWAYS( aIndex >= 0,

                     User::Panic( KPanicText, EAccessArrayOutOfBounds ) );

    __ASSERT_ALWAYS( iRecordedChatsArrayPC.MdcaCount() > aIndex,

                     User::Panic( KPanicText, EAccessArrayOutOfBounds ) );

    if ( !iSelectedItems )

        {

        return EFalse;

        }

    TInt markedCount( iSelectedItems->Count() );

    for ( TInt a( 0 ); a < markedCount; ++a )

        {

        if ( aIndex == iSelectedItems->At( a ) )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// CCARecordedChatsPC::SetSelectedItems

// Initialize or uninitialize selected items. NULL means uninitialization.

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

//

void CCARecordedChatsPC::SetSelectedItems( const CArrayFix< TInt >* aArray )

    {

    iSelectedItems = aArray;

    }

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

// CCARecordedChatsPC::InitDeleteArrayL

// Init delete array, so we delete items in right order.

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

//

void CCARecordedChatsPC::InitDeleteArrayL()

    {

    iItemsForDeletion.Reset();

    RArray< TInt > tempArray;

    CleanupClosePushL( tempArray );

    TInt itemCount = iSelectedItems->Count();

    TInt index;

    for ( index = 0; index < itemCount; ++index )

        {

        User::LeaveIfError( tempArray.Append( iSelectedItems->At( index ) ) );

        }

    tempArray.Sort();

    for ( index = itemCount - 1; index >= 0; --index )

        {

        if ( index >= 0 && index < tempArray.Count() ) //Bound checking

            {

            User::LeaveIfError( iItemsForDeletion.Append( tempArray[ index ] ) );

            }

        }

    //Codescanner warning ignored

    CleanupStack::PopAndDestroy(); // tempArray.Close()

    }

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

// CCARecordedChatsPC::SendMTML

// MTM editor launcher.

// Code Scanner warning to be ignored

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

//

TInt CCARecordedChatsPC::SendMTML( TInt aIndex, TUid aTargetUid /*= KNullUid*/ )

    {

    __ASSERT_ALWAYS( aIndex >= 0,

                     User::Panic( KPanicText, EAccessArrayOutOfBounds ) );

    __ASSERT_ALWAYS( iRecordedChatsArrayPC.MdcaCount() > aIndex,

                     User::Panic( KPanicText, EAccessArrayOutOfBounds ) );

    if ( !iSendAppUi )

        {

        // Leave after prepare. Prepare should have been called earlier.

        // For some reason iSendAppUi is not ready for sending MTM messages

        // if we try to use it right after creation. This is why leave is needed.

        PrepareArrayForSendingMtmL();

        User::Leave( KErrNotReady );

        }

    if ( aTargetUid == KNullUid )

        {

        // No target uid defined, show query

        // only one item in the array

        CArrayFix<TUid>* servicesToDim = new( ELeave )CArrayFixFlat<TUid>( 1 );

        CleanupStack::PushL( servicesToDim );

        servicesToDim->AppendL( KSenduiMtmAudioMessageUid );

        TRAPD( cancel, aTargetUid = iSendAppUi->ShowSendQueryL( NULL,

                                                                KCapabilitiesForAllServices, servicesToDim ) );

        CleanupStack::PopAndDestroy( servicesToDim );

        if ( cancel == KErrCancel || aTargetUid == KNullUid )

            {

            // user cancelled

            return KErrCancel;

            }

        User::LeaveIfError( cancel );

        }

    CDesCArray* attachments = NULL;

    TBool fileSendFlag( EFalse );

    TStreamId theId;

    //recommended minimimun amount of granularity for segmented buffer is 16

    CStreamStore* bufStore = CBufStore::NewLC( KSegmentGranularity );

    TInt maxMsgLength( IMUtils::MaxMsgLength() );

    RStoreWriteStream outStream;

    RStoreReadStream inStream;

    // this is done to get the Id for replacement in the for-loop

    theId = outStream.CreateLC( *bufStore );

    //Codescanner warning ignored

    CleanupStack::PopAndDestroy(); //outStream

    CRichText* text =

        CRichText::NewL( iEikonEn->SystemParaFormatLayerL(),

                         iEikonEn->SystemCharFormatLayerL() );

    CleanupStack::PushL( text );

    TInt markedCount;

    if ( iSelectedItems )

        {

        markedCount = iSelectedItems->Count();

        }

    else

        {

        markedCount = KOneSelected; // Delete from recorded chat view.

        }

    CMessageData* messageData = CMessageData::NewL();

    CleanupStack::PushL( messageData );

#ifdef RD_UNIFIED_EDITOR

    // check sending capabilities

    TSendingCapabilities capa;

    iSendAppUi->ServiceCapabilitiesL( aTargetUid, capa );

    if ( capa.iFlags & TSendingCapabilities::ESupportsAttachments )

        {

        // send as attachments

        fileSendFlag = ETrue;

        attachments = new( ELeave ) CDesCArraySeg( 1 );

        CleanupStack::PushL( attachments );

        }

    else if ( ! ( capa.iFlags & TSendingCapabilities::ESupportsBodyText ) )