/*

* Copyright (c) 2010 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: 

*

*/

#include <cntdef.h>

#include "engine.h"

#include "enginewrapper.h"

#include "creator_log.h" 

#include "creator_traces.h"

static const TInt KLogsFieldLength = 256;

//_LIT(KCreatorLogsPrefixName, "CR_");

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

CLogsParameters::CLogsParameters()

    {

    LOGSTRING("Creator: CLogsParameters::CLogsParameters");

    iPhoneNumber = HBufC::New(KLogsFieldLength);

    /*iMissedCallPhoneNumber = HBufC::New(KLogsFieldLength);

    iReceivedCallPhoneNumber = HBufC::New(KLogsFieldLength);

    iDialledNumberPhoneNumber = HBufC::New(KLogsFieldLength);*/

    }

CLogsParameters::~CLogsParameters()

    {

    LOGSTRING("Creator: CLogsParameters::~CLogsParameters");

    delete iPhoneNumber;

    /*delete iDialledNumberPhoneNumber;

    delete iReceivedCallPhoneNumber;

    delete iMissedCallPhoneNumber;*/

    }

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

CCreatorLogs* CCreatorLogs::NewL(CCreatorEngine* aEngine)

    {

    CCreatorLogs* self = CCreatorLogs::NewLC(aEngine);

    CleanupStack::Pop(self);

    return self;

    }

CCreatorLogs* CCreatorLogs::NewLC(CCreatorEngine* aEngine)

    {

    CCreatorLogs* self = new (ELeave) CCreatorLogs;

    CleanupStack::PushL(self);

    self->ConstructL(aEngine);

    return self;

    }

CCreatorLogs::CCreatorLogs() : CActive(0)

    {

    iEntriesToBeCreated = 1;

    }

void CCreatorLogs::ConstructL(CCreatorEngine* aEngine)

    {

    LOGSTRING("Creator: CCreatorLogs::ConstructL");

    iEngine = aEngine;

    iLogClient = CLogClient::NewL(CEikonEnv::Static()->FsSession());

    iLogEvent = CLogEvent::NewL();

	CActiveScheduler::Add(this); // needed by CActive

    }

CCreatorLogs::~CCreatorLogs()

    {

    LOGSTRING("Creator: CCreatorLogs::~CCreatorLogs");

    Cancel(); //from CActive

    if ( iEngine && iEntryIds.Count() )

        {

        TRAP_IGNORE( iEngine->WriteEntryIdsToStoreL( iEntryIds, KUidDictionaryUidLogs ) );

        }

    iEntryIds.Reset();

    iEntryIds.Close();

    delete iLogEvent;

    delete iLogClient;

    if (iParameters)

        delete iParameters;

    }

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

void CCreatorLogs::QueryDialogClosedL(TBool aPositiveAction, TInt aUserData)

    {

    LOGSTRING("Creator: CCreatorModuleBase::QueryDialogClosedL");

    if( aPositiveAction == EFalse )

        {

        iEngine->ShutDownEnginesL();

        return;

        }

    const TDesC* showText = &KSavingText;

    TBool finished(EFalse);

    TBool retval(ETrue);

    switch(aUserData)

        {

        case ECreatorLogsDelete:

            showText = &KDeletingText;

            iEntriesToBeCreated = 1;

            finished = ETrue;

            break;

        case ECreatorLogsStart:

            finished = ETrue;

            break;

        default:

            //some error

            retval = EFalse;

            break;

        }

    if( retval == EFalse )

        {

        iEngine->ShutDownEnginesL();

        }

    else if( finished )

        {

        // add this command to command array

        iEngine->AppendToCommandArrayL(iCommand, NULL, iEntriesToBeCreated);

        // started exucuting commands

        iEngine->ExecuteFirstCommandL( *showText );

        }

    }

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

