// Copyright (c) 2002-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 "LOGCHNGE.H"
#include <logwraplimits.h>
#include <logcntdef.h>
#include "LOGQUERY.H"
#include "logservpanic.h"
#include "LogServRecentList.h"
#include "LogServCacheConfig.h"
#include "LogServRecentListManager.h"
#include "LogServDatabaseTransactionInterface.h"
#include "LogServDatabaseChangeInterface.h"
#include "LOGDUP.H"
#include "LogServCacheStrings.h"
#include "LogServSqlStrings.h"

//**********************************
// CLogChangeEvent
//**********************************

CLogChangeEvent::CLogChangeEvent(MLogServDatabaseTransactionInterface& aDatabase, TInt aPriority)
: CLogActive(aPriority), iDatabase(aDatabase)
	{
	}

CLogChangeEvent::~CLogChangeEvent()
	{
	Cancel();
	//
	delete iEvent;
	delete iDuplicate;
	delete iDuplicateFilter;
	}

void CLogChangeEvent::ConstructL()
	{
	iEvent = CLogEvent::NewL();
	iDuplicate = CLogDuplicate::NewL(iDatabase, Priority());
	iDuplicateFilter = CLogFilter::NewL();
	}

CLogChangeEvent* CLogChangeEvent::NewL(MLogServDatabaseTransactionInterface& aDatabase, TInt aPriority)
	{
	CLogChangeEvent* self = new(ELeave)CLogChangeEvent(aDatabase, aPriority);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

void CLogChangeEvent::StartL(const CLogEvent& aEvent, const CLogServRecentList* aRecentList, TRequestStatus& aStatus, const RMessage2& aMessage)
	{
	__ASSERT_ALWAYS(iState == ELogNone, Panic(ELogBadState2));
	__ASSERT_DEBUG(!IsActive(), Panic(ELogAlreadyActive3));

	iMessage = &aMessage;
	iEvent->CopyL(aEvent);
	iState = ELogChangeEvent;
	iRecentList = aRecentList; // Need to use this! (5yrs later - okay then :-)
	iOldRecentList = KLogNullRecentList;

	Queue(aStatus);
	TRequestStatus* status = &iStatus;
	User::RequestComplete(status, KErrNone);
	SetActive();
	}

void CLogChangeEvent::DoRunL()
	{
	__ASSERT_DEBUG(iState != ELogNone, Panic(ELogBadState3));

	switch (iState)
		{
		case ELogChangeEvent:
			DoChangeEventL();
            ResetDuplicatesL();
            UpdateDuplicateEventsL();
			break;
		case ELogPurgeRecent:
			{
            RArray<TLogId> logIds;
            ::LogGetRecentEventsLC(iDatabase, iRecentList->Id(), iDatabase.DTICacheConfig().Config().iMaxRecentLogSize, logIds); 
            ::LogPurgeRecentEventsL(iDatabase, logIds);
            CleanupStack::PopAndDestroy(&logIds);
			}
            break;
 		default:
 			__ASSERT_DEBUG(ETrue, Panic(ELogBadState4));
 			break;
		}
	}

void CLogChangeEvent::DoComplete(TInt& aStatus)
	{
	if (iDatabase.DTIInTransaction())
		{
		if (aStatus == KErrNone)
			aStatus = iDatabase.DTICommitAndEnd();

		if (aStatus < KErrNone)
			iDatabase.DTIRollBack();
		}

	iState = ELogNone;
	}

void CLogChangeEvent::ResetDuplicatesL()
    {
    // Was it in a recent list? Is it now changing lists?
    if (iOldRecentList > 0 && (!iRecentList || iOldRecentList != iRecentList->Id()))
        {
        ::LogResetDuplicatesL(iDatabase, iEvent->Id());
        }
    }

void CLogChangeEvent::UpdateDuplicateEventsL()
    {
    // Detect duplicate events if we've added an event to a recent list
    if (iOldRecentList > 0 && iRecentList && iOldRecentList != iRecentList->Id())
        {
        iRecentList->GetFilter(*iEvent, *iDuplicateFilter);
        // If we get here we have added an event to a recent list, which may need to be purged
        iState = ELogPurgeRecent;
        // Passing -1 into this will ensure that events are updated so the most recent duplicate is first
        if (!iDuplicate->StartL(-1, iRecentList->Id(), *iDuplicateFilter, iStatus))
            {
            // Complete ourselves
            TRequestStatus* status = &iStatus;
            User::RequestComplete(status, KErrNone);
            }
        SetActive();
        }
    }

void CLogChangeEvent::DoChangeEventL()
    {
    RLogEventDbTable tbl;
    tbl.OpenLC(iDatabase.DTIDatabase());
    User::LeaveIfError(tbl.SetIndex(KLogNameEventIdx1));
    if(!tbl.SeekL(TDbSeekKey((TInt)iEvent->Id())))
        {
        User::Leave(KErrNotFound);
        }
    User::LeaveIfError(iDatabase.DTIBegin());
    tbl.GetL();
    iOldRecentList = tbl.ColInt8(RLogEventDbTable::iRecentColNo);
    DoChangeL(tbl, iDatabase.DTICacheStrings().GetIdL(iEvent->Direction()), iDatabase.DTICacheStrings().GetIdL(iEvent->Status()));
    CleanupStack::PopAndDestroy();//tbl
    }

void CLogChangeEvent::DoChangeL(RLogEventDbTable& aTbl, TLogStringId aDirectionId, TLogStringId aStatusId)
	{
	if(!iDatabase.DTIIsAllowed(EWriteOp, *iMessage, iEvent->EventType())) 
		{
		User::Leave(KErrPermissionDenied);
		}
	
	aTbl.UpdateL();

	if (iEvent->RemoteParty().Length() > 0)
		aTbl.SetColL(RLogEventDbTable::iRemotePartyColNo, iEvent->RemoteParty());
	else
		aTbl.SetColNullL(RLogEventDbTable::iRemotePartyColNo);

	if (iEvent->Direction().Length() > 0)
	    aTbl.SetColL(RLogEventDbTable::iDirectionColNo, (TUint32)aDirectionId);
	else
	    aTbl.SetColNullL(RLogEventDbTable::iDirectionColNo);

	aTbl.SetColL(RLogEventDbTable::iTimeColNo, iEvent->Time());
	aTbl.SetColL(RLogEventDbTable::iDurationTypeColNo, (TInt32)iEvent->DurationType());

	if (iEvent->DurationType() != KLogNullDurationType)
	    aTbl.SetColL(RLogEventDbTable::iDurationColNo, iEvent->Duration());
	else
	    aTbl.SetColNullL(RLogEventDbTable::iDurationColNo);

	if (iEvent->Status().Length() > 0)
	    aTbl.SetColL(RLogEventDbTable::iStatusColNo, (TUint32)aStatusId);
	else
	    aTbl.SetColNullL(RLogEventDbTable::iStatusColNo);

	if (iEvent->Subject().Length() > 0)
	    aTbl.SetColL(RLogEventDbTable::iSubjectColNo, iEvent->Subject());
	else
	    aTbl.SetColNullL(RLogEventDbTable::iSubjectColNo);

	if (iEvent->Number().Length() > 0)
	    aTbl.SetColL(RLogEventDbTable::iNumberColNo, iEvent->Number());
	else
	    aTbl.SetColNullL(RLogEventDbTable::iNumberColNo);

	if (iEvent->Contact() != KLogNullContactId)
	    aTbl.SetColL(RLogEventDbTable::iContactColNo, iEvent->Contact());
	else
	    aTbl.SetColNullL(RLogEventDbTable::iContactColNo);

	if (iEvent->Link() != KLogNullLink)
	    aTbl.SetColL(RLogEventDbTable::iLinkColNo, iEvent->Link());
	else
	    aTbl.SetColNullL(RLogEventDbTable::iLinkColNo);

	if (iEvent->Data().Length() > 0)
	    aTbl.SetColL(RLogEventDbTable::iDataColNo, iEvent->Data());
	else
	    aTbl.SetColNullL(RLogEventDbTable::iDataColNo);

	// Set the flags
	TInt bit = KLogFlagsCount;
	while(bit--)
		{
        aTbl.SetColL(RLogEventDbTable::iFlagColNo[bit], (TUint32)((iEvent->Flags() & 0x1 << bit) ? 1 : 0));
		}

	// Set the recent list
	if (iOldRecentList > 0)
		{
		// Removing an event from all recent lists?
		if (!iRecentList)
			{
			aTbl.SetColNullL(RLogEventDbTable::iRecentColNo);
			aTbl.SetColNullL(RLogEventDbTable::iDuplicateColNo);
			}
		// Changing list?
		else if (iOldRecentList != iRecentList->Id())
			{
			__ASSERT_DEBUG(iRecentList->Id() != KLogNullRecentList, Panic(ELogNullRecentList));
			aTbl.SetColL(RLogEventDbTable::iRecentColNo, (TInt32)iRecentList->Id());

			// This is set to -1 to prevent it temporarily appearing in a recent or duplicate view
			// It gets updated properly later when detecting duplicates
			aTbl.SetColL(RLogEventDbTable::iDuplicateColNo, -1);
			}
		}

#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
	if(iEvent->SimId() != KLogNullSimId)
	    aTbl.SetColL(RLogEventDbTable::iSimIdColNo, iEvent->SimId());
	else
	    aTbl.SetColNullL(RLogEventDbTable::iSimIdColNo);
#endif	
	
	aTbl.PutL();

	iDatabase.DTIChangeInterface().DCISubmitChangedEventContextL(ELogChangeTypeEventChanged, iEvent->Id());
	}

//**********************************
// CLogChangeConfig
//**********************************

CLogChangeConfig::CLogChangeConfig(MLogServDatabaseTransactionInterface& aDatabase, const CLogServRecentListManager& aRecentSetup, TInt aPriority)
: CLogActive(aPriority), iDatabase(aDatabase), iRecentSetup(aRecentSetup)
	{
	}

CLogChangeConfig::~CLogChangeConfig()
	{
	Cancel();
	}

CLogChangeConfig* CLogChangeConfig::NewL(MLogServDatabaseTransactionInterface& aDatabase, const CLogServRecentListManager& aRecentSetup, TInt aPriority)
	{
	CLogChangeConfig* self = new(ELeave) CLogChangeConfig(aDatabase, aRecentSetup, aPriority);
	return self;
	}

void CLogChangeConfig::StartL(const TLogConfig& aConfig, TRequestStatus& aStatus)
	{
	__ASSERT_ALWAYS(iState == ELogNone, Panic(ELogBadState5));
	__ASSERT_DEBUG(!IsActive(), Panic(ELogAlreadyActive4));

	iState = ELogChange;
	iConfig = &aConfig;

	Queue(aStatus);
	TRequestStatus* status = &iStatus;
	User::RequestComplete(status, KErrNone);
	SetActive();
	}

void CLogChangeConfig::DoRunL()
	{
	switch (iState)
		{
		case ELogChange:
			{
			// Start a transaction
			User::LeaveIfError(iDatabase.DTIBegin());
			// Change the config, using the existing transaction
			iDatabase.DTICacheConfig().UpdateL(*iConfig);
			//Purge old events
            RLogEventDbTable tbl;
            tbl.OpenLC(iDatabase.DTIDatabase());
            ::LogPurgeMainL(iDatabase, tbl, iConfig->iMaxLogSize, 0);
            CleanupStack::PopAndDestroy(&tbl);
            iRecent = 0;
            //
			iState = ELogPurgeRecent;
			TRequestStatus* status = &iStatus;
			User::RequestComplete(status, KErrNone);
			SetActive();
			break;
			}
		case ELogPurgeRecent:
			{
			// Are there any more recent lists to check
			if(iRecent >= iRecentSetup.Count())
			    {
				break;
			    }
            RArray<TLogId> logIds;
            ::LogGetRecentEventsLC(iDatabase, iRecentSetup.List(iRecent).Id(), iConfig->iMaxRecentLogSize, logIds); 
            ::LogPurgeRecentEventsL(iDatabase, logIds);
            CleanupStack::PopAndDestroy(&logIds);
            // Purge next recent list?
            if (++iRecent < iRecentSetup.Count())
                {
                iState = ELogPurgeRecent;
                TRequestStatus* status = &iStatus;
                User::RequestComplete(status, KErrNone);
                SetActive();
                }
            break;
			}
		default:
			__ASSERT_DEBUG(ETrue, Panic(ELogBadState6));
			break;
		}
	}

void CLogChangeConfig::DoComplete(TInt& aStatus)
	{
	// Try and commit the transaction
	if (iDatabase.DTIInTransaction())
		{
		if	(aStatus == KErrNone)
			aStatus = iDatabase.DTICommitAndEnd();

		if	(aStatus < KErrNone)
			{
			iDatabase.DTICacheConfig().Rollback();
			iDatabase.DTIRollBack();
			}
		else
		    {
		    iDatabase.DTICacheConfig().Commit();
		    }
		}
    __ASSERT_DEBUG(!iDatabase.DTICacheConfig().InTransaction(), Panic(ELogChangeConfigLogicError));
	iState = ELogNone;
	}