/*

* Copyright (c) 2006-2007 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:  ?Description

*

*/

#include <coemain.h>

#include <ezgzip.h>

#include <sysutil.h>

#include <utf.h>

#include <etel3rdparty.h>

#include <imcvcodc.h>

#include "irdebug.h"

#include "irreportsettings.h"

#include "irsessiondb.h"

#include "irsessionlogger.h"

#include "irsessionloggerutility.h"

#include "irsettings.h"

#include "irnmslogdb.h"

#include "irnmslogger.h"

#include "irdbstatusobserver.h"

#include "irphoneinfo.h"

const TUint KFieldPosition = 5;

const TInt KAmpMaxLength = 5;

const TInt KFormatBuffMaxLength = 6;

const TInt KMaxUrlSize = 256;

const TUint KSessionLogGranularity = 4;

const TUint KNmsLogGranularity = 5;

const TUint KSessionLogThreshold = 5; // Session Log Maximum 15

const TUint KNmsLogThreshold = 5;     // Nms Log Maximum 15

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

// Function: OpenL

// Two phase constructor returns the instance of CIRReportGenerator

// this is a single ton implementation

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

//

EXPORT_C CIRReportGenerator* CIRReportGenerator::OpenL()

	{

	IRLOG_DEBUG( "CIRReportGenerator::OpenL" );

    CIRReportGenerator* reportGenerator = reinterpret_cast<CIRReportGenerator*>(Dll::Tls());

    if (reportGenerator)

        {

        User::LeaveIfError(reportGenerator->Open());

	    IRLOG_INFO( "CIRReportGenerator::OpenL - Opened singleton for new user." );

        }

    else

        {

        reportGenerator = new (ELeave) CIRReportGenerator;

        CleanupClosePushL(*reportGenerator);

        reportGenerator->ConstructL();

        User::LeaveIfError(Dll::SetTls(reportGenerator));

        CleanupStack::Pop(reportGenerator);

	    IRLOG_INFO( "CIRSessionLogger::OpenL - Created the CIRReportGenerator singleton." );

        }

	IRLOG_DEBUG( "CIRReportGenerator::OpenL - Exiting." );

    return reportGenerator;

	}

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

// Function: ~CIRReportGenerator

// default destructor

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

//

CIRReportGenerator::~CIRReportGenerator()	

	{

	IRLOG_DEBUG( "CIRReportGenerator::~CIRReportGenerator" );

	delete iImeiBase64;

	iImeiBase64 = NULL;

	delete iPhoneInfo;

	iPhoneInfo = NULL;

	//operation settings instance is removed

	if( iSettingsData )

		{

		iSettingsData->Close(); // delete is handled like this.

		}

	delete iSessionLog;

	delete iNmsLog;

	delete iLogSessionDb;

	delete iNmsLogDb;

	//session data is also removed

	if (iSessionData)

	    {

	    iSessionData->ResetAndDestroy();

	    }

	delete iSessionData;

	//NmsLog data is also removed

	if (iNmsLogData)

	    {

	    iNmsLogData->ResetAndDestroy();

	    }

	delete iNmsLogData;

	iBrowseLog.Close(); //browse log array is closed

	iLogFile.Close();

	//file session is closed

	iFsSession.Close();

	delete iPreviousSessionLog;

	delete iPreviousNmsLog;

	Dll::FreeTls();

	IRLOG_DEBUG( "CIRReportGenerator::~CIRReportGenerator - Exiting." );	

	}

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

// Function: ConstructL

// Two phase constructor

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

//	