TBool CCreatorLogs::AskDataFromUserL(TInt aCommand)

    {

    LOGSTRING("Creator: CCreatorLogs::AskDataFromUserL");

    iCommand = aCommand;

    if ( aCommand == ECmdDeleteLogs )

        {

        return iEngine->GetEngineWrapper()->YesNoQueryDialog( _L("Delete all log entries?"), this, ECreatorLogsDelete );

        }

    else if ( aCommand ==  ECmdDeleteCreatorLogs )

        {

        return iEngine->GetEngineWrapper()->YesNoQueryDialog( _L("Delete all log entries created with Creator?"), this, ECreatorLogsDelete );

        }

    return iEngine->GetEngineWrapper()->EntriesQueryDialog( &iEntriesToBeCreated, _L("How many entries to create?"), EFalse, this, ECreatorLogsStart );

    }

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

void CCreatorLogs::RunL()

	{

    LOGSTRING("Creator: CCreatorLogs::RunL");

    // log writing finished, stop the async waiting

    iLogWriteWait.AsyncStop();

    }

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

void CCreatorLogs::DoCancel()

	{

    }

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

TInt CCreatorLogs::CreateMissedCallEntryL(CLogsParameters *aParameters)

    {

    LOGSTRING("Creator: CCreatorLogs::CreateMissedCallEntryL");

    // clear any existing parameter definations

    delete iParameters;

    iParameters = NULL;

    CLogsParameters* parameters = aParameters;

    // random data needed if no predefined data available

    if (!parameters)

        {

        iParameters = new(ELeave) CLogsParameters;

        parameters = iParameters;

        /*iParameters->iMissedCallPhoneNumber->Des().Zero();

        iParameters->iMissedCallPhoneNumber->Des().AppendNum( iEngine->RandomNumber(1000000, 9999999) );

        iParameters->iMissedCallEventTime.UniversalTime();

        iParameters->iMissedCallEventTime -= TTimeIntervalMinutes( iEngine->RandomNumber(12000) );*/

        parameters->iPhoneNumber->Des().Zero();

        parameters->iPhoneNumber->Des().AppendNum( iEngine->RandomNumber(1000000, 9999999) );

        parameters->iEventTime.UniversalTime();

        parameters->iEventTime -= TTimeIntervalMinutes( iEngine->RandomNumber(12000) );

        }

    // defaults

    iLogEvent->SetId( KLogNullId );

    iLogEvent->SetEventType( KNullUid );

    iLogEvent->SetRemoteParty( KNullDesC );

    iLogEvent->SetDirection( KNullDesC );

    iLogEvent->SetTime( Time::NullTTime() );

    iLogEvent->SetDurationType( KLogNullDurationType );

    iLogEvent->SetDuration( KLogNullDuration );

    iLogEvent->SetStatus( KNullDesC );

    iLogEvent->SetSubject( KNullDesC );

    iLogEvent->SetNumber( KNullDesC );

    iLogEvent->SetContact( KNullContactId );

    iLogEvent->SetLink( KLogNullLink );

    iLogEvent->SetDescription( KNullDesC );

    iLogEvent->SetFlags( KLogNullFlags );

    iLogEvent->SetEventType(KLogCallEventTypeUid);

    iLogEvent->SetSubject(_L("A"));

    // set direction

    TLogString missed;

    iLogClient->GetString(missed, R_LOG_DIR_MISSED);

    iLogEvent->SetDirection(missed);

    // set duration

    iLogEvent->SetDurationType( KLogDurationNone );

    TLogDuration duration = 0;

    iLogEvent->SetDuration(duration);

    // set the phone number

    //iLogEvent->SetNumber( iParameters->iMissedCallPhoneNumber->Des() );

    iLogEvent->SetNumber( parameters->iPhoneNumber->Des() );

    // set event time

    //iLogEvent->SetTime( iParameters->iMissedCallEventTime );

    iLogEvent->SetTime( parameters->iEventTime );

    // start writing

    __ASSERT_ALWAYS(!IsActive(), User::Panic(_L("LogWriter"), 150));

	iLogClient->AddEvent(*iLogEvent, iStatus);

	SetActive();

    // wait till adding has finished

    iLogWriteWait.Start();

    // id has been generated, store it for being able to delete

    // entries created only with Creator

    return iStatus.Int();  // should be KErrNone if writing was succesful

    }

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

