// Copyright (c) 2004-2010 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 <s32file.h>
#include <logcntmodel.h>
#include <logengevents.h>
#include "LOGADD.H"
#include "logservpanic.h"
#include "LOGDUP.H"
#include "LOGQUERY.H"
#include "LogServRecentList.h"
#include "LogServDatabaseTransactionInterface.h"
#include "LogServResourceInterpreter.h"
#include "LogServCacheConfig.h"
#include "LogServDatabaseChangeInterface.h"
#include <centralrepository.h>
#include "LogServCacheStrings.h"
#include "LogServCacheTypes.h"
#include "LOGREPDEFS.H"

const TInt KMinimumNumberOfDigitsToMatch = 3;

////////////////////////////////////////////////////////////////////////////////////////////
// Local functions

#ifdef SYSLIBS_TEST

#pragma BullseyeCoverage off

static void LogStore32IntL(RFs& aFs, const TDesC& aFilePath, TInt aVal)
	{
	RFile file;
	User::LeaveIfError(file.Replace(aFs, aFilePath, EFileWrite));
	TPtrC8 p((const TUint8*)&aVal, sizeof(aVal));
	TInt err = file.Write(p);
	if(err == KErrNone)
		{
		err = file.Flush();
		}
	file.Close();
	User::LeaveIfError(err);
	}

static void LogStoreContactMatchCountAndNameFormatL(TInt aContactMatchCount, TLogContactNameFormat aContactNameFormat)
	{
	RFs fs;
	CleanupClosePushL(fs);
	User::LeaveIfError(fs.Connect());

	_LIT(KTestDir, "c:\\test\\");
	TInt err = fs.MkDir(KTestDir);
	if(err != KErrNone && err != KErrAlreadyExists)
		{
		User::Leave(err);
		}
	
	_LIT(KLogengTestFileNameCount, "c:\\test\\test_logengconfig_count.ini");
	LogStore32IntL(fs, KLogengTestFileNameCount, aContactMatchCount);
	
	_LIT(KLogengTestFileNameFormat, "c:\\test\\test_logengconfig_format.ini");
	LogStore32IntL(fs, KLogengTestFileNameFormat, (TInt)aContactNameFormat);
	
	CleanupStack::PopAndDestroy(&fs);
	}

#pragma BullseyeCoverage on

#endif //SYSLIBS_TEST

//This function reads logeng repository file and returns the integer value of the given key. 
static TInt LogGetRepositoryValueL(CRepository& aRepository, TInt aKey)
	{		
	TInt val = -1;		
	User::LeaveIfError(aRepository.Get(aKey, val));
	return val;
	}

static void LogGetContactmatchCountAndNameFormatL(TInt& aContactMatchCount, TLogContactNameFormat& aContactNameFormat)
	{
	CRepository* repository = NULL;
	TRAPD(err, repository = CRepository::NewL(KUidLogengRepository));		
	if(err == KErrNone)
		{
		CleanupStack::PushL(repository);
		aContactMatchCount = LogGetRepositoryValueL(*repository, KContactMatchCountRepKey);
		aContactNameFormat = static_cast <TLogContactNameFormat> (LogGetRepositoryValueL(*repository, KContactNameFormatRepKey));
		CleanupStack::PopAndDestroy(repository);
		}
	else if(err == KErrCorrupt)
		{
		__ASSERT_DEBUG(!repository, User::Invariant());
		User::Leave(err);
		}
	else
		{
		__ASSERT_DEBUG(!repository, User::Invariant());
		aContactMatchCount = KLogContactMatchCount;
		aContactNameFormat = KLogContactNameFormat;
		}
	#ifdef SYSLIBS_TEST
	LogStoreContactMatchCountAndNameFormatL(aContactMatchCount, aContactNameFormat);
	#endif	
	}

////////////////////////////////////////////////////////////////////////////////////////////
// CLogAddEvent class

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

CLogAddEvent::~CLogAddEvent()
	{
	Cancel();
	
	CloseContactsPlugin();

	delete iDuplicate;
	delete iDuplicateFilter;
	}

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

void CLogAddEvent::ConstructL()
	{
	iDuplicate = CLogDuplicate::NewL(iDatabase, Priority());
	iDuplicateFilter = CLogFilter::NewL();
	::LogGetContactmatchCountAndNameFormatL(iContactMatchCount, iContactNameFormat);
	}

//This method will open contacts database (if not opened yet), only if the value of 
//iContactMatchCount is not 0.
//Se how iContactMatchCount data member is initialised.
TBool CLogAddEvent::PerformContactMatchL()
	{
	if (iContactMatchCount <= 0 || iEvent->Contact() != KLogNullContactId)
		return EFalse;
	
	if (iContactPlugin)
		return ETrue;
	
	// Attempt to load plugin
	TRAPD( err, iContactPlugin=CLogCntModel::NewL());

	// If plugin doesn't exist this is equivalent to matching being disabled so we don't leave
	// for KErrNotFound
	if(err==KEComErrNoInterfaceIdentified)
		{
		// Disable contacts matching so that we don't keep attempting to match
		iContactMatchCount = 0;
		// Plugin doesn't exist
		return EFalse;
		}

	User::LeaveIfError(err);
	
	// Open the DB
	OpenContactsL();
	
	return ETrue;
	}

