/*

* 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:

*

*/

// INCLUDE FILES

#include <exception>

#include <logview.h>

#include "logsreader.h"

#include "logsreaderobserver.h"

#include "logsevent.h"

#include "logsengdefs.h"

#include "logslogger.h"

// CONSTANTS

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

// LogsReader::LogsReader

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

//

LogsReader::LogsReader(

    RFs& fsSession,

    CLogClient& logClient,

    LogsEventStrings& strings,

    QList<LogsEvent*>& events,

    LogsReaderObserver& observer,

    bool readAllEvents) 

 : LogsWorker(readAllEvents),

   mFsSession(fsSession), 

   mStrings(strings), 

   mEvents(events), 

   mObserver(observer),

   mGlobalObserverSet(false),

   mPendingRead(false)

{

    LOGS_QDEBUG( "logs [ENG] -> LogsReader::LogsReader()" )

    mLogClient = &logClient; 

    initializeReadStates();   

    setGlobalObserver();

    LOGS_QDEBUG( "logs [ENG] <- LogsReader::LogsReader()" )

}

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

// LogsReader::~LogsReader

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

//

LogsReader::~LogsReader()

{

    LOGS_QDEBUG( "logs [ENG] -> LogsReader::~LogsReader()" )

    Cancel();

    qDeleteAll( mReadStates );

    qDeleteAll( mModifyingStates );

    qDeleteAll( mDuplicateReadingStates );

    delete mLogViewRecent;

    mLogViewRecent = 0;

    delete mLogViewEvent;

    mLogViewEvent = 0;

    delete mDuplicatesView;

    mDuplicatesView = 0;

    qDeleteAll( mDuplicatedEvents );

    LOGS_QDEBUG( "logs [ENG] <- LogsReader::~LogsReader()" )

}

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

// LogsReader::start

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

//

int LogsReader::start()

    {

    LOGS_QDEBUG( "logs [ENG] -> LogsReader::start()" )

    TRAPD( err, startL() );

    LOGS_QDEBUG_2( "logs [ENG] <- LogsReader::start(), err:", err )

    return err;

    }

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

// LogsReader::stop

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

//

void LogsReader::stop()

    {

    LOGS_QDEBUG( "logs [ENG] -> LogsReader::stop()" )

    Cancel(); 

    deleteLogViews();

    clearGlobalObserver();

    LOGS_QDEBUG( "logs [ENG] <- LogsReader::stop()" )

    }

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

// LogsReader::updateDetails

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

//

void LogsReader::updateDetails(bool clearCached)

{

    LOGS_QDEBUG( "logs [ENG] -> LogsReader::updateDetails()" )

    start();

    LOGS_QDEBUG( "logs [ENG] <- LogsReader::updateDetails()" )

}

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

// LogsReader::markEventSeen

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

//

int LogsReader::markEventSeen(int eventId)

{

    LOGS_QDEBUG_2( "logs [ENG] -> LogsReader::markEventsSeen(), ids: ", eventId )

    TRAPD( err, markEventSeenL(eventId) );

    LOGS_QDEBUG_2( "logs [ENG] <- LogsReader::markEventsSeen(), err:", err )

    return err;

}

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

// LogsReader::readDuplicates

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

//

int LogsReader::readDuplicates(int eventId)

{

    LOGS_QDEBUG_2( "logs [ENG] -> LogsReader::readDuplicates(), ids: ", eventId )

    TRAPD( err, readDuplicatesL(eventId) );

    LOGS_QDEBUG_2( "logs [ENG] <- LogsReader::readDuplicates(), err:", err )

    return err;

}

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

// LogsReader::lock

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

//

int LogsReader::lock(bool locked)

{

    bool prevLocked = mLocked;

    mLocked = locked;

    LOGS_QDEBUG_3( "logs [ENG] -> LogsReader::lock(), prev and new locked:", 

                   prevLocked, mLocked )

    if ( prevLocked && !mLocked && mPendingRead ){

        // Read attempt occured while locked, read now when not anymore locked

        start();

    }

    return 0;

}

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