TInt CCreatorLogs::CreateReceivedCallEntryL(CLogsParameters *aParameters)

    {

    LOGSTRING("Creator: CCreatorLogs::CreateReceivedCallEntryL");

    // clear any existing parameter definations

    delete iParameters;

    iParameters = NULL;

    CLogsParameters* parameters = aParameters;

    // random data needed if no predefined data available

    if (!parameters)

        {

        iParameters = new(ELeave) CLogsParameters;

        parameters = iParameters;

        /*iParameters->iReceivedCallPhoneNumber->Des().Zero();

        iParameters->iReceivedCallPhoneNumber->Des().AppendNum( iEngine->RandomNumber(1000000, 9999999) );

        iParameters->iReceivedCallEventTime.UniversalTime();

        iParameters->iReceivedCallEventTime -= TTimeIntervalMinutes( iEngine->RandomNumber(12000) );

        iParameters->iReceivedCallDuration = iEngine->RandomNumber(7200);*/

        parameters->iPhoneNumber->Des().Zero();

        parameters->iPhoneNumber->Des().AppendNum( iEngine->RandomNumber(1000000, 9999999) );

        parameters->iEventTime.UniversalTime();

        parameters->iEventTime -= TTimeIntervalMinutes( iEngine->RandomNumber(12000) );

        parameters->iDuration = iEngine->RandomNumber(7200);

        }

    // defaults

    iLogEvent->SetId( KLogNullId );

    iLogEvent->SetEventType( KNullUid );

    iLogEvent->SetRemoteParty( KNullDesC );

    iLogEvent->SetDirection( KNullDesC );

    iLogEvent->SetTime( Time::NullTTime() );

    iLogEvent->SetDurationType( KLogNullDurationType );

    iLogEvent->SetDuration( KLogNullDuration );

    iLogEvent->SetStatus( KNullDesC );

    iLogEvent->SetSubject( KNullDesC );

    iLogEvent->SetNumber( KNullDesC );

    iLogEvent->SetContact( KNullContactId );

    iLogEvent->SetLink( KLogNullLink );

    iLogEvent->SetDescription( KNullDesC );

    iLogEvent->SetFlags( KLogNullFlags );

    iLogEvent->SetEventType(KLogCallEventTypeUid);

    iLogEvent->SetSubject(_L("A"));

    // set direction

    TLogString incoming;

    iLogClient->GetString(incoming, R_LOG_DIR_IN);

    iLogEvent->SetDirection(incoming);

    // set duration

    iLogEvent->SetDurationType( KLogDurationValid );

    //iLogEvent->SetDuration( iParameters->iReceivedCallDuration );

    iLogEvent->SetDuration( parameters->iDuration );

    // set the phone number

    //iLogEvent->SetNumber( iParameters->iReceivedCallPhoneNumber->Des() );

    iLogEvent->SetNumber( parameters->iPhoneNumber->Des() );

    // set event time

    //iLogEvent->SetTime( iParameters->iReceivedCallEventTime );

    iLogEvent->SetTime( parameters->iEventTime );

    // start writing

    __ASSERT_ALWAYS(!IsActive(), User::Panic(_L("LogWriter"), 151));

	iLogClient->AddEvent(*iLogEvent, iStatus);

	SetActive();

    // wait till adding has finished

    iLogWriteWait.Start();

    // id has been generated, store it for being able to delete

    // entries created only with Creator

    return iStatus.Int();  // should be KErrNone if writing was succesful

    }

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

