/*

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

#include <logview.h>

#include <logwraplimits.h>

#include "logsreaderstates.h"

#include "logsstatebasecontext.h"

#include "logsevent.h"

#include "logseventdata.h"

#include "logsengdefs.h"

#include "logslogger.h"

#include "logsreaderobserver.h"

#include "logscommondata.h"

// CONSTANTS

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

// LogsReaderStateBase::LogsReaderStateBase

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

//

LogsReaderStateBase::LogsReaderStateBase(

    LogsStateBaseContext& context, LogsReaderStateContext& readerContext) 

 : LogsStateBase(context),

   mContext(readerContext)

{

}

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

// LogsReaderStateBase::~LogsReaderStateBase

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

//

LogsReaderStateBase::~LogsReaderStateBase()

{

}

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

// LogsReaderStateBase::updateAndInsertEventL

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

//

bool LogsReaderStateBase::updateAndInsertEventL(

    const CLogEvent& source, LogsEvent* dest, int& eventIndex)

{

    Q_ASSERT( dest );

    dest->initializeEventL( source, mContext.strings() );

    mContext.events().insert(eventIndex, dest);

    eventIndex++;

    return true;

}

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

// LogsReaderStateBase::constructAndInsertEventL

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

//

bool LogsReaderStateBase::constructAndInsertEventL(

    const CLogEvent& source, LogsEvent* dest, int& eventIndex, QList<LogsEvent*>& events)

{

    Q_ASSERT( dest );

    dest->initializeEventL( source, mContext.strings() );

    if ( !dest->validate() ){

        LOGS_QDEBUG( "LogsReaderStateBase::constructAndInsertEventL, event discarded" )

        delete dest;

        return false;

    } 

    events.insert(eventIndex, dest);

    eventIndex++;

    return true;

}

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

// LogsReaderStateBase::resetEvents

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

//

void LogsReaderStateBase::resetEvents()

{

    QList<LogsEvent*> &events = mContext.events();

    for ( int i = 0; i < events.count(); i++ ){

        events.at(i)->setIsInView(false);

    }

}

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

// LogsReaderStateBase::takeMatchingEvent

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

//

LogsEvent* LogsReaderStateBase::takeMatchingEvent(const CLogEvent& event)

{

    QList<LogsEvent*> &events = mContext.events();

    for ( int i = 0; i < events.count(); i++ ){

        if ( events.at(i)->logId() == event.Id() ){

            return events.takeAt(i);

        }

    }

    return 0;

}

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

// LogsReaderStateBase::eventById

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

//

LogsEvent* LogsReaderStateBase::eventById(int eventId)

{

    LogsEvent* event = 0;

    QList<LogsEvent*> &events = mContext.events();

    for ( int i = 0; i < events.count() && !event; i++ ){

        if ( events.at(i)->logId() == eventId ){

            event = events.at(i);

        }

    }

    return event;

}

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

// LogsReaderStateInitReading::LogsReaderStateInitReading

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

//

LogsReaderStateInitReading::LogsReaderStateInitReading(

    LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) 

 : LogsReaderStateBase(context, readerContext)

{

}

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

// LogsReaderInitReadingState::enterL

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

//

bool LogsReaderStateInitReading::enterL()

{

    LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateInitReading::enterL" );

    resetEvents();

    return enterNextStateL();

}

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

// LogsReaderStateFiltering::LogsReaderStateFiltering

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

//

LogsReaderStateFiltering::LogsReaderStateFiltering(

    LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) 

 : LogsReaderStateBase(context, readerContext),

   mFilterList(0)

{

}

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

// LogsReaderStateFiltering::~LogsReaderStateFiltering

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

//

LogsReaderStateFiltering::~LogsReaderStateFiltering()

{

    if ( mFilterList ){

        mFilterList->ResetAndDestroy();

    }

    delete mFilterList;

}

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

// LogsReaderStateFiltering::enterL

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

//

bool LogsReaderStateFiltering::enterL()

{

    // Filtering all recent calls (max number of recent events is configurable,

    // see TLogConfig in logcli.h

    //

    LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateFiltering::enterL" );

    CLogFilterList* filterList = new ( ELeave ) CLogFilterList;

    CleanupStack::PushL(filterList);

    CLogFilter* filter = CLogFilter::NewL();

    CleanupStack::PushL( filter );

    filter->SetEventType( KLogCallEventTypeUid );

    filterList->AppendL( filter );

    CleanupStack::Pop( filter );

    if ( mFilterList ){

        mFilterList->ResetAndDestroy();

        delete mFilterList;

        mFilterList = 0;

    }

    mFilterList = filterList;

    CleanupStack::Pop(filterList);

    if ( setFilterL( *filterList ) ) {

        return true;

    }

    // Not possible to continue with filtering

    return enterNextStateL();

}

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

// LogsReaderStateFiltering::continueL

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

//

bool LogsReaderStateFiltering::continueL()

{

    return enterNextStateL();

}

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

// LogsReaderStateFiltering::setFilterL

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

//

bool LogsReaderStateFiltering::setFilterL(CLogFilterList& filterList){

    __ASSERT_ALWAYS( mBaseContext.isRecentView(), User::Leave( KErrNotFound ) );

    return static_cast<CLogViewRecent&>( mBaseContext.logView() ).SetRecentListL( 

            KLogNullRecentList, filterList, mBaseContext.reqStatus() );

}

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

// LogsReaderStateFiltering::LogsReaderStateFiltering

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

//

LogsReaderStateFilteringAll::LogsReaderStateFilteringAll(

    LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) 

 : LogsReaderStateFiltering(context, readerContext)

{

}

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

// LogsReaderStateFilteringAll::~LogsReaderStateFilteringAll

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

//

LogsReaderStateFilteringAll::~LogsReaderStateFilteringAll()

{

}

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

// LogsReaderStateFilteringAll::setFilterL

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

//

bool LogsReaderStateFilteringAll::setFilterL(CLogFilterList& filterList){

    __ASSERT_ALWAYS( !mBaseContext.isRecentView(), User::Leave( KErrNotFound ) );

    return static_cast<CLogViewEvent&>( mBaseContext.logView() ).SetFilterL( 

            filterList, mBaseContext.reqStatus() );

}

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

// LogsReaderStateReading::LogsReaderStateReading

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

//

LogsReaderStateReading::LogsReaderStateReading(

    LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) 

 : LogsReaderStateBase(context, readerContext),

   mDuplicateMissedFilter(0),

   mCheckingMissed(false),

   mEventIndex(0),

   mReadSizeCounter(0)

{

}

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

// LogsReaderStateReading::~LogsReaderStateReading

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

//

LogsReaderStateReading::~LogsReaderStateReading()

{

    delete mDuplicateMissedFilter;

}

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

// LogsReaderStateReading::enterL

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

//

bool LogsReaderStateReading::enterL()

{

    mCheckingMissed = false;

    mEventIndex = 0;

    mReadSizeCounter = 0;

    if ( !mDuplicateMissedFilter ){

        // Interested only about duplicates which are not marked as read

        mDuplicateMissedFilter = CLogFilter::NewL();

        mDuplicateMissedFilter->SetFlags(KLogEventRead);

        mDuplicateMissedFilter->SetNullFields(ELogFlagsField);

    }

    if ( viewCountL() > 0 && mBaseContext.logView().FirstL( mBaseContext.reqStatus() ) ){

        return true;

    }

    // Not possible to continue with reading

    return enterNextStateL();  

}

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

// LogsReaderStateReading::continueL

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

//

bool LogsReaderStateReading::continueL()

{

    int& index = mBaseContext.index();  

    QList<LogsEvent*> &events = mContext.events();

    if ( mCheckingMissed ) {

        events.at(mEventIndex-1)->setDuplicates( 

            mBaseContext.duplicatesView().CountL() );

        mCheckingMissed = false;

    } 

    else {

        const CLogEvent& sourceEvent = event();

        LogsEvent* event = takeMatchingEvent(sourceEvent);

        bool inserted = false;

        if ( event ){

            // Matching event is updated and put to new position

            inserted = updateAndInsertEventL( sourceEvent, event, mEventIndex );

        }

        else {

            // Create new entry

            event = new LogsEvent;

            inserted = constructAndInsertEventL( 

                    sourceEvent, event, mEventIndex, mContext.events() );

        }

        if ( inserted  ){

            updateReadSizeCounter(*event);

            if ( handleMissedL(*event) ){

                mCheckingMissed = true;

                return true;

            }

        }

    }

    index++;    

    if ( canContinueReadingL(index) ){

        return mBaseContext.logView().NextL( mBaseContext.reqStatus() );

    }           

    return enterNextStateL();

}

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

// LogsReaderStateReading::handleMissedL

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

//

bool LogsReaderStateReading::handleMissedL(LogsEvent& parsedEvent)

{

    bool handled = false;

    if ( parsedEvent.direction() == LogsEvent::DirMissed ){

        handled = duplicatesL(mDuplicateMissedFilter); 

    }

    return handled;

}

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

// LogsReaderStateReading::updateReadSizeCounter

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

//

void LogsReaderStateReading::updateReadSizeCounter(LogsEvent& event)

{

    if ( LogsCommonData::getInstance().maxReadSize() >= 0 ){

        LogsEvent::LogsDirection dir = 

            LogsCommonData::getInstance().maxReadSizeDirection();

        if ( dir == LogsEvent::DirUndefined || dir == event.direction() ){

            mReadSizeCounter++;

        }

    }

}

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

// LogsReaderStateReading::canContinueReadingL

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

//

bool LogsReaderStateReading::canContinueReadingL(int index) const

{

    bool canContinue( index < viewCountL() );

    int maxReadSize = LogsCommonData::getInstance().maxReadSize();

    if ( canContinue && maxReadSize >= 0 ){

        canContinue = ( mReadSizeCounter < maxReadSize );

    }

    return canContinue;

}

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

// LogsReaderStateFillDetails::LogsReaderStateFillDetails

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

//

LogsReaderStateFillDetails::LogsReaderStateFillDetails(

    LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) 

 : LogsReaderStateBase(context, readerContext)

{

}

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

// LogsReaderStateFillDetails::~LogsReaderStateFillDetails

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

//

LogsReaderStateFillDetails::~LogsReaderStateFillDetails()

{

}

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

// LogsReaderStateFillDetails::enterL

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

//

bool LogsReaderStateFillDetails::enterL()

{

    LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateFillDetails::enterL()" )

    fillDetails();

    LOGS_QDEBUG( "logs [ENG] <- LogsReaderStateFillDetails::enterL()" )

    return enterNextStateL();

}

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

// LogsReaderStateFillDetails::fillDetails

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

//

void LogsReaderStateFillDetails::fillDetails()

{

    mDuplicateLookup.invalidate();

    QHash<QString, ContactCacheEntry>& contactMappings = mContext.contactCache();

    QList<LogsEvent*> &events = mContext.events();

    foreach ( LogsEvent* event, events ){  

        if ( event->isInView() ){

            const QString& num = event->getNumberForCalling();

            }

            if ( mBaseContext.isRecentView() ){

                LogsEvent* duplicateEvent = mDuplicateLookup.findDuplicate(*event);

                if ( duplicateEvent ){

                    mergeDuplicates( *duplicateEvent, *event ); 

                } else {

                    mDuplicateLookup.addLookupEntry(*event);

                }

            }

        }

    } 

    mDuplicateLookup.cleanup();

}

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

// LogsReaderStateFillDetails::mergeDuplicates

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

//

void LogsReaderStateFillDetails::mergeDuplicates( 

    LogsEvent& usedEvent, LogsEvent& discardedEvent ) const

{

    usedEvent.merge(discardedEvent);

    discardedEvent.setIsInView(false);

}

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

// LogsReaderStateDone::LogsReaderStateDone

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

//

LogsReaderStateDone::LogsReaderStateDone(

    LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) 

 : LogsReaderStateBase(context, readerContext)

{

}

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

// LogsReaderStateDone::~LogsReaderStateDone

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

//

LogsReaderStateDone::~LogsReaderStateDone()

{

}

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

// LogsReaderStateDone::enterL

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