// LogsReader::RunError

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

//

TInt LogsReader::RunError(TInt error)

{

    LOGS_QDEBUG_2( "logs [ENG] -> LogsReader::RunError(), err:", error )

    handleError(error);

    LOGS_QDEBUG( "logs [ENG] <- LogsReader::RunError()" )

    return KErrNone;

}

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

// LogsReader::startL

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

//

void LogsReader::startL()

{

    if ( mLocked ){

        LOGS_QDEBUG( "logs [ENG] <-> LogsReader::startL(), locked" )

        mPendingRead = true;

        User::Leave( KErrAccessDenied );

    }

    prepareReadingL();

    initializeReadStates();

    if ( currentState().enterL() ){

        SetActive();

    }

    mPendingRead = false;

} 

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

// LogsReader::markEventSeenL

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

//

void LogsReader::markEventSeenL(int eventId)

{

    prepareReadingL();

    mCurrentEventId = eventId;   

    initializeModifyingStates();

    if ( currentState().enterL() ){

        SetActive();

    }

}

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

// LogsReader::readDuplicatesL

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

//

void LogsReader::readDuplicatesL(int eventId)

{

    if ( IsActive() && mCurrentStateMachine != &mDuplicateReadingStates ){

        LOGS_QDEBUG( "logs [ENG] <-> LogsReader::readDuplicatesL(), cannot interrupt" )

        User::Leave(KErrInUse);

    }

    prepareReadingL();

    mCurrentEventId = eventId;

    initializeDuplicateReadingStates();

    if ( currentState().enterL() ){

        SetActive();

    }

}

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

// LogsReader::cancelCurrentRequestL

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

//

void LogsReader::cancelCurrentRequestL()

{

    LOGS_QDEBUG( "logs [ENG] -> LogsReader::cancelCurrentRequestL()" )

    if ( IsActive() ) {

        if (mCurrentStateMachine == &mReadStates || 

            mCurrentStateMachine == &mDuplicateReadingStates){

            LOGS_QDEBUG( "logs [ENG] reading is in progress, cancelling" )

            Cancel();

        } else if (mCurrentStateMachine == &mModifyingStates) {

            LOGS_QDEBUG( "logs [ENG] <- LogsReader::cancelCurrentRequestL(), modifying is in progress, can't cancel" )

            User::Leave(KErrInUse);

        }

    }

    LOGS_QDEBUG( "logs [ENG] <- LogsReader::cancelCurrentRequestL()" )   

}

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

// LogsReader::HandleLogClientChangeEventL

//

// Called by Log Database engine when it notifies a change in database (e.g.

// Log database cleared)

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

//

void LogsReader::HandleLogClientChangeEventL(

TUid aChangeType,

TInt /*aChangeParam1*/,

TInt /*aChangeParam2*/,

TInt /*aChangeParam3*/ )

{

    LOGS_QDEBUG_2( "logs [ENG] -> LogsReader::HandleLogClientChangeEventL()",

                   aChangeType.iUid )

    if( aChangeType == KLogClientChangeEventLogCleared ){

        handleViewChange();

    }

    LOGS_QDEBUG( "logs [ENG] <- LogsReader::HandleLogClientChangeEventL()" )

}

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

// LogsReader::HandleLogViewChangeEventAddedL

// Called by Log Database engine when it notifies us that it has added

// an event to database

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

//

void LogsReader::HandleLogViewChangeEventAddedL( 

TLogId /*aId*/, 

TInt /*aViewIndex*/, 

TInt /*aChangeIndex*/, 

TInt aTotalChangeCount )

