/*

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

*

*/

#ifndef LOGSREADERSTATES_H

#define LOGSREADERSTATES_H

//  INCLUDES

#include <e32std.h>

#include <logclientchangeobserver.h>

#include <logviewchangeobserver.h>

// FORWARD DECLARATION

class LogsReaderStateContext;

class LogsEvent;

class CLogViewEvent;

class CLogFilterList;

class CLogFilter;

class CLogEvent;

// CLASS DECLARATION

/**

 * Reader state base

 */

class LogsReaderStateBase {

    friend class UT_LogsReaderStates;

    friend class UT_LogsReader;

    public:

        /**

         * Destructor

         */

        virtual ~LogsReaderStateBase();

        /**

         * Set next state to be used once this state has completed.

         * @param nextState

         */

        void setNextState(LogsReaderStateBase& nextState);

        /**

         * Enter to the state, may proceed immediately to next state.

         * @return true if entering started async operation,  false if not

         */

        virtual bool enterL();

        /**

         * Continue running in the state, may proceed to next state

         * @return true if continue started async operation,  false if not

         */

        virtual bool continueL();

    protected:

        /**

         * Constructor

         */

        LogsReaderStateBase(LogsReaderStateContext& context);

        /**

         * Proceed to next state if such exists.

         * @return true if entering started async operation,  false if not 

         */

        virtual bool enterNextStateL();

        /**

         * Get number of events in view

         * @return view count

         */

        int viewCountL() const;

        /**

         * Get current event

         * @return event

         */

        CLogEvent& event() const;

        /**

         * Fill dest event with source event data and insert to specified

         * place in events list.

         * @param source event 

         * @param dest event, ownership is transferred

         * @param index, increased if event was added

         * @param events, event is possibly added to this list

         * @return true if dest event was inserted, false if discarded and deleted

         */