void CIRReportGenerator::ConstructL()		

	{

	IRLOG_DEBUG( "CIRReportGenerator::ConstructL" );

	iSessionEndCalled = 0;

	//file session is connected

	//Create the IROperation Settings Instance

	iSettingsData = CIRSettings::OpenL();

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

	//session logger is created

	iSessionLog = CIRSessionLogger::NewL();

   	//session logger is created

	iNmsLog = CIRNmsLogger::NewL();

    //session db is created

    iLogSessionDb = CIRSessionDb::NewL();

    //NmsLog db is created

    iNmsLogDb = CIRNmsLogDb::NewL();

    iSessFile =iSettingsData->PrivatePath();

	iSessFile.Append(KSession);

  	TInt error = iLogSessionDb->CreateDbConditional(iSessFile);

	if ( error )

		{

		iSessionDbCreationFailed = ETrue;

		}

	else

		{

		iSessionDbCreationFailed = EFalse;	

		}

    iNmsLogFile =iSettingsData->PrivatePath();

	iNmsLogFile.Append(KNmsLog);

  	TInt nmsError = iNmsLogDb->CreateDbConditional(iNmsLogFile);

	if ( nmsError )

		{

		iNmsDbCreationFailed = ETrue;

		}

	else

		{

		iNmsDbCreationFailed = EFalse;	

		}

  	//session log for five session are to be stored

  	//and is stored in session data  	

	iSessionData = new (ELeave) CArrayPtrFlat<CIRSessionLogger>(KSessionLogGranularity);

	iNmsLogData = new (ELeave) CArrayPtrFlat<CIRNmsLogger>(KNmsLogGranularity);

	iPhoneInfo = CPhoneInfo::NewL(this);

	iPhoneInfo->StartUpdating();

	IRLOG_DEBUG( "CIRReportGenerator::ConstructL - Exiting." );	

	}

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

// Function: CIRReportGenerator

// default constructor

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

//

CIRReportGenerator::CIRReportGenerator():iPhoneInfo(NULL),

                                         iDbStatusObserver(NULL),

                                         iNmsLogDbUpdated(EFalse),

                                         iSessionLogDbUpdated(EFalse),

                                         iUnComfirmedReportSent(EFalse),

                                         iSessionLogUpdationFailed(EFalse),

                                         iNmsLogUpdationFailed(EFalse),

                                         iSessionDbCreationFailed(EFalse),

                                         iNmsDbCreationFailed(EFalse),

                                         iImeiBase64(NULL)

	{

	//No Implementation	

	}

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

// Function: LogServerResult

// logs server connection result

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

//

EXPORT_C void CIRReportGenerator::LogServerResult(const TDesC& aUrl,TResponse aResult)	

	{

	iSessionLog->LogServerResult(aUrl,aResult);

	}

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

// Function: LogSongRecog

// logs song recog

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

//

EXPORT_C void CIRReportGenerator::LogSongRecog()  

    {

    //taking the session start time in GMT    

    iSongRecogTimestamp.UniversalTime();

    TTimeIntervalSeconds offset(iSettingsData->TimeCorrection());

    iSongRecogTimestamp -= offset;

    iDate = iSongRecogTimestamp.DateTime();

    TBuf<64> songRecogTimestamp;

    FormatDateTime(songRecogTimestamp,iDate);

    iSessionLog->LogSongRecog(songRecogTimestamp);

    }

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

// Function: UpdateCurrentBrowseNetwork

// logs network browsing

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

//

EXPORT_C void CIRReportGenerator::UpdateCurrentBrowseNetwork(TInt aNetwork)

	{

	iCurrentBrowseNetwork = aNetwork;

	}

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

// Function: LogBrowse

// logs browse url and status information

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

//	

EXPORT_C void CIRReportGenerator::LogBrowse(const TDesC8& aUrl,TInt aStatus)	

	{

	IRLOG_DEBUG( "CIRReportGenerator::LogBrowse" );

	//browse url is copied

	iRBrowseLog.iBrowseUrl.Copy(aUrl);

	//time stamp in GMT is onbtained

	iBrowseLogTimeStamp.UniversalTime();

	TInt time_val = 0;

    time_val = iSettingsData->TimeCorrection();

	TTimeIntervalSeconds offset(time_val);

	iBrowseLogTimeStamp -= offset;

	iDate = iBrowseLogTimeStamp.DateTime();

	//formated

	FormatDateTime(iRBrowseLog.iTimeStamp,iDate);

	_LIT(KFormat,"%d");

	(iRBrowseLog.iCurrentNetwork).Format(KFormat,

									iCurrentBrowseNetwork);	

	//status is stored

	iRBrowseLog.iStatus = aStatus;

	TRAP_IGNORE(iBrowseLog.AppendL(iRBrowseLog))

	IRLOG_DEBUG( "CIRReportGenerator::LogBrowse - Exiting." );

	}

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

