// Copyright (c) 2003-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 <logclientchangeobserver.h>
#include "LogServDatabaseDriver.h"
#include "LOGMAIN.H"
#include "LOGADD.H"
#include "LOGCHNGE.H"
#include "LOGGET.H"
#include "LOGDEL.H"
#include "LOGQUERY.H"
#include "logservpanic.h"
#include "LogServCacheConfig.h"
#include "LogServCacheTypes.h"
#include "LogServBackupInterface.h"
#include "LogServViewWindowFetcher.h"
#include "LogServRecentListManager.h"
#include "LogServDatabaseTransactionInterface.h"
#include "LogServDatabaseChangeInterface.h"
#include "LogServSqlStrings.h"


/////////////////////////////////////////////////////////////////////////////////////////
// -----> CLogServDatabaseDriver (source)
/////////////////////////////////////////////////////////////////////////////////////////

CLogServDatabaseDriver::CLogServDatabaseDriver(MLogServBackupInterface& aBackupInterface, MLogServDatabaseTransactionInterface& aDatabase, CLogServResourceInterpreter& aResourceInterface, CLogServRecentListManager& aRecentListManager, TInt aHitterPriorities)
:	iHitterPriorities(aHitterPriorities), iBackupInterface(aBackupInterface), iDatabase(aDatabase), iResourceInterface(aResourceInterface), iRecentListManager(aRecentListManager)
	{
	}

CLogServDatabaseDriver::~CLogServDatabaseDriver()
	{
	iBackupInterface.BIObserverRemove(*this);
	DestroyHitters();
	}

void CLogServDatabaseDriver::ConstructL()
	{
	iBackupInterface.BIObserverAddL(*this, MLogServBackupInterface::EObjectDatabaseDriver);
	//
	CreateHittersL();
	}