TInt CCreatorLogs::CreateDialledNumberEntryL(CLogsParameters *aParameters)

    {

    LOGSTRING("Creator: CCreatorLogs::CreateDialledNumberEntryL");

    // clear any existing parameter definations

    delete iParameters;

    iParameters = NULL;

    CLogsParameters* parameters = aParameters; 

    // random data needed if no predefined data available

    if (!parameters)

        {

        iParameters = new(ELeave) CLogsParameters;

        parameters = iParameters;

        /*iParameters->iDialledNumberPhoneNumber->Des().Zero();

        iParameters->iDialledNumberPhoneNumber->Des().AppendNum( iEngine->RandomNumber(1000000, 9999999) );

        iParameters->iDialledNumberEventTime.UniversalTime();

        iParameters->iDialledNumberEventTime -= TTimeIntervalMinutes( iEngine->RandomNumber(12000) );

        iParameters->iDialledNumberDuration = iEngine->RandomNumber(7200);*/

        parameters->iPhoneNumber->Des().Zero();

        parameters->iPhoneNumber->Des().AppendNum( iEngine->RandomNumber(1000000, 9999999) );

        parameters->iEventTime.UniversalTime();

        parameters->iEventTime -= TTimeIntervalMinutes( iEngine->RandomNumber(12000) );

        parameters->iDuration = iEngine->RandomNumber(7200);

        }

    // defaults

    iLogEvent->SetId( KLogNullId );

    iLogEvent->SetEventType( KNullUid );

    iLogEvent->SetRemoteParty( KNullDesC );

    iLogEvent->SetDirection( KNullDesC );

    iLogEvent->SetTime( Time::NullTTime() );

    iLogEvent->SetDurationType( KLogNullDurationType );

    iLogEvent->SetDuration( KLogNullDuration );

    iLogEvent->SetStatus( KNullDesC );

    iLogEvent->SetSubject( KNullDesC );

    iLogEvent->SetNumber( KNullDesC );

    iLogEvent->SetContact( KNullContactId );

    iLogEvent->SetLink( KLogNullLink );

    iLogEvent->SetDescription( KNullDesC );

    iLogEvent->SetFlags( KLogNullFlags );

    iLogEvent->SetEventType(KLogCallEventTypeUid);

    iLogEvent->SetSubject(_L("A"));

    // set direction

    TLogString outgoing;

    iLogClient->GetString(outgoing, R_LOG_DIR_OUT);

    iLogEvent->SetDirection(outgoing);

    // set duration

    iLogEvent->SetDurationType( KLogDurationValid );

    //iLogEvent->SetDuration( iParameters->iDialledNumberDuration );

    iLogEvent->SetDuration( parameters->iDuration );

    // set the phone number

    //iLogEvent->SetNumber( iParameters->iDialledNumberPhoneNumber->Des() );

    iLogEvent->SetNumber( parameters->iPhoneNumber->Des() );

    // set event time

    //iLogEvent->SetTime( iParameters->iDialledNumberEventTime );

    iLogEvent->SetTime( parameters->iEventTime );

    // start writing

    __ASSERT_ALWAYS(!IsActive(), User::Panic(_L("LogWriter"), 152));

	iLogClient->AddEvent(*iLogEvent, iStatus);

	SetActive();

    // wait till adding has finished

    iLogWriteWait.Start();

    // id has been generated, store it for being able to delete

    // only entries created with Creator

    return iStatus.Int();  // should be KErrNone if writing was succesful

    }

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

void CCreatorLogs::DeleteAllL()

    {

    LOGSTRING("Creator: CCreatorLogs::DeleteAllL");

    iLogClient->ClearLog( TTime( Time::MaxTTime() ), iStatus ); 

    SetActive();

    // wait till delete has finished

    iLogWriteWait.Start();

    User::LeaveIfError( iStatus.Int() );

    // reset must be done here, because iEntryIds is stored in destructor

    iEntryIds.Reset();

    // all entries deleted, remove the Logs related registry

    iEngine->RemoveStoreL( KUidDictionaryUidLogs );

    }

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

void CCreatorLogs::DeleteAllCreatedByCreatorL()

    {

    LOGSTRING("Creator: CCreatorLogs::DeleteAllCreatedByCreatorL");

    iEntryIds.Reset();

    // fetch ids of entries created by Creator

    iEngine->ReadEntryIdsFromStoreL( iEntryIds, KUidDictionaryUidLogs );

    // delete entries

    for ( TInt i = 0; i < iEntryIds.Count(); i++ )

        {

        // This could be implemented with while loop

        // with additional cancel flag. That would enable 

        // using CancelOp() and cancelling would be bit smoother.

        // With this for loop implementation all entries will be

        // deleted whether or not user cancels during logs operation.

        iLogClient->DeleteEvent( iEntryIds[i], iStatus );

        SetActive();        

        // wait till delete has finished

        iLogWriteWait.Start();

        }

    // reset must be done here, because iEntryIds is stored in destructor

    iEntryIds.Reset();

    // all entries deleted, remove the Logs related registry

    iEngine->RemoveStoreL( KUidDictionaryUidLogs );

    }