// Function: SessionStartedL

// starts a new session

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

//

EXPORT_C void CIRReportGenerator::SessionStartedL()

	{

	IRLOG_DEBUG( "CIRReportGenerator::SessionStartedL" );

	//gets the session id for new session

	iSessionLog->ResetResource();

	iSessionLog->UpdateSessionId(iSettingsData->GetLogRunningNo());

	iSettingsData->SetLogRunningNoL();

	iFileWritePos = 0;	

	iLogFilePath = iSettingsData->PrivatePath();

	iLogFilePath.Append(KLogFileName);

    //taking the session start time in GMT    

	iSessionStartTime.UniversalTime();

	iSessionLog->UpdateSessionStartGMTTime();

	TTimeIntervalSeconds offset(iSettingsData->TimeCorrection());

	iSessionStartTime -= offset;

	iDate = iSessionStartTime.DateTime();

	FormatDateTime(iSessionLog->StartTime(),iDate);

	iSessionLog->UnMarkSession();

	//collect the neccessary information	

	CollectSettingsData();

	iSessionLogUpdationFailed = EFalse;

	//start adding the intial information in db	

	IRLOG_DEBUG( "CIRReportGenerator::SessionStartedL - Exiting." );	

	}

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

// Function: NmsLogStartedL

// starts a new nmslog

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

//

EXPORT_C void CIRReportGenerator::NmsLogStartedL()

	{

	IRLOG_DEBUG( "CIRReportGenerator::SessionStartedL" );

	iNmsTimestamp.UniversalTime();

	TInt time_val = 0;

	time_val = iSettingsData->TimeCorrection();

	TTimeIntervalSeconds offset(time_val);

	iNmsTimestamp -= offset;

	iDate = iNmsTimestamp.DateTime();

	//formated

	FormatDateTime(iNmsLog->StartTime(),iDate);	

	iNmsLogUpdationFailed = EFalse;

	//start adding the intial information in db	

	IRLOG_DEBUG( "CIRReportGenerator::SessionStartedL - Exiting." );	

	}

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

// Function: SessionEnd

// marks the a session

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

//

EXPORT_C void CIRReportGenerator::SessionEndL( TBool aForcedTermination )

	{

	IRLOG_DEBUG( "CIRReportGenerator::SessionEndL" );

	iSessionEndCalled++;

	//session end

	if( aForcedTermination )

		{

		//forced ending of session log

		ForcedSessionEndedL();

		}

	else

		{

		//unforced ending of session log

		iSessionLog->EndLogging();

		UnForceSessionEndedL(iSessionLog);	

		}	

	IRLOG_DEBUG( "CIRReportGenerator::SessionEndL - Exiting." );

	}

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

// Function: UpdateTerminatedBy

// updates the termination status

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

//

EXPORT_C void CIRReportGenerator::UpdateTerminatedBy(TTerminationStatus 

	aTerminatedBy)

	{

	IRLOG_DEBUG( "CIRReportGenerator::UpdateTerminatedBy" );

	iSessionLog->UpdateTerminationStatus(aTerminatedBy);		

	}

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

// Function: GetConnectedFrom

// connected information is stored

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

//	

EXPORT_C void CIRReportGenerator::UpdateConnectedFrom(TConnectedFrom aConnectedFrom)

	{

	IRLOG_DEBUG( "CIRReportGenerator::UpdateConnectedFrom" );

	iSessionLog->GetConnectedFrom(aConnectedFrom);

	}

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

// Function: BrowseUrl

// logs browse url and result

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

//

EXPORT_C void CIRReportGenerator::BrowseUrl(const TDesC& aBrowseUrl,

													TInt aStatus)

	{

	IRLOG_DEBUG( "CIRReportGenerator::BrowseUrl" );

	_LIT(KAmp,"&");

	TBuf8<KAmpMaxLength> amp;

	amp.Copy(KAmp);	

	TBuf8<KMaxUrlSize> url;

	url.Copy(aBrowseUrl);

	_LIT8(KAmpnd,"&");

	TInt pos = url.Find(KAmpnd);

	if(pos > 0)

		{

		url.Replace(pos,1,amp);	

		}

	LogBrowse(url,aStatus);

	IRLOG_DEBUG( "CIRReportGenerator::BrowseUrl - Exiting." );

	}

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