{

    LOGS_QDEBUG_2( "logs [ENG] -> LogsReader::HandleLogViewChangeEventAddedL()",

                   aTotalChangeCount )

    //Comment: HandleLogViewChangeEventAddedL seems to be called only once

    // (and aTotalChangeCount is 1) even if  there are multiple entries added

    // to database in a batch. This seems to happen at least in wins emulator

    // in Symbian 80a_200432. If problems in this area or changed behaviour,

    // we need to consider same kind of optimization to here as is in 

    //HandleLogViewChangeEventDeletedL

    handleViewChange(aTotalChangeCount);

    LOGS_QDEBUG( "logs [ENG] <- LogsReader::HandleLogViewChangeEventAddedL()" )

}

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

// LogsReader::HandleLogViewChangeEventChangedL

// Called by Log Database engine when it notifies us that it has

// changed an event in the database

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

//

void LogsReader::HandleLogViewChangeEventChangedL( 

TLogId /*aId*/, 

TInt /*aViewIndex*/, 

TInt /*aChangeIndex*/, 

TInt aTotalChangeCount )

{

    LOGS_QDEBUG_2( "logs [ENG] -> LogsReader::HandleLogViewChangeEventChangedL()",

                   aTotalChangeCount )

    handleViewChange(aTotalChangeCount);

    LOGS_QDEBUG( "logs [ENG] <- LogsReader::HandleLogViewChangeEventChangedL()" )

}

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

// LogsReader::HandleLogViewChangeEventDeletedL

// Called by Log Database engine when it notifies us that it has deleted

// an event in the database

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

//

void LogsReader::HandleLogViewChangeEventDeletedL( 

TLogId /*aId*/, 

TInt /*aViewIndex*/, 

TInt aChangeIndex, 

TInt aTotalChangeCount )

{

    LOGS_QDEBUG_2( "logs [ENG] -> LogsReader::HandleLogViewChangeEventDeletedL()",

                   aTotalChangeCount )

LOGS_QDEBUG_2( "logs [ENG] -> LogsReader::HandleLogViewChangeEventDeletedL() aChangeIndex=",

        aChangeIndex )

    // In order to prevent to re-reading the database multiple times, we call

    // HandleViewChangeL only once. This is because HandleLogViewChangeEventDeletedL

    // is called as many times as is the number of entries are deleted e.g. when 

    // deleteting old entries from database happens. However, aTotalChangeCount contains

    // total number of deletions in a batch, so we can optimize the call to

    // HandleViewChangeL to happen only even if we're called multiple times.

    // Value of aChangeIndex is increasing from 0 to ( aTotalChangeCount - 1 ).

    // we call HandleViewChangeL when the last notify has arrived.

if ( aChangeIndex == ( aTotalChangeCount - 1 ) ) 

    {

    LOGS_QDEBUG( "logs [ENG] <- LogsReader::HandleLogViewChangeEventDeletedL() handleViewChange" )

       handleViewChange(aTotalChangeCount);

   }               

    LOGS_QDEBUG( "logs [ENG] <- LogsReader::HandleLogViewChangeEventDeletedL()" )

}

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

// LogsReader::events

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

//

QList<LogsEvent*>& LogsReader::events()

{

    return mEvents;

}

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

// LogsReader::strings

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

//

LogsEventStrings& LogsReader::strings()

{

    return mStrings;

}

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

// LogsReader::observer

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

//

LogsReaderObserver& LogsReader::observer()

{

    return mObserver;

}

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

// LogsReader::contactCache

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

//

QHash<QString, ContactCacheEntry>& LogsReader::contactCache()

{

    return mContactCache;

}

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

// LogsReader::duplicatedEvents

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

//

QList<LogsEvent*>& LogsReader::duplicatedEvents()

{

    return mDuplicatedEvents;

}

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

// LogsReader::initializeReadStates

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

//

void LogsReader::initializeReadStates()

