/*

* Copyright (c) 2006 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:  This file defines the clean up handler

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <lbtcommon.h>

#include <f32file.h>

#include <s32file.h>

#include <centralrepository.h>

#include "lbtcleanuphandler.h"

#include "lbtcontainer.h"

#include "lbtcontainerupdatefilter.h"

#include "lbttriggerfilterbyattribute.h"

#include "lbttriggeringsettingskeys.h"

#include "lbtlogger.h"

// LOCAL ENUMERATIONS

enum

	{

	TLbtNone,

	TLbtContainerCleaningUp,

	TLbtWaitingForTimer

	};

// CONSTANTS

_LIT(KLbtAppCleanupFileName, "lbtappcleanup.dat");

// ======== LOCAL FUNCTIONS ========

TInt CleanupItemOrder( const CLbtCleanupItem& aFirst, const CLbtCleanupItem& aSecond )

	{

	FUNC_ENTER("CleanupItemOrder");

	const TTime& aFirstTime = aFirst.GetTime();

	const TTime& aSecondTime = aSecond.GetTime();

	if( aFirstTime == aSecondTime )

		{

		return 0;

		}

	else if( aFirstTime < aSecondTime )

		{

		return -1;

		}

	else

		{

		return 1;

		}

	}

// ============ CLASS METHODS ==========

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

// CLbtCleanupHandler::NewL

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

//

CLbtCleanupHandler* CLbtCleanupHandler::NewL( CLbtContainer& aContainer )

	{

	FUNC_ENTER("CLbtCleanupHandler::NewL");	

	CLbtCleanupHandler* self = new (ELeave) CLbtCleanupHandler( aContainer );

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

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

// CLbtCleanupHandler::ConstructL

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

//

void CLbtCleanupHandler::ConstructL()

	{

	FUNC_ENTER("CLbtCleanupHandler::ConstructL");

	CTimer::ConstructL();	

	iOperation = TLbtNone;

	CRepository* repository = CRepository::NewL(TUid::Uid(KCRUidLocationTriggeringSettings));

	repository->Get(ELbtDaysForCleanup, iDaysForCleanup);

	delete repository;

	ReadCleanupDataFromFileL();

	CleanupNextItemL();

	}

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

// CLbtCleanupHandler::AddTriggersForCleanupL

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

//	

void CLbtCleanupHandler::AddTriggersForCleanupL( const RArray<TLbtTriggerId>& aTriggers )

	{

	FUNC_ENTER("CLbtCleanupHandler::AddTriggersForCleanupL");

	CLbtCleanupItem* item = new(ELeave) CLbtCleanupItem;

	TTime utcTime;

	utcTime.UniversalTime();

	TTimeIntervalDays cleanupDays(iDaysForCleanup);

	utcTime += cleanupDays;

	item->AddCleanupItem( aTriggers, utcTime );

	TLinearOrder<CLbtCleanupItem> order(CleanupItemOrder);

	iCleanupItems.InsertInOrder( item, order );

	WriteCleanupDataToFileL();

	CleanupNextItemL();

	}

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

// CLbtCleanupHandler::RemoveTriggersFromCleanupL

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

//	

void CLbtCleanupHandler::RemoveTriggersFromCleanupL( const RArray<TLbtTriggerId>& aTriggers )

	{

	FUNC_ENTER("CLbtCleanupHandler::RemoveTriggersFromCleanupL");

	// Bool to check if at the end of removal, current cleanup have to be aborted

	TBool cancelCleanup = EFalse;

	// Parse through cleanup items

	for( TInt j=0;j<iCleanupItems.Count();++j )

		{

		RArray<TLbtTriggerId>& array = iCleanupItems[j]->GetTriggers();

		for( TInt i=0;i<aTriggers.Count();++i )

			{

			TInt index = array.Find( aTriggers[i] );

			if( index != KErrNotFound )

				{

				array.Remove(index);

				}

			}

		if( array.Count() == 0 )

			{

			CLbtCleanupItem* item = iCleanupItems[j];

			iCleanupItems.Remove(j);

			delete item;

			if( j==0 )

				{

				cancelCleanup = ETrue;

				}			

			}

		}

	if( cancelCleanup )

		{

		Cancel();

		}

	WriteCleanupDataToFileL();

	CleanupNextItemL();

	}

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

// CLbtCleanupHandler::CleanupNextItemL

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

//	

void CLbtCleanupHandler::CleanupNextItemL()

	{

	FUNC_ENTER("CLbtCleanupHandler::CleanupNextItemL");

	if( iCleanupItems.Count() > 0 &&

	    !IsActive() )

		{

		const TTime& utcTime = iCleanupItems[0]->GetTime();

		// First get the universal time

		TTime time;

		time.UniversalTime();

		if( time > utcTime )

			{

			// The UT has already elapsed

			LOG("Provided UTC has already elapsed. Cleaning up Immediately");

			iOperation = TLbtContainerCleaningUp;

			// Get the trigger ids

			RArray<TLbtTriggerId>& triggers = iCleanupItems[0]->GetTriggers();

			CLbtTriggerFilterByAttribute* filterByAttribute = CLbtTriggerFilterByAttribute::NewL();

			CleanupStack::PushL(filterByAttribute);

			// Cleanup startup triggers

			filterByAttribute->AddTriggerTypeL(CLbtTriggerEntry::ETypeStartup);

			// Add the trigger ids trhat need to be cleanedup

			for( TInt i=0;i<triggers.Count();++i )

				{

				filterByAttribute->AddTriggerIdL( triggers[i] );

				}

			CLbtContainerUpdateFilter* updateFilter = CLbtContainerUpdateFilter::NewL( filterByAttribute ,NULL );		

			iContainer.DeleteTriggers( updateFilter, iContainerOp, iStatus );

			SetActive();

			CleanupStack::Pop(filterByAttribute);

			}

		else

			{

			if( !IsActive() )

				{

				LOG("Waiting for Provided UTC")

				// Wait for timer expiry

				iOperation = TLbtWaitingForTimer;

				AtUTC(utcTime);

				}			

			}

		}

	}

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

// CLbtCleanupHandler::Cancel

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

//	

void CLbtCleanupHandler::Cancel()

	{

	FUNC_ENTER("CLbtCleanupHandler::Cancel");

	if( IsActive() )

		{

		if( iOperation == TLbtContainerCleaningUp )

			{

			iContainer.CancelAsyncOperation( iContainerOp );		

			}

		else if( iOperation == TLbtWaitingForTimer )

			{

			CTimer::Cancel();

			}

		}

	iOperation = TLbtNone;

	}

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

// CLbtCleanupHandler::RunL

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

//	

void CLbtCleanupHandler::RunL()

	{

	FUNC_ENTER("CLbtCleanupHandler::RunL");

	LOG1("iOperation %d",iOperation);

	if( iStatus.Int() != KErrNone )

		{

		LOG1("CLbtCleanupHandler, iStatus = %d", iStatus.Int());

		return;

		}

	switch(iOperation)

		{

		case TLbtContainerCleaningUp: 

			{

			CLbtCleanupItem* item = iCleanupItems[0];

			iCleanupItems.Remove(0);

			delete item;

			iOperation = TLbtNone;

			WriteCleanupDataToFileL();

			CleanupNextItemL();

			break;

			}

		case TLbtWaitingForTimer:

			{

			LOG("Timer has expired. Cleaning triggers");

			iOperation = TLbtContainerCleaningUp;

			// Get the trigger ids

			RArray<TLbtTriggerId>& triggers = iCleanupItems[0]->GetTriggers();

			CLbtTriggerFilterByAttribute* filterByAttribute = CLbtTriggerFilterByAttribute::NewL();

			CleanupStack::PushL(filterByAttribute);

			// Cleanup startup triggers

			filterByAttribute->AddTriggerTypeL(CLbtTriggerEntry::ETypeStartup);

			// Add the trigger ids trhat need to be cleaned up

			for( TInt i=0;i<triggers.Count();++i )

				{

				filterByAttribute->AddTriggerIdL( triggers[i] );

				}

			CLbtContainerUpdateFilter* updateFilter = CLbtContainerUpdateFilter::NewL( filterByAttribute ,NULL );		

			iContainer.DeleteTriggers( updateFilter, iContainerOp, iStatus );

			SetActive();

			CleanupStack::Pop(filterByAttribute);

			break;

			}

		default:

			{

			iOperation = TLbtNone;

			break;

			}

		}

	}

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

// CLbtCleanupHandler::RunError

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

//	

TInt CLbtCleanupHandler::RunError( TInt aError )

	{

	FUNC_ENTER("CLbtCleanupHandler::RunError");

	ERROR("CLbtCleanupHandler::RunL left with error code", aError);

	return KErrNone;

	}

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

// CLbtCleanupHandler::WriteCleanupDataToFileL

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

//

void CLbtCleanupHandler::WriteCleanupDataToFileL()

	{

	FUNC_ENTER("CLbtCleanupHandler::WriteCleanupDataToFileL");	

	RFs fs;

	User::LeaveIfError( fs.Connect() );

	CleanupClosePushL( fs );

    // Obtain the file path

    TFileName file;

    // Gets the path in which the file can be created

    fs.SessionPath(file);

    // Create the file Directory ie the private directory of the process

    fs.MkDirAll(file);

    // Append the name of the file

    file.Append(KLbtAppCleanupFileName);

    // Open write stream to write to the file

    RFileWriteStream writeStream;

    // Open the file to replace the contents. If the file is not preset

    // this method will create the file

    TInt error = writeStream.Replace( fs, file, EFileWrite );    

    if( error != KErrNone )

    	{

    	ERROR("Opening of cleanup file failed with : %d", error);

    	writeStream.Close();

    	CleanupStack::PopAndDestroy(); //fs

    	User::Leave(error);

    	}

    CleanupClosePushL( writeStream );

    // First write the number of cleanup items

    writeStream.WriteInt16L( iCleanupItems.Count() );

	for(TInt i=0;i<iCleanupItems.Count();++i)

		{

		RArray<TLbtTriggerId>& triggers = iCleanupItems[i]->GetTriggers();

		// Write the trigger ids into the file

		writeStream.WriteInt16L( triggers.Count() );

		for(TInt j=0;j<triggers.Count();++j)

			{

			writeStream.WriteUint32L( triggers[j] );

			}

		// Write the time into the file

		const TDateTime dateTime = iCleanupItems[i]->GetTime().DateTime();

		// Write the year

		writeStream.WriteInt32L( dateTime.Year() );

		// Write the month

		writeStream.WriteInt32L( dateTime.Month() );

		// Write the day

		writeStream.WriteInt32L( dateTime.Day() );

		}

    CleanupStack::PopAndDestroy(2); //fs and writeSteam    

	}

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

// CLbtCleanupHandler::ReadCleanupDataFromFileL

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

//

void CLbtCleanupHandler::ReadCleanupDataFromFileL()

	{

	FUNC_ENTER("CLbtCleanupHandler::ReadCleanupDataFromFileL");

	// First reset the cleanup data 

	iCleanupItems.ResetAndDestroy();

	// Open handle to file system

	RFs fs;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

	// Obtain the file path

    TFileName file;

    // Gets the path in which the file can be created

    fs.SessionPath(file);

    // Create the file Directory ie the private directory of the process

    fs.MkDirAll(file);

    // Append the name of the file

    file.Append(KLbtAppCleanupFileName);

    // Open read stream

    RFileReadStream readStream;

    TInt error = readStream.Open( fs, file, EFileRead );

    if( error != KErrNone )

    	{

    	// File may not exists

    	ERROR("Opening of cleanup file failed with : %d", error);

    	readStream.Close();

    	CleanupStack::PopAndDestroy(); //fs

    	return;

    	}

    CleanupClosePushL( readStream );

    // Get the count in the cleanup array

    TInt count = readStream.ReadInt16L();    

    for(TInt i=0; i<count; ++i)

    	{

    	RArray<TLbtTriggerId> triggers;

    	CleanupClosePushL(triggers);

    	// Read the trigger ids

    	TInt triggerCount = readStream.ReadInt16L();

    	for(TInt j=0;j<triggerCount;++j)

    		{

    		triggers.Append( readStream.ReadUint32L() );

    		}

    	// Read the universal time

    	TInt year = readStream.ReadInt32L();

    	TMonth month = static_cast<TMonth>( readStream.ReadInt32L() );

    	TInt day = readStream.ReadInt32L();

    	TDateTime dateTime( year,

    						month,

    						day,

    						0,

    						0,

    						0,

    						0 );

    	TTime time( dateTime );

    	CLbtCleanupItem* cleanupItem = new (ELeave) CLbtCleanupItem();

    	cleanupItem->AddCleanupItem( triggers, time );

    	CleanupStack::Pop(); // triggers

    	triggers.Close();

    	// Append cleanup item to the cleaup items array

    	iCleanupItems.Append( cleanupItem );

    	}

    CleanupStack::PopAndDestroy(2); // fs and readStream

	}

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

// CLbtCleanupHandler::~CLbtCleanupHandler

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

//	

CLbtCleanupHandler::~CLbtCleanupHandler()

	{

	FUNC_ENTER("CLbtCleanupHandler::~CLbtCleanupHandler");

	Cancel();	

	iCleanupItems.ResetAndDestroy();

	}

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

// CLbtCleanupHandler::CLbtCleanupHandler

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

//

CLbtCleanupHandler::CLbtCleanupHandler( CLbtContainer& aContainer ): 

					CTimer(CActive::EPriorityLow),

					iContainer( aContainer )

	{

	CActiveScheduler::Add(this);

	}

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

// CLbtCleanupItem::AddCleanupItem

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

//

void CLbtCleanupItem::AddCleanupItem( const RArray<TLbtTriggerId>& aTriggers, TTime& aUTCTime )

	{

	FUNC_ENTER("CLbtCleanupItem::AddCleanupItem");

	iTriggers.Reset();	

	for(TInt i=0;i<aTriggers.Count();++i)

		{

		iTriggers.Append( aTriggers[i] );

		}

	iUTCTime = aUTCTime;

	}

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

// CLbtCleanupItem::GetTime

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

//

const TTime& CLbtCleanupItem::GetTime() const

	{

	return iUTCTime;

	}

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

// CLbtCleanupItem::GetTriggers

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

//

RArray<TLbtTriggerId>& CLbtCleanupItem::GetTriggers()

	{

	return iTriggers;

	}

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

// CLbtCleanupItem::~CLbtCleanupItem