        bool constructAndInsertEventL(

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

        /**

         * Fill already used dest event with source event data and insert

         * to specified place in events list.

         * @param source event 

         * @param dest event, ownership is transferred

         * @param index, increased if event was added

         * @return true if dest event was inserted, false if discarded and deleted

         */

        bool updateAndInsertEventL(

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

        /**

         * Reset current events

         */

        void resetEvents();

        /**

         * Try to find matching event and remove it from

         * events list.

         * @param event, symbian log event

         * @return LogsEvent or 0 if no matching found, ownership is transferred

         */

        LogsEvent* takeMatchingEvent(const CLogEvent& event);

        /**

         * Finds specified event from the event list. Event not removed from the list.

         * @param eventId, id of the event to be found

         * @return pointer to event or 0 if not found

         */

        LogsEvent* eventById(int eventId);

        /**

         * Try to search duplicates for current event in the view

         * @param aFilter, filter to be used for searching duplicates

         * @return true, if duplicates are searched

         */

        bool duplicatesL(const CLogFilter* aFilter = 0);

    protected:   

        LogsReaderStateContext& mContext;

        LogsReaderStateBase* mNextState;

        int mStateIndex;

};

/**

 * Initialize reading state

 */

class LogsReaderStateInitReading : public LogsReaderStateBase {

     friend class UT_LogsReaderStates;

    public:

     LogsReaderStateInitReading(LogsReaderStateContext& context);

        virtual ~LogsReaderStateInitReading(){}

    public: // From LogsReaderStateBase

        virtual bool enterL();

 };

/**

 * Filtering recent state

 */

class LogsReaderStateFiltering : public LogsReaderStateBase {

     friend class UT_LogsReaderStates;

    public:

        LogsReaderStateFiltering(LogsReaderStateContext& context);

        virtual ~LogsReaderStateFiltering();

    public: // From LogsReaderStateBase

        virtual bool enterL();

        virtual bool continueL();

    protected:

        /**

         * Setting filter for view, derived class may add special filtering

         * at this stage.

         */

        virtual bool setFilterL(CLogFilterList& filterList);

    protected:

        CLogFilterList* mFilterList;

 };

/**

 * Filtering all state

 */

class LogsReaderStateFilteringAll : public LogsReaderStateFiltering {

     friend class UT_LogsReaderStates;

    public:

        LogsReaderStateFilteringAll(LogsReaderStateContext& context);

        virtual ~LogsReaderStateFilteringAll();

    protected: // From LogsReaderStateFiltering

        virtual bool setFilterL(CLogFilterList& filterList);

 };

/**

 * Reading state

 */

class LogsReaderStateReading : public LogsReaderStateBase {

    friend class UT_LogsReaderStates;

    public:

        LogsReaderStateReading(LogsReaderStateContext& context);

        virtual ~LogsReaderStateReading();

    public: // From LogsReaderStateBase

        virtual bool enterL();

        virtual bool continueL();

    protected:

        bool handleMissedL(LogsEvent& parsedEvent);

        void updateReadSizeCounter(LogsEvent& event);

        bool canContinueReadingL(int index) const;     

    protected:

        CLogFilter* mDuplicateMissedFilter;

        bool mCheckingMissed;

        int mEventIndex;

        int mReadSizeCounter;

};

/**

 * Fill missing information state

 */

class LogsReaderStateFillDetails : public LogsReaderStateBase {

    public:

        LogsReaderStateFillDetails(LogsReaderStateContext& context);

        virtual ~LogsReaderStateFillDetails();

        /**

         * Synchronously fills details from phonebook

         */

        void fillDetails(); 

    public: // From LogsReaderStateBase

        virtual bool enterL();

};

/**

 * Completed state

 */

class LogsReaderStateDone : public LogsReaderStateBase {

    public:

        LogsReaderStateDone(LogsReaderStateContext& context);

        virtual ~LogsReaderStateDone();

    public: // From LogsReaderStateBase

        virtual bool enterL();

};

/**

 * Searching event state

 */

class LogsReaderStateSearchingEvent : public LogsReaderStateBase 

{

    friend class UT_LogsReaderStates;

    public:

        LogsReaderStateSearchingEvent(LogsReaderStateContext& context);

        virtual ~LogsReaderStateSearchingEvent(){}

    public: // From LogsReaderStateBase

        virtual bool enterL();

        virtual bool continueL();

};

/**

 * Finding duplicate events state

 */

class LogsReaderStateFindingDuplicates : public LogsReaderStateBase 

{

    friend class UT_LogsReaderStates;

    public:

        LogsReaderStateFindingDuplicates(LogsReaderStateContext& context);

        virtual ~LogsReaderStateFindingDuplicates();

    public: // From LogsReaderStateBase

        virtual bool enterL();  

        virtual bool continueL();

    protected:

        CLogFilter* mDuplicateFilter;

};

/**

 * Marking duplicate events state

 */

class LogsReaderStateMarkingDuplicates : public LogsReaderStateBase 

{

    friend class UT_LogsReaderStates;

    public:

        LogsReaderStateMarkingDuplicates(LogsReaderStateContext& context);

        virtual ~LogsReaderStateMarkingDuplicates(){}

    public: // From LogsReaderStateBase

        virtual bool enterL();

        virtual bool continueL(); 

    protected:

        bool mGettingDuplicates;

};

/**

 * Marking duplicate events state

 */

class LogsReaderStateReadingDuplicates : public LogsReaderStateBase 

{

    friend class UT_LogsReaderStates;

    public:

        LogsReaderStateReadingDuplicates(LogsReaderStateContext& context);

        virtual ~LogsReaderStateReadingDuplicates(){}

    public: // From LogsReaderStateBase

        virtual bool enterL();   

        virtual bool continueL();

};

/**

 * Modifying done state

 */

class LogsReaderStateModifyingDone : public LogsReaderStateBase 

{

    friend class UT_LogsReaderStates;

    public:

        LogsReaderStateModifyingDone(LogsReaderStateContext& context);

        virtual ~LogsReaderStateModifyingDone(){}

    public: // From LogsReaderStateBase

        virtual bool enterL();

};

/**

 * Reading duplicates done state

 */

class LogsReaderStateReadingDuplicatesDone : public LogsReaderStateBase 

{

    friend class UT_LogsReaderStates;

    public:

        LogsReaderStateReadingDuplicatesDone(LogsReaderStateContext& context);

        virtual ~LogsReaderStateReadingDuplicatesDone(){}

    public: // From LogsReaderStateBase

        virtual bool enterL();

};

#endif      // LOGSREADERSTATES_H

// End of File