{

    if ( mReadStates.count() == 0 ){

        LogsReaderStateInitReading* init = new LogsReaderStateInitReading(*this, *this);

        LogsReaderStateFiltering* filtering = createFilteringState();

        LogsReaderStateReading* reading = new LogsReaderStateReading(*this, *this);

        LogsReaderStateFillDetails* fillDetails = new LogsReaderStateFillDetails(*this, *this);

        LogsReaderStateDone* done = new LogsReaderStateDone(*this, *this);

        init->setNextState(*filtering);

        filtering->setNextState(*reading);

        reading->setNextState(*fillDetails);

        fillDetails->setNextState(*done);

        mReadStates.append(init);

        mReadStates.append(filtering);

        mReadStates.append(reading);

        mReadStates.append(fillDetails);

        mReadStates.append(done);

    }

    mCurrentStateMachine = &mReadStates;

    setCurrentState(*mReadStates.at(0));

}

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

// LogsReader::initializeDuplicateReadingStates

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

//

void LogsReader::initializeDuplicateReadingStates()

{

    if ( mDuplicateReadingStates.count() == 0 ){

        LogsReaderStateFiltering* filtering = createFilteringState();

        LogsStateSearchingEvent* searching = 

                    new LogsStateSearchingEvent(*this);

        LogsReaderStateFindingDuplicates* findingDuplicates = 

                    new LogsReaderStateFindingDuplicates(*this, *this);

        LogsReaderStateReadingDuplicates* readingDuplicates = 

                    new LogsReaderStateReadingDuplicates(*this, *this);

        LogsReaderStateMergingDuplicates* mergingDuplicates = 

                            new LogsReaderStateMergingDuplicates(*this, *this);

        LogsReaderStateReadingDuplicatesDone* done = 

                    new LogsReaderStateReadingDuplicatesDone(*this, *this);

        filtering->setNextState(*searching);

        searching->setNextState(*findingDuplicates);

        findingDuplicates->setNextState(*readingDuplicates);

        readingDuplicates->setNextState(*mergingDuplicates);

        mergingDuplicates->setNextState(*done);

        mDuplicateReadingStates.append(filtering);

        mDuplicateReadingStates.append(searching); 

        mDuplicateReadingStates.append(findingDuplicates); 

        mDuplicateReadingStates.append(readingDuplicates);

        mDuplicateReadingStates.append(mergingDuplicates);

        mDuplicateReadingStates.append(done);        

    }

    mCurrentStateMachine = &mDuplicateReadingStates;

    setCurrentState(*mDuplicateReadingStates.at(0)); 

}

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

// LogsReader::initializeModifyingStates

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

//

void LogsReader::initializeModifyingStates()

{

    if ( mModifyingStates.count() == 0 ){

        LogsReaderStateFiltering* filtering = createFilteringState();

        LogsStateSearchingEvent* searching = 

                    new LogsStateSearchingEvent(*this);

        LogsReaderStateMarkingDuplicates* duplicates = 

                    new LogsReaderStateMarkingDuplicates(*this, *this);

        LogsReaderStateModifyingDone* done = new LogsReaderStateModifyingDone(*this, *this);

        filtering->setNextState(*searching);

        searching->setNextState(*duplicates);

        duplicates->setNextState(*done);

        mModifyingStates.append(filtering);

        mModifyingStates.append(searching); 

        mModifyingStates.append(duplicates);

        mModifyingStates.append(done);        

    }

    mCurrentStateMachine = &mModifyingStates;

    setCurrentState(*mModifyingStates.at(0)); 

}

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

// LogsReader::handleViewChange

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

//

void LogsReader::handleViewChange(int totalChangeCount)

{

    //we do not update view untill deletion is done

    if ( totalChangeCount > 0 ){

        int err = start();

        handleError( err );

    } 

}

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

// LogsReader::handleError

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

//

void LogsReader::handleError(int error)

{

    if ( error == KErrAccessDenied || error == KErrInUse ){

        LOGS_QDEBUG( "logs [ENG] <-> LogsReader::handleError(), temp err" )

        mObserver.temporaryErrorOccurred(error); 

    } else if ( error != 0 ){