// Function: UpdateChannelID

// updates the channel id

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

//

EXPORT_C void CIRReportGenerator::UpdateChannelID(TInt aChanneldID)

	{

	IRLOG_DEBUG( "CIRReportGenerator::UpdateChannelID" );

	iSessionLog->UpdateChannelID(aChanneldID);

	}

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

// Function: UpdateCurrentNetwork

// updates the current network

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

//

EXPORT_C void CIRReportGenerator::UpdateCurrentNetwork(TInt aCurrentNetwork)

	{

	IRLOG_DEBUG( "CIRReportGenerator::UpdateCurrentNetwork" );

	iSessionLog->UpdateCurrentNetwork(aCurrentNetwork);

	}

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

// Function: UpdateHomeOperator

// updates the home network

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

//

EXPORT_C void CIRReportGenerator::UpdateHomeOperator(TInt aHomeOperator)

	{

	IRLOG_DEBUG( "CIRReportGenerator::UpdateHomeOperator" );

	iSessionLog->UpdateHomeOperator(aHomeOperator);

	}

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

// Function: MarkSessionStart

// updates the termination status

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

//

EXPORT_C void CIRReportGenerator::MarkSessionStart()

	{

	iSessionStartTime.UniversalTime();

	TInt time_val = 0;

	time_val = iSettingsData->TimeCorrection();

	TTimeIntervalSeconds offset(time_val);

	iSessionStartTime -= offset; 

	iDate = iSessionStartTime.DateTime();

	FormatDateTime(iSessionLog->StartTime(),iDate);

	//setting session start time

	iSessionLog->UpdateSessionStartGMTTime();

	iSessionLog->MarkSession();		

	if( iPreviousSessionLog )

		{

		//if previous session exist it added to the log

		TRAP_IGNORE( UnForceSessionEndedL(iPreviousSessionLog) )

		delete iPreviousSessionLog;

		iPreviousSessionLog = NULL;	

		}

	}

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

// Function: HandleStopEvents

// function handles session state changes

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

//

EXPORT_C void CIRReportGenerator::HandleStopEvents(TBool aIsSessionProgressing )

	{

	IRLOG_DEBUG( "CIRReportGenerator::HandleStopEvents" );

	if( !aIsSessionProgressing )

		{

		iSessionLog->HandleStopEvents();

		}

	else

		{

		iSessionLog->HandleStartEvents();

		}

	IRLOG_DEBUG( "CIRReportGenerator::HandleStopEvents - Exiting." );

	}

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

// Function: ReStorePreviousSession

// restore the previous session

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

//

EXPORT_C TBool CIRReportGenerator::ReStorePreviousSession()

	{

	if( iPreviousSessionLog )

		{

		//if previous session exist that is restored

		//ETrue is returned.

		iSessionLog->GetBackedUp(*iPreviousSessionLog);

		delete iPreviousSessionLog;

		iPreviousSessionLog = NULL;

		return ETrue;	

		}

	else

		{

		//if previous session doesn't exist EFalse is returned

		return EFalse;	

		}

	}

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

// Function: UpdateConnectionType

// updates the connection type

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

//

EXPORT_C void CIRReportGenerator::UpdateConnectionType(const TDesC& 

	aConnectionType)

	{

	IRLOG_DEBUG( "CIRReportGenerator::UpdateConnectionType" );

	iSessionLog->UpdateConnectionType(aConnectionType);

	}

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

// Function: UpdateNmsType

// updates the connection type

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

//

EXPORT_C void CIRReportGenerator::UpdateNmsType(const TDesC& aNmsType)

	{

	IRLOG_DEBUG( "CIRReportGenerator::UpdateNmsType" );

	iNmsLog->UpdateNmsType(aNmsType);

	}

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

// Function: SetDbStatusObserser

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

//