CLogServDatabaseDriver* CLogServDatabaseDriver::NewL(MLogServBackupInterface& aBackupInterface, MLogServDatabaseTransactionInterface& aDatabase, CLogServResourceInterpreter& aResourceInterface, CLogServRecentListManager& aRecentListManager, TInt aHitterPriorities)
	{
	CLogServDatabaseDriver* self = new(ELeave) CLogServDatabaseDriver(aBackupInterface, aDatabase, aResourceInterface, aRecentListManager, aHitterPriorities);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////

void CLogServDatabaseDriver::BOHandleEventL(TLogServBackupEvent aEvent)
	{
	switch(aEvent)
		{
	case EBackupStarting:
		LOGTEXT("CLogServDatabaseDriver::BOHandleEventL() - Backup STARTING");
		DestroyHitters();
		break;
	case EBackupEnded:
		LOGTEXT("CLogServDatabaseDriver::BOHandleEventL() - Backup ENDING");
		CreateHittersL();
		break;
	default:
		__ASSERT_DEBUG(EFalse, User::Invariant());
		break;
		}

	LOGTEXT("CLogServDatabaseDriver::BOHandleEventL() - end");
	}

/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////

void CLogServDatabaseDriver::TaskEventAddL(TRequestStatus& aStatus, CLogEvent& aEvent, const RMessage2& aMessage)
//
// Add an event to the database
//
	{
	LOGTEXT("CLogServDatabaseDriver::TaskEventAddL()");

	// Handle when we're doing a backup
	iBackupInterface.BIValidateStateForDatabaseOperationL();

	// Get the recent list for this event
	const CLogServRecentList* list = iRecentListManager.GetRecentList(aEvent);

	// Do the work
	iAddEvent->StartL(aEvent, list, aStatus, aMessage);

	LOGTEXT("CLogServDatabaseDriver::TaskEventAddL() - end");
	}

void CLogServDatabaseDriver::TaskEventChangeL(TRequestStatus& aStatus, const CLogEvent& aEvent, const RMessage2& aMessage)
//
// Change an event in the database
//
	{
	LOGTEXT("CLogServDatabaseDriver::TaskEventChangeL()");

	// Handle when we're doing a backup
	iBackupInterface.BIValidateStateForDatabaseOperationL();

	// Get the recent list for this event
	const CLogServRecentList* list = iRecentListManager.GetRecentList(aEvent);
	
	//

	// Do the work
	iChangeEvent->StartL(aEvent, list, aStatus, aMessage);

	LOGTEXT("CLogServDatabaseDriver::TaskEventChangeL() - end");
	}

void CLogServDatabaseDriver::TaskEventGetL(TRequestStatus& aStatus, CLogEvent& aEvent, const RMessage2& aMessage)
//
// Get an event from the database
//
	{
	LOGTEXT("CLogServDatabaseDriver::TaskEventGetL()");

	// Handle when we're doing a backup
	iBackupInterface.BIValidateStateForDatabaseOperationL();

	// Do the work
	iGetEvent->StartL(aEvent, aStatus, aMessage);

	LOGTEXT("CLogServDatabaseDriver::TaskEventGetL() - end");
	}

void CLogServDatabaseDriver::TaskEventDeleteL(TRequestStatus& aStatus, TLogId aId, const RMessage2& aMessage)
//
// Delete an event from the database
//
	{
	LOGTEXT("CLogServDatabaseDriver::TaskEventDeleteL()");

	// Handle when we're doing a backup
	iBackupInterface.BIValidateStateForDatabaseOperationL();

	iDeleteEvent->StartL(aId, aStatus, aMessage);

	LOGTEXT("CLogServDatabaseDriver::TaskEventDeleteL() - end");
	}

void CLogServDatabaseDriver::TaskEventTypeAddL(TRequestStatus& aStatus, const CLogEventType& aEventType)
	{
	LOGTEXT("CLogServDatabaseDriver::TaskEventTypeAddL()");

	// Handle when we're doing a backup
	iBackupInterface.BIValidateStateForDatabaseOperationL();
	iDatabase.DTICacheTypes().AddTypeL(aEventType);
	//
	TRequestStatus* status = &aStatus;
	User::RequestComplete(status, KErrNone);

	LOGTEXT("CLogServDatabaseDriver::TaskEventTypeAddL() - end");
	}

void CLogServDatabaseDriver::TaskEventTypeGetL(TRequestStatus& aStatus, const CLogEventType*& aEventType, TUid aUid)
	{
	LOGTEXT("CLogServDatabaseDriver::TaskEventTypeGetL()");

	// Handle when we're doing a backup
	iBackupInterface.BIValidateStateForDatabaseOperationL();

	const TLogServCacheTypeEntry& entry = iDatabase.DTICacheTypes().FindByUid(aUid);
	aEventType = entry.iEventType;
	if(entry.iEventTypeId == KLogNullTypeId)
		{
		User::Leave(KErrNotFound);
		}

	TRequestStatus* status = &aStatus;
	User::RequestComplete(status, KErrNone);

	LOGTEXT("CLogServDatabaseDriver::TaskEventTypeGetL() - end");
	}

void CLogServDatabaseDriver::TaskEventTypeChangeL(TRequestStatus& aStatus, const CLogEventType& aEventType)
	{
	LOGTEXT("CLogServDatabaseDriver::TaskEventTypeChangeL()");

	// Handle when we're doing a backup
	iBackupInterface.BIValidateStateForDatabaseOperationL();
	const TInt error = iDatabase.DTICacheTypes().ChangeType(aEventType);
	//
	TRequestStatus* status = &aStatus;
	User::RequestComplete(status, error);

	LOGTEXT("CLogServDatabaseDriver::TaskEventTypeChangeL() - end");
	}

void CLogServDatabaseDriver::TaskEventTypeDeleteL(TRequestStatus& aStatus, TUid aType)
	{
	LOGTEXT("CLogServDatabaseDriver::TaskEventTypeDeleteL()");

	// Handle when we're doing a backup
	iBackupInterface.BIValidateStateForDatabaseOperationL();
	const TInt error = iDatabase.DTICacheTypes().DeleteType(aType);
	//
	TRequestStatus* status = &aStatus;
	User::RequestComplete(status, error);

	LOGTEXT("CLogServDatabaseDriver::TaskEventTypeDeleteL() - end");
	}

void CLogServDatabaseDriver::TaskConfigGetL(TRequestStatus& aStatus, TLogConfig& aConfig)
	{
	LOGTEXT("CLogServDatabaseDriver::TaskConfigGetL()");

	// Handle when we're doing a backup
	iBackupInterface.BIValidateStateForDatabaseOperationL();
	aConfig = iDatabase.DTICacheConfig().Config();
	//
	TRequestStatus* status = &aStatus;
	User::RequestComplete(status, KErrNone);

	LOGTEXT("CLogServDatabaseDriver::TaskConfigGetL() - end");
	}

void CLogServDatabaseDriver::TaskConfigChangeL(TRequestStatus& aStatus, const TLogConfig& aConfig)
	{
	LOGTEXT("CLogServDatabaseDriver::TaskConfigChangeL()");

	// Handle when we're doing a backup
	iBackupInterface.BIValidateStateForDatabaseOperationL();

	iChangeConfig->StartL(aConfig, aStatus);

	LOGTEXT("CLogServDatabaseDriver::TaskConfigChangeL() - end");
	}

// aDate is expected to be UTC
void CLogServDatabaseDriver::TaskClearLogL(TRequestStatus& aStatus, const TTime& aDate
#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
		, TSimId aSimId
#endif		
		)
	{
	LOGTEXT("CLogServDatabaseDriver::TaskClearLogL()");

	// Handle when we're doing a backup
	iBackupInterface.BIValidateStateForDatabaseOperationL();

	// Format the date.
	TBuf<KLogMaxDateLength> dateString;
	aDate.FormatL(dateString, LogUtils::DateFormatForLocale());
	// Get list of events to purge
	TheSql.Format(KLogSqlDeleteOldestString, &dateString);
#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
	if(aSimId != KLogNullSimId)
		{
		TheSql.Append(KLogAnd);
		TheSql.AppendFormat(KLogUNumberPredicate, &KLogFieldEventSimId, aSimId);
		}
#endif	
	iDatabase.DTIBeginWithRollBackProtectionLC();
	TInt rc = iDatabase.DTIExecuteSql(TheSql);
	User::LeaveIfError(rc);
	if(rc > 0)
	    {
		// Add log cleared events. First is for the window code, which receives messages
		// through the old API. The 2nd is for clients of the log engine
		iDatabase.DTIChangeInterface().DCISubmitChangedEventContextL(ELogChangeTypeLogCleared, KLogNullId);
		iDatabase.DTIChangeInterface().DCISubmitGlobalChangeContextL(KLogClientChangeEventLogCleared);
		}
	iDatabase.DTICommitAndCancelRollbackProtectionL();
	// Complete the request
	TRequestStatus* status = &aStatus;
	User::RequestComplete(status, KErrNone);

	LOGTEXT("CLogServDatabaseDriver::TaskClearLogL() - end");
	}

void CLogServDatabaseDriver::TaskClearRecentL(TRequestStatus& aStatus, TInt aRecentList
#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
		, TSimId aSimId
#endif		
		)
	{
	LOGTEXT("CLogServDatabaseDriver::TaskClearRecentL()");

	// Handle when we're doing a backup
	iBackupInterface.BIValidateStateForDatabaseOperationL();

	TheSql.Copy(KLogSqlSelectAllRecent);
#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
	TBool whereAdded = EFalse;
#endif	
	// Get events to clear from recent lists
	if(aRecentList != KLogNullRecentList)
		{
		TheSql.Append(KLogWhere);
#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
		whereAdded = ETrue;
#endif		
		TheSql.AppendFormat(KLogNumberPredicate, &KLogFieldEventRecentString, aRecentList);
		}
#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
	//..and clear from recent lists with specific SimId
	if(aSimId != KLogNullSimId)
		{
		if(whereAdded)
			{
			TheSql.Append(KLogAnd);
			}
		else
			{
			TheSql.Append(KLogWhere);
			}
		TheSql.AppendFormat(KLogUNumberPredicate, &KLogFieldEventSimId, aSimId);
		}
#endif	
	
    RLogDbView view;
    view.PrepareLC(iDatabase.DTIDatabase(), TheSql);
	
	if(view.FirstL())
		{
        static TDbColNo colId = 0;
        static TDbColNo colRecent = 0;
        static TDbColNo colDuplicate = 0;
        if(colId == 0)
            {
            CDbColSet* cs = view.ColSetL();
            colId = cs->ColNo(KLogFieldIdString);
            colRecent = cs->ColNo(KLogFieldEventRecentString);
            colDuplicate = cs->ColNo(KLogFieldEventDuplicateString);
            delete cs;
            }
		iDatabase.DTIBeginWithRollBackProtectionLC();
		// Iterate through the events
		do
			{
			// Get current event id
			view.GetL();
			const TLogId id = view.ColInt32(colId);
			// Make the change
			view.UpdateL();
			view.SetColNullL(colRecent);
			view.SetColNullL(colDuplicate);
			view.PutL();
			// This is a "hidden" change. It may affect the contents of a view, but the actual event hasn't changed
			iDatabase.DTIChangeInterface().DCISubmitChangedEventContextL(ELogChangeTypeEventChangedHidden, id);
			}
		while(view.NextL());
		iDatabase.DTICommitAndCancelRollbackProtectionL();
		}
    CleanupStack::PopAndDestroy(&view);

	// Complete the request
	TRequestStatus* status = &aStatus;
	User::RequestComplete(status, KErrNone);

	LOGTEXT("CLogServDatabaseDriver::TaskClearRecentL() - end");
	}

void CLogServDatabaseDriver::TaskMaintenanceStartL(TRequestStatus& aStatus, TBool aPurge)
//
//	Start database maintenance process
//
	{
	LOGTEXT("CLogServDatabaseDriver::TaskMaintenanceStartL()");

	// Handle when we're doing a backup
	iBackupInterface.BIValidateStateForDatabaseOperationL();

	iMaintainer->Start(aPurge, aStatus);

	LOGTEXT("CLogServDatabaseDriver::TaskMaintenanceStartL() - end");
	}

void CLogServDatabaseDriver::TaskBuildWindowL(TRequestStatus& aStatus, const CLogServViewBase& aView, const TLogTransferWindow& aWindow, const RMessage2& aMessage)
//
//	Build a client window
//
	{
	LOGTEXT("CLogServDatabaseDriver::TaskBuildWindowL()");

	// Handle when we're doing a backup
	iBackupInterface.BIValidateStateForDatabaseOperationL();

	iWindowFetcher->StartL(aStatus, aView, aWindow, aMessage); 

	LOGTEXT("CLogServDatabaseDriver::TaskBuildWindowL() - end");
	}

void CLogServDatabaseDriver::TaskCancelCurrent()
//
//	Cancel all active tasks
//
	{
	LOGTEXT("CLogServDatabaseDriver::TaskCancelCurrent()");

	if	(iAddEvent)
		iAddEvent->Cancel();
	if	(iChangeEvent)
		iChangeEvent->Cancel();
	if	(iGetEvent)
		iGetEvent->Cancel();
	if	(iDeleteEvent)
		iDeleteEvent->Cancel();
	if	(iChangeConfig)
		iChangeConfig->Cancel();
	if	(iWindowFetcher)
		iWindowFetcher->Cancel();

	LOGTEXT("CLogServDatabaseDriver::TaskCancelCurrent() - end");
	}

/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////

void CLogServDatabaseDriver::DestroyHitters()
	{
	LOGTEXT("CLogServDatabaseDriver::DestroyHitters()");

	TaskCancelCurrent();
	//
	delete iMaintainer;
	iMaintainer = NULL;
	delete iAddEvent;
	iAddEvent = NULL;
	delete iChangeEvent;
	iChangeEvent = NULL;
	delete iGetEvent;
	iGetEvent = NULL;
	delete iDeleteEvent;
	iDeleteEvent = NULL;
	delete iChangeConfig;
	iChangeConfig = NULL;
	delete iWindowFetcher;
	iWindowFetcher = NULL;

	LOGTEXT("CLogServDatabaseDriver::DestroyHitters() - end");
	}

void CLogServDatabaseDriver::CreateHittersL()
	{
	LOGTEXT("CLogServDatabaseDriver::CreateHittersL()");

	iMaintainer = CLogMaintenance::NewL(iDatabase, iHitterPriorities);
	iAddEvent = CLogAddEvent::NewL(iDatabase, iHitterPriorities);
	iChangeEvent = CLogChangeEvent::NewL(iDatabase, iHitterPriorities);
	iGetEvent = CLogGetEvent::NewL(iDatabase, iHitterPriorities);
	iDeleteEvent = CLogDeleteEvent::NewL(iDatabase, iHitterPriorities);
	iChangeConfig = CLogChangeConfig::NewL(iDatabase, iRecentListManager, iHitterPriorities);
	iWindowFetcher = CLogServViewWindowFetcher::NewL(iDatabase, iHitterPriorities);

	LOGTEXT("CLogServDatabaseDriver::CreateHittersL() - end");
	}