/*

* Copyright (c) 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:  The implementation for presentation elements.

*

*/

#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;

    //CIRSessionDb object is deleted

    delete iLogSessionDb;

    //CIRNmsLogDb object is deleted

    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();

    Dll::FreeTls();

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

    }

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

// Function: ConstructL

// Two phase constructor

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

//    

void CIRReportGenerator::ConstructL()        

    {

    IRLOG_DEBUG( "CIRReportGenerator::ConstructL" );

    //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()

    {

    IRLOG_DEBUG( "CIRReportGenerator::SessionEndL" );

    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();

    }

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

// 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: 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

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

//

EXPORT_C void CIRReportGenerator::SetDbStatusObserser( 

        MIRLogDbStatusObserver *aDbStatusObserver )

{

    iDbStatusObserver = aDbStatusObserver;

}    

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

// Function: reportSent

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

//

EXPORT_C void CIRReportGenerator::ReportSent()

{

    iUnComfirmedReportSent = ETrue;

}    

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

// Function : ReponseFromISDSObtained

// This function is called when session log is successfully sent

// removes all session log entries from sessiondb

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

//

EXPORT_C void CIRReportGenerator::ReponseFromISDSObtained()

    {

    IRLOG_DEBUG( "CIRReportGenerator::ReponseFromISDSObtained" );

    iUnComfirmedReportSent = EFalse;

    TRAP_IGNORE( iLogSessionDb->DeleteAllSessionL() )

    TRAP_IGNORE( iNmsLogDb->DeleteAllNmsLogL() )

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

        {

        if ( iBrowseLog.Count() > 0 )

            iBrowseLog.Remove( 0 );

        }

    }    

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

// Function: CollectSettingsData

// collect information during starting of session

// like irid, version information.

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

//

void CIRReportGenerator::CollectSettingsData()

    {

    IRLOG_DEBUG( "CIRReportGenerator::CollectSettingsData" );

    _LIT( KData, "1.0" );

    _LIT( KIRID, "NO IRID" );