void CLogAddEvent::StartL(CLogEvent& aEvent, const CLogServRecentList* aRecentList, TRequestStatus& aStatus, const RMessage2& aMessage)
	{
	__ASSERT_ALWAYS(!IsActive(), Panic(ELogAlreadyActive1));

	LOGTEXT("CLogAddEvent::StartL()");

	// Store event details which were obtained from the client side
	iEvent = &aEvent;
	iState = ELogAddEvent;
	
	if (!iDatabase.DTIIsAllowed(EWriteOp, aMessage, iEvent->EventType()))
		{
		User::Leave(KErrPermissionDenied);
		}

	if (PerformContactMatchL())
		iState = ELogSetContactAndRemoteParty; // Go look for a matching contact

	iRecentList = aRecentList;
	iEventAdded = EFalse;

	// Setup the event's time (UTC)
	TTime time;
	time.UniversalTime();
	iEvent->SetTime(time);

	// Save the observer's request status and set it to KRequestPending
	Queue(aStatus);

	// Start this objects RunL chain
	TRequestStatus* status = &iStatus;
	User::RequestComplete(status, KErrNone);
	SetActive();
	}
	
void CLogAddEvent::SetEventContact()
    {
    // Start by converting the phone number text into a number
    // check we've got a long enough number to be worth checking
    if(iEvent->Number().Length() >= KMinimumNumberOfDigitsToMatch)
        {
        // now search for a contact by looking up the phone number
        TLogContactItemId contactId = KLogNullContactId;
        TRAPD(err, contactId = iContactPlugin->MatchPhoneNumberL(iEvent->Number(), iContactMatchCount));
        
        if(err == KErrNone)
            {
            // we have at least one match
            if(contactId != KLogNullContactId)
                {
                // we have a match so set the contact id
                iEvent->SetContact(contactId);
                }
            }
        }
    iEvent->SetFlags(KLogEventContactSearched);
    }

void CLogAddEvent::SetRemoteParty()
    {
    // Get the contact id
    TLogContactItemId  contactId = iEvent->Contact();
    if((contactId != KLogNullContactId) && (iEvent->RemoteParty().Length() == 0))
        {
        // Look it up and get the remote party info
        // Setup buffer to contain concatenated result
        TBuf<128> buf;
        // Go get the info
        TRAPD(err, iContactPlugin->ReadContactNameL(contactId, buf, iContactNameFormat));

        if(err == KErrNotFound)
            {
            // Couldn't find the contact with that id so set it to NULL
            iEvent->SetContact(KLogNullContactId);
            }
        else
            {
            // Found it so fill in remote party
            iEvent->SetRemoteParty(buf);
            }
        }
    }

void CLogAddEvent::GetConfigL()
    {
    iConfig = iDatabase.DTICacheConfig().Config();
    if(iConfig.iMaxLogSize == 0)
      {
      LOGTEXT("CLogAddEvent::DoRunL() - logging disabled");
      User::Leave(KErrNotSupported);
      }
    }

TLogTypeId CLogAddEvent::SetDescriptionL()
    {
    const TLogServCacheTypeEntry& entry = iDatabase.DTICacheTypes().FindByUid(iEvent->EventType());
    if(entry.iEventTypeId == KLogNullTypeId)
        {
        LOGTEXT("CLogAddEvent::DoRunL() - type not found");
        User::Leave(KErrNotFound);
        }
    if(!entry.iEventType->LoggingEnabled())
        {
        LOGTEXT("CLogAddEvent::DoRunL() - type not enabled");
        User::Leave(KErrNotSupported);
        }
    iEvent->SetDescription(entry.iEventType->Description());
    return entry.iEventTypeId;
    }
    
TBool CLogAddEvent::DetectDuplicateEventsL()
    {
    TBool rc = EFalse;
    if(iRecentList)
        {
        iRecentList->GetFilter(*iEvent, *iDuplicateFilter);
        rc = iDuplicate->StartL(iEvent->Id(), iRecentList->Id(), *iDuplicateFilter, iStatus);
        }
    return rc;
    }

