/*

* 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 "logsdbconnector.h"

#include "logsevent.h"

#include "logsengdefs.h"

#include "logsreader.h"

#include "logslogger.h"

#include "logsremove.h"

#include "logscommondata.h"

#include <logcli.h>

#include <f32file.h>

#include <QApplication>

// CONSTANTS

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

// LogsDbConnector::LogsDbConnector

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

//

LogsDbConnector::LogsDbConnector( 

    QList<LogsEvent*>& events, bool checkAllEvents, bool resourceControl ) 

: QObject(), 

  mModelEvents( events ), 

  mCheckAllEvents( checkAllEvents ),

  mResourceControl( resourceControl ),

  mLogClient( 0 ), 

  mReader( 0 ),

  mLogsRemove( 0 ),

  mCompressionEnabled(false),

  mFirstReadCompleted(false)

{

    LOGS_QDEBUG( "logs [ENG] <-> LogsDbConnector::LogsDbConnector()" )

    mFsSession = new RFs();

}

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

// LogsDbConnector::~LogsDbConnector

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

//

LogsDbConnector::~LogsDbConnector()

{

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

    delete mReader;

    delete mLogsRemove;

    delete mLogClient;

    if ( mFsSession ){

        mFsSession->Close();

    }

    delete mFsSession;

    qDeleteAll( mEvents );

    qDeleteAll( mDuplicatedEvents );

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

}

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

// LogsDbConnector::init

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

//

int LogsDbConnector::init()

{

    LOGS_QDEBUG( "logs [ENG] -> LogsDbConnector::init()" )

    TRAPD( err, initL() );

    handleTemporaryError(err);

    LOGS_QDEBUG_2( "logs [ENG] <- LogsDbConnector::init(), err:", err )

    return err;

}

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

// LogsDbConnector::start

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

//

int LogsDbConnector::start()

{

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

#ifdef LOGSDBCONNECTOR_SIMULATION

    LOGS_QDEBUG( "logs [ENG]    Simulation enabled" )

    int numEvents = 16;

    QList<int> indexes;

    for ( int i = 0; i < numEvents; i++ ){

        QString number = QString("1223456%1").arg(i);

        LogsEvent* event = new LogsEvent;

        if ( i % 3 == 0 ){

            event->setDirection(LogsEvent::DirMissed);

            number += QString("DirMissed");        

        }

        else if ( i % 2 == 0 ){

            event->setDirection(LogsEvent::DirIn);

            number += QString("DirIn");

        } else {

            event->setDirection(LogsEvent::DirOut);

            number += QString("DirOut");

        }

        event->setNumber(number);

        mEvents.append(event);

        mModelEvents.append(event);

        indexes.append(i);

    }

    emit dataAdded( indexes );

    return 0;

#endif

    if ( !mReader ){

        LOGS_QDEBUG( "logs [ENG]    Not initialized, failure" )

        return -1;

    }

    int err = mReader->start();

    handleTemporaryError(err);

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

    return err;

}

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

// LogsDbConnector::updateDetails

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

//

int LogsDbConnector::updateDetails(bool clearCached)

{

    if ( !mReader ){

        LOGS_QDEBUG( "logs [ENG]    Not initialized, failure" )

        return -1;

    }

    mReader->updateDetails(clearCached);    

    return 0;    

}

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

// LogsDbConnector::stateChanged

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

//

void LogsDbConnector::initL()

{

    if ( mReader ){

        // Already initialized

        return;

    }  

    User::LeaveIfError( mFsSession->Connect() );

    mLogClient = CLogClient::NewL( *mFsSession );

    mLogsRemove = new LogsRemove( *this, mCheckAllEvents );

    TLogString logString;

    //Texts in LOGWRAP.RLS / LOGWRAP.RSS        

    User::LeaveIfError( mLogClient->GetString( logString, R_LOG_DIR_IN ) );

    mLogEventStrings.iInDirection = DESC_TO_QSTRING( logString );

    User::LeaveIfError( mLogClient->GetString( logString, R_LOG_DIR_OUT ) );

    mLogEventStrings.iOutDirection = DESC_TO_QSTRING( logString );

    User::LeaveIfError( mLogClient->GetString( logString, R_LOG_DIR_MISSED ) );

    mLogEventStrings.iMissedDirection = DESC_TO_QSTRING( logString );

    //"Unknown" (Logwrap.rls)

    User::LeaveIfError( mLogClient->GetString( logString, R_LOG_REMOTE_UNKNOWN ) ); 

    mLogEventStrings.iUnKnownRemote = DESC_TO_QSTRING( logString );

    //"Incoming on alternate line"

    User::LeaveIfError( mLogClient->GetString( logString, R_LOG_DIR_IN_ALT ) ); 

    mLogEventStrings.iInDirectionAlt = DESC_TO_QSTRING( logString );

    User::LeaveIfError( mLogClient->GetString( logString, R_LOG_DIR_OUT_ALT ) );

    mLogEventStrings.iOutDirectionAlt = DESC_TO_QSTRING( logString );

    User::LeaveIfError( mLogClient->GetString( logString, R_LOG_DIR_FETCHED) );

    mLogEventStrings.iFetched = DESC_TO_QSTRING( logString );

    mReader = new LogsReader( 

        *mFsSession, *mLogClient, mLogEventStrings, mEvents, *this, mCheckAllEvents );

    if ( mResourceControl ){

        LOGS_QDEBUG( "logs [ENG] -> LogsDbConnector::initL(), resource control enabled" )

        LogsCommonData::getInstance().configureReadSize(

                logsReadSizeCompressEnabled, LogsEvent::DirUndefined);

        mCompressionEnabled = true;

    }

    //Get number of digits used to match   

    int matchLen;

    LogsCommonData::getInstance().getTelNumMatchLen(matchLen);

    LOGS_QDEBUG_2( "logs [ENG]    Tel number match length", matchLen )

}

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

// LogsDbConnector::clearList

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

//

bool LogsDbConnector::clearList(LogsModel::ClearType cleartype)

{

    bool clearingStarted(false);

	if ( mLogsRemove ){

		clearingStarted = mLogsRemove->clearList(cleartype);

	}

	return clearingStarted;

}

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

// LogsDbConnector::clearEvent

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

//

bool LogsDbConnector::clearEvents(const QList<LogsEvent*>& events)

{

    bool asyncClearingStarted(false);

    if ( mLogsRemove ){

        bool async(false);

        int err = mLogsRemove->clearEvents(events, async);

        asyncClearingStarted = ( !err && async );

    } 

    if ( asyncClearingStarted ){

        // Lock reader while removing events one-by-one as reading

        // might have chance to run while removing is still in progress

        // which looks bad at UI layer.

        mReader->lock(true);

    }

    return asyncClearingStarted;

}

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

// LogsDbConnector::markEventsSeen

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

//

bool LogsDbConnector::markEventsSeen(const QList<LogsEvent*>& events)

{

    LOGS_QDEBUG( "logs [ENG] -> LogsDbConnector::markEventsSeen()" )

    if ( !mReader ){

        return false;

    }

    foreach( LogsEvent* ev, events ){

        if ( !mEventsSeen.contains(*ev) ){

            mEventsSeen.append(*ev);

            foreach ( const LogsEvent& mergedEv, ev->mergedDuplicates() ){

                if ( !mEventsSeen.contains(mergedEv) ){

                    mEventsSeen.append(mergedEv);

                }

            }

        }

    }

    int err = doMarkEventSeen();

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

                   err )

    return ( err == 0 );

}

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

// LogsDbConnector::readDuplicates

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

//

int LogsDbConnector::readDuplicates(int eventId)

{

    LOGS_QDEBUG_2( "logs [ENG] -> LogsDbConnector::readDuplicates(), id", eventId )

    if ( !mReader ){

        return -1;

    }

    qDeleteAll(mDuplicatedEvents);

    mDuplicatedEvents.clear();

    return mReader->readDuplicates(eventId);

}

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

// LogsDbConnector::takeDuplicates

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

//

QList<LogsEvent*> LogsDbConnector::takeDuplicates()

{

    LOGS_QDEBUG( "logs [ENG] -> LogsDbConnector::takeDuplicates()" )

    QList<LogsEvent*> duplicates = mDuplicatedEvents;

    mDuplicatedEvents.clear();

    LOGS_QDEBUG( "logs [ENG] <- LogsDbConnector::takeDuplicates()" )

    return duplicates;

} 

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

// Do refresh only if compression has been enabled. Monitoring for database

// changes is restored and current database contents are read.

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

//

int LogsDbConnector::refreshData()

{

    if ( !mResourceControl ){

        return -1;

    }

    LOGS_QDEBUG( "logs [ENG] -> LogsDbConnector::refreshData()" )

    int err = 0;

    bool prevCompressionEnabled = mCompressionEnabled;

    mCompressionEnabled = false;

    LogsCommonData::getInstance().configureReadSize(

        logsReadSizeUndefined, LogsEvent::DirUndefined);

    if ( mReader ){

        if ( prevCompressionEnabled && !mReader->IsActive() ){

            err = mReader->start();

        }

    }

    if ( !mLogsRemove ){

        mLogsRemove = new LogsRemove( *this, mCheckAllEvents );

    }   

    LOGS_QDEBUG( "logs [ENG] <- LogsDbConnector::refreshData()" )

    return err;

}

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

// Compress data, only defined amount of events are kept in memory, others

// are deleted and read back to memory once refreshData is called. Also

// monitoring for database changes is disabled.

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

//

int LogsDbConnector::compressData()

{

    if ( !mResourceControl ){

        return -1;

    }

    LOGS_QDEBUG( "logs [ENG] -> LogsDbConnector::compressData()" )

    mCompressionEnabled = true;

    LogsCommonData::getInstance().configureReadSize(

        logsReadSizeCompressEnabled, LogsEvent::DirUndefined);

    if ( mReader ){

        int numEventsLeftInMemory = qMin(mEvents.count(), logsReadSizeCompressEnabled );

        // Simulate disappearing of compressed events

        QList<int> removedIndexes;

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

            if ( i == 0 ){

                mModelEvents.clear();

            }

            if ( i < numEventsLeftInMemory ){

                mModelEvents.append(mEvents.at(i));

            } else {

                removedIndexes.append(mEvents.at(i)->index());

            }

        }

        emit dataRemoved(removedIndexes);

        deleteInvalidEvents( numEventsLeftInMemory );

    }

    releaseDbConnections();

    LOGS_QDEBUG( "logs [ENG] <- LogsDbConnector::compressData()" )

    return 0;

}

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

// LogsDbConnector::handleTemporaryError

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

//

void LogsDbConnector::handleTemporaryError(int& error)

{

     if ( error == KErrAccessDenied ){

        LOGS_QDEBUG(

            "logs [ENG] LogsDbConnector::handleTemporaryError, DB temp unavailable" )

        // TODO: handle temporary error in some meaningful way

        error = 0;

    }

}

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

// LogsDbConnector::deleteInvalidEvents

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

//

void LogsDbConnector::deleteInvalidEvents(int newEventCount)

{

    // Remove events which are not anymore in db nor in model,

    // such events are always at end of list

    while ( mEvents.count() > newEventCount ){

        delete mEvents.takeLast();

    }

}

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

// LogsDbConnector::removeCompleted

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

//

void LogsDbConnector::removeCompleted()

{

    LOGS_QDEBUG( "logs [ENG] -> LogsDbConnector::removeCompleted()" )

    mReader->lock(false);

    emit clearingCompleted(0);

    LOGS_QDEBUG( "logs [ENG] <- LogsDbConnector::removeCompleted()" )

}

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

// LogsDbConnector::logsRemoveErrorOccured

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

//

void LogsDbConnector::logsRemoveErrorOccured(int err)

{

    LOGS_QDEBUG_2( "logs [ENG] <-> LogsDbConnector::logsRemoveErrorOccured(), err:", err )

    mReader->lock(false);

    emit clearingCompleted(err);

    // TODO: error handling

    LOGS_QDEBUG( "logs [ENG] <- LogsDbConnector::logsRemoveErrorOccured()" )

}

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

// LogsDbConnector::readCompleted

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

//

void LogsDbConnector::readCompleted()

{

    LOGS_QDEBUG( "logs [ENG] -> LogsDbConnector::readCompleted()" )

    LOGS_QDEBUG_EVENT_ARR(mEvents)

    // Find out updated, added and removed events

    mRemovedEventIndexes.clear();

    mUpdatedEventIndexes.clear();

    mAddedEventIndexes.clear();

    mModelEvents.clear();

    QList<LogsEvent*> toBeDeletedEvents;

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

        LogsEvent* currEvent = mEvents.at(i);

        if ( !currEvent->isInView() ){

            if ( currEvent->index() >= 0 ){

                mRemovedEventIndexes.append( currEvent->index() );

            }

            toBeDeletedEvents.append( mEvents.takeAt(i) );

            i--;

        } else {

            currEvent->setIndex(i);

            if ( currEvent->eventState() == LogsEvent::EventUpdated ) {

                mUpdatedEventIndexes.append(i);

            } else if ( currEvent->eventState() == LogsEvent::EventAdded ) {

                mAddedEventIndexes.append(i);

            }

            mModelEvents.append(currEvent);

        }

    }

    int changeCount = 0;

    changeCount += mRemovedEventIndexes.isEmpty() ? 0 : 1;

    changeCount += mAddedEventIndexes.isEmpty() ? 0 : 1;

    changeCount += mUpdatedEventIndexes.isEmpty() ? 0 : 1;

    if ( changeCount > 1 ){

        // If having many changes, it is less error prone

        // to just report reset.

        emit dataReset();

    } else {

        if ( !mRemovedEventIndexes.isEmpty() ){

            emit dataRemoved(mRemovedEventIndexes);

        }             

        if ( !mAddedEventIndexes.isEmpty() ){

            emit dataAdded(mAddedEventIndexes);

        }

        if ( !mUpdatedEventIndexes.isEmpty() ){

            emit dataUpdated(mUpdatedEventIndexes);

        }

    }  

    qDeleteAll(toBeDeletedEvents);

    if ( qApp && !mFirstReadCompleted){

        // Just used for testing purposes

        QMetaObject::invokeMethod(qApp, "testLogsAppEngineReady" );

        mFirstReadCompleted = true;

    }

    if ( mCompressionEnabled ){

        releaseDbConnections();

    }    

    LOGS_QDEBUG( "logs [ENG] <- LogsDbConnector::readCompleted()" )

}

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

// LogsDbConnector::errorOccurred

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

//

void LogsDbConnector::errorOccurred(int err)

{

    LOGS_QDEBUG_2( "logs [ENG] <-> LogsDbConnector::errorOccurred(), err:", err )

    // TODO: error handling

    handleModifyingCompletion(err);

    Q_UNUSED(err)

}

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

// LogsDbConnector::temporaryErrorOccurred

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

//

void LogsDbConnector::temporaryErrorOccurred(int err)

{

    LOGS_QDEBUG_2( 

            "logs [ENG] -> LogsDbConnector::temporaryErrorOccurred(), err:", err )

    handleTemporaryError(err);

    LOGS_QDEBUG( "logs [ENG] <- LogsDbConnector::temporaryErrorOccurred()" )

}

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

// LogsDbConnector::eventModifyingCompleted

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

//

void LogsDbConnector::eventModifyingCompleted()