void CLogAddEvent::DoRunL()
	{
	LOGTEXT3("CLogAddEvent::DoRunL(%d), state = %d", iStatus.Int(), iState);

	switch (iState)
		{
		case ELogSetContactAndRemoteParty:
			{
			SetEventContact();
			SetRemoteParty();
			TRequestStatus* status = &iStatus;
			User::RequestComplete(status, KErrNone);
			iState = ELogAddEvent;
			SetActive();
			break;
			}
		case ELogAddEvent:
			{
			GetConfigL();
			TLogTypeId typeId = SetDescriptionL();
			RLogEventDbTable tbl;
			tbl.OpenLC(iDatabase.DTIDatabase());
			::LogPurgeMainL(iDatabase, tbl, iConfig.iMaxLogSize, 1);
			DoAddEventL(tbl, typeId, iDatabase.DTICacheStrings().GetIdL(iEvent->Direction()), iDatabase.DTICacheStrings().GetIdL(iEvent->Status()));
            CleanupStack::PopAndDestroy();//tbl
			iEventAdded = ETrue;
			if(DetectDuplicateEventsL())
			    {
                iState = ELogPurgeRecent;
                SetActive();
                break;
			    }
			iState = ELogPurgeRecent;
			TRequestStatus* status = &iStatus;
			User::RequestComplete(status, KErrNone);
			SetActive();
			break;
			}
		case ELogPurgeRecent:
			{
			// Delete old recent events
			if (iRecentList)
				{
				RArray<TLogId> logIds;
				::LogGetRecentEventsLC(iDatabase, iRecentList->Id(), iConfig.iMaxRecentLogSize, logIds); 
				::LogPurgeRecentEventsL(iDatabase, logIds);
				CleanupStack::PopAndDestroy(&logIds);
				}
			}
			break;
		default:
			__ASSERT_DEBUG(ETrue, Panic(ELogBadState1));
            break;
		}

	LOGTEXT("CLogAddEvent::DoRunL() - end");
	}

void CLogAddEvent::DoCancel()
	{
	iDuplicate->Cancel();
	CLogActive::DoCancel();
	}

void CLogAddEvent::DoAddEventL(RLogEventDbTable& aTbl, TLogTypeId aTypeId, TLogStringId aDirectionId, TLogStringId aStatusId)
	{
	LOGTEXT("CLogAddEvent::DoAddEventL()");

	// Insert a new record
	aTbl.InsertL();

	aTbl.SetColL(RLogEventDbTable::iTypeColNo, (TUint32)aTypeId);

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

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

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

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

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

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

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

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

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

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

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

	if (iRecentList)
		{
		__ASSERT_DEBUG(iRecentList->Id() != KLogNullRecentList, Panic(ELogNullRecentList));
		aTbl.SetColL(RLogEventDbTable::iRecentColNo, (TInt32)iRecentList->Id());
		}

#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
	if(iEvent->SimId() != KLogNullSimId)
		{
		aTbl.SetColL(RLogEventDbTable::iSimIdColNo, iEvent->SimId());
		}
	else
		{
		aTbl.SetColNullL(RLogEventDbTable::iSimIdColNo);
		}
#endif
	
	// Assign event id and end the rowset operation
	const TLogId newId = aTbl.ColInt32(RLogEventDbTable::iIdColNo);
	iEvent->SetId(newId);
	aTbl.PutL();

	// Tell change interface about the addition
	iDatabase.DTIChangeInterface().DCISubmitChangedEventContextL(ELogChangeTypeEventAdded, newId);

	LOGTEXT("CLogAddEvent::DoAddEventL() - end");
	}

void CLogAddEvent::DoComplete(TInt& aStatus)
	{
	LOGTEXT2("CLogAddEvent::DoComplete(%d)", aStatus);

	if	(iDatabase.DTIInTransaction())
		{
		LOGTEXT2("CLogAddEvent::DoComplete() - in transaction: %d", aStatus);
		if (aStatus == KErrNone)
			aStatus = iDatabase.DTICommitAndEnd();

		LOGTEXT2("CLogAddEvent::DoComplete() - checking for need to rollback: %d", aStatus);
		if (aStatus < KErrNone)
			iDatabase.DTIRollBack();
		}
	else
		{
		if	(iEventAdded)
			aStatus = KErrNone;
		}

	LOGTEXT2("CLogAddEvent::DoComplete() - final status value is: %d", aStatus);
	}

//Opens the default contacts database.
void CLogAddEvent::OpenContactsL()
	{
	//Sometimes, after a sequence of OpenContactsL()/CloseContacts() calls the Contacts server crashes
	//and OpenContactsL() leaves with error -15. In order to avoid that the following delay has been added.
	//(something related to Contacts server state machine)
    User::After(1000);
	// Attempt to open DB
	TRAPD(err,iContactPlugin->OpenContactsL());
	if(KErrNone!=err)
		{
		if(err == KErrServerTerminated)
		    {
		    RDebug::Print(_L("+++LogEng, LogAdd.cpp, Contacts server crashed!\r\n"));
		    }
		// If DB doesn't open delete plugin
		delete iContactPlugin;
		iContactPlugin = NULL;
		User::Leave(err);
		}
	}

//Closes the default contacts database and deletes the plugin.
void CLogAddEvent::CloseContactsPlugin()
	{
	if(iContactPlugin)
		{
		iContactPlugin->CloseContacts();
		delete iContactPlugin;
		iContactPlugin = NULL;
		//REComSession::FinalClose() call moved here from logcntmodel.cpp.
		//The in-source documentation of REComSession::FinalClose() notes that: 
		//"It must never be called from within a plug-in implementations class 
		//destructor, especially following a DestroyImplementation() ". 
		//That was the case before the function call was moved here.
	    REComSession::FinalClose();
		}
	}