/*

* Copyright (c) 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:  Class definition of 

*

*/

#include <s32std.h>

#include <sysutil.h> 

#include <f32file.h> 

#include <centralrepository.h>

#include "diagresultsdbtestrecord.h"

#include "diagresultsdbstore.h"

#include "diagresultsdatabasecommon.h"

#include "diagresultsdbcrdc.h"

#include "diagresultsdatabase.h"

#include "diagresultsdbtestrecordhandle.h"

#include "diagresultsdbrecordengineparam.h"

#include "diagresultsdbprivatecrkeys.h"

_LIT( KFileType, ".dat" );

_LIT( KDriveC, "C:" );

const TInt KMininumDiskSpace = 500;

const TInt KFirstStreamId = 2;

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

// Constructor.

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

// 

CDiagResultsDbStore::CDiagResultsDbStore( TUid aDbUid ): 

        CActive( CActive::EPriorityStandard ), iStore( NULL ), 

        iDbUid( aDbUid ), iLoadingObserver( NULL ), iCompletionObserver( NULL ),

        iRecordArray( NULL ), iRecordIds(NULL), iRecordNumber(0), 

        iTestRecord( NULL ), iState( ENotRunning )

	{

	CActiveScheduler::Add(this);

	}

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

// NewL. Creates a DB file based on aDbUid if it does not exist.

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

// 

CDiagResultsDbStore* CDiagResultsDbStore::NewL( TUid aDbUid )

	{

	LOGME("CDiagResultsDbStore* CDiagResultsDbStore::NewL");

	CDiagResultsDbStore* store = new (ELeave) CDiagResultsDbStore( aDbUid );

	CleanupStack::PushL( store );

	store->ConstructL();

	CleanupStack::Pop();

	return store;

	}

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

// NewLC.

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

// 

CDiagResultsDbStore* CDiagResultsDbStore::NewLC( TUid aDbUid )

	{

	LOGME("CDiagResultsDbStore::NewLC");

	CDiagResultsDbStore* store = new (ELeave) CDiagResultsDbStore( aDbUid );

	CleanupStack::PushL( store );

	store->ConstructL();

	return store;

	}	

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

// Starts asynchronous loading of all test records from the DB.

// Observer is notified when test records have been loaded.

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

// 

void CDiagResultsDbStore::ExistingRecordsAsyncL( MRecordLoadingObserver& aObserver )

    {

    if ( IsActive() )

        {

        User::Leave( KErrInUse );

        }

    iLoadingObserver = &aObserver;

    iState = EGetRootStream;

    iRecordNumber = 0;

    CompleteOwnRequest();

    SetActive();

    }

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

// Cancel asynchronous functionality. Do not call this directly (use Cancel())

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

// 

void CDiagResultsDbStore::DoCancel()

    {

    if ( iRecordArray )

        {

        iRecordArray->ResetAndDestroy(); 

        delete iRecordArray;

        iRecordArray = NULL;   

        }

    //Note that Store is not responsible for deleting the iTestRecord.

    //iTestRecord is deleted by subsession.

    delete iRecordIds;

    iRecordIds = NULL;

    iState = ENotRunning;

    iRecordNumber = 0;

    }

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

// This is called if there are leaves or errors in RunL.

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

// 

TInt CDiagResultsDbStore::RunError(TInt aError)

    {

    TInt err = KErrNone;

    switch ( iState )

    	{

        case EGetRootStream:

        case EGetRecord:            

        case ERecordsReady:

            {

            TRAP( err, iLoadingObserver->ExistingRecordsL( aError, NULL ) );

            }

        break;

        default:

        	{

        	///@@@KSR: changes for Codescanner error val = High 

        	//User::Leave( aError );

        	}

    	}

    }

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

// Keeps the database file small as possible. Compacting must be done often as

// possible keeping in mind that compacting could take a long time.

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

// 

void CDiagResultsDbStore::CompactDatabase()

    {    

    TRAPD( error, iStore->CompactL());

    if ( error != KErrNone )

        {

        User::Panic(_L("compact error"), 

            DiagResultsDbCommon::EDatabaseCompact );

        }    

    else 

        {

        //Commit must be called in order to really reduce the size of DB file.

        TRAP( error, iStore->CommitL() ); 

        if ( error != KErrNone )

           {

           User::Panic(_L("compact/commit error"), 

           DiagResultsDbCommon::EDatabaseCompactCommit );

           }

        }

    }

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

// Completes own request. This changes the value of TRequestStatus and causes

// RunL to be called afterwards (if CActive is active).

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

// 

void CDiagResultsDbStore::CompleteOwnRequest()

    {

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    }

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

// Asynchronous handling function. States are needed to separate two different

// tasks. The first one is loading test records from the db file. The second

// is writing a test record into the DB file.

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

//     

void CDiagResultsDbStore::RunL()

    {

    switch ( iState )

        {

        case EGetRootStream:

            {

            iRecordArray = new (ELeave) RPointerArray<CDiagResultsDbTestRecord>;

            iRecordIds = new (ELeave) RArray<TStreamId>;

            // Find available stream ids

            ReadRootStreamL( *iRecordIds );

            if ( iRecordIds->Count() == 0 ) //no records, no need to continue

                {

                 //Ownership is transferred

                iLoadingObserver->ExistingRecordsL( KErrNone, iRecordArray );

                iRecordArray = NULL; //do not delete

                iRecordIds->Close();

                delete iRecordIds;

                iRecordIds = NULL;

                iState = ENotRunning;

                iRecordNumber = 0;   

                iLoadingObserver = NULL;

                return;

                }

            iState = EGetRecord;

            CompleteOwnRequest();

            SetActive();

            }

            break;

        case EGetRecord:

            {            

            iRecordArray->Append ( OpenExistingRecordL( 

                            TUid::Uid( (*iRecordIds)[iRecordNumber].Value()), ETrue ) );

            iRecordNumber++;

            if ( iRecordNumber < iRecordIds->Count() )

                {

                iState = EGetRecord;

                }

            else 

                {

                iState = ERecordsReady;

                }

            CompleteOwnRequest();

            SetActive();

            }

            break;

        case ERecordsReady:

            {

             //Ownership is transferred

            iLoadingObserver->ExistingRecordsL( KErrNone, iRecordArray );

            iRecordArray = NULL; //do not delete

            iRecordIds->Close();

            delete iRecordIds;

            iRecordIds = NULL;

            iState = ENotRunning;

            iRecordNumber = 0;   

            iLoadingObserver = NULL;

            }

            break;

        default:

            User::Leave( KErrNotFound );

            break;

        }

    }

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

// Constructs the store. Creates the DB file if it does not exist or opens it. 

// Also creates an empty root stream into the store if file was created.

// There is some exception handling included for example if file exist but it

// cannot be opened.

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

// 

void CDiagResultsDbStore::ConstructL()

	{	

	LOGME("CDiagResultsDbStore::ConstructL");		

	//Read from central repository.

	TInt algorithm = GetDeletionAlgorithmL();

	if ( algorithm == 0 )

		{

		iDeletionAlgorithm = EMaxRecordCountAlgorithm;

		}

	else if ( algorithm == 1 )

		{

		iDeletionAlgorithm = ELastResultsAlgorithm;

		}

	else 

		{

		User::Panic( _L("Unknown Deletion Algorithm"), 

                DiagResultsDbCommon::EUnknownDeletionAlgorithm);  

		}

	LOGME("resultdbstore::Before irfs.connect");

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

    LOGME("iRfs.connect");

    TBool tooLowSpace = SysUtil::DiskSpaceBelowCriticalLevelL( 

                                                    &iRfs, 

                                                    KMininumDiskSpace, 

                                                    EDriveC );

    LOGME1("tooLowSpace %d",tooLowSpace);

    if ( tooLowSpace )        

        {

        User::Leave( KErrDiskFull );

        }

    TInt err = iRfs.CreatePrivatePath( EDriveC );

    LOGME1("privatepathcreate %d",err);

    //Create private path if it does not exists

    if ( err != KErrAlreadyExists && err != KErrNone )

        {

        User::Leave ( err ); //Unexpected error

        }

    TBuf<256> filename;

    iRfs.PrivatePath( filename );

    filename.Insert( 0, KDriveC );

    filename.Append( iDbUid.Name() );

    filename.Append( KFileType );

    //Check is the File already there

    //open for reading and writing.

    err = iFile.Open( iRfs, filename, EFileShareAny|EFileWrite );  

    LOGME1("ifile.open %d",err);

    TInt fileError = KErrNotFound;

    TInt fileSize = 0;

    if ( err == KErrNone )

        {        

        fileError = iFile.Size( fileSize );    

        }

    //Checking is done when the file exists. 

    //File size reading error should never happen.

    //if the file is too large, the function will panic.

    if ( err == KErrNone && fileError == KErrNone )

    	{

    	CheckMaximumFileSizeLimitL( iRfs, filename, fileSize ); 

    	}

    iFile.Close();

    // File exist

    if ( err == KErrNone )

        {                           

        TRAPD( err, iStore = CPermanentFileStore::OpenL(iRfs, filename, 

                        EFileShareAny|EFileWrite|EFileRead|EFileStream ));

        if ( err != KErrNone )

            {           

            err = iRfs.Delete ( filename );

            if ( err != KErrNone )

                {

                User::Panic( _L("DiagServer corrupt file delete failed"), 

                        DiagResultsDbCommon::EServerCorruptFileDelete);

                }

            User::Leave( KErrCorrupt );

            }

        //This must be called, otherwise RStoreWriteStream write will fail.

        iStore->SetTypeL( iStore->Layout() );

        }

    else if ( err == KErrNotFound ) //Create new file  if the file is not found

        {

        LOGME("createnewfile");

        TRAPD( err, iStore = CPermanentFileStore::CreateL(iRfs, filename, 

                        EFileShareAny|EFileWrite|EFileRead|EFileStream ));

        LOGME1("createnewfile = %d",err);

        if ( err != KErrNone ) //File could not be created for some reason

            { 

             LOGME1("createnewfile panic = %d",err);

            User::Panic( _L("DiagServer unable to create DB file"), 

                            DiagResultsDbCommon::EServerFileCreationError);          

            }

        //This must be called, otherwise RStoreWriteStream write will fail.

        iStore->SetTypeL( iStore->Layout() );

        CreateEmptyRootStreamL( *iStore );

        if ( iDeletionAlgorithm == ELastResultsAlgorithm )

        	{

        	CreateLastResultsBufferStreamL();

        	}

        iStore->CommitL();

        }

    else 

        {

        LOGME1("else userleave = %d",err);

        User::Leave( err );

        }

	}

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

// Get central repository key that controls maximum file size.

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

//

TInt CDiagResultsDbStore::GetMaximumFileSizeL()

	{

	CRepository* cr = CRepository::NewLC( KCRUidDiagnosticsResults );

	TInt result = 0;	

	TInt error = cr->Get( KDiagDatabaseMaxFileSize, result );

	CleanupStack::PopAndDestroy();

	if ( error != KErrNone )

		{

		User::Leave(error);

		}

	return result;

	}

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

// Get central repository key that controls usage of the deletion algorithm.

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

//

TInt CDiagResultsDbStore::GetDeletionAlgorithmL()

	{

	CRepository* cr = CRepository::NewLC( KCRUidDiagnosticsResults );

	TInt result = 0;	

	TInt error = cr->Get( KDiagDatabaseDeletionAlgorithm, result );

	CleanupStack::PopAndDestroy();

	if ( error != KErrNone )

		{

		User::Leave(error);

		}

	return result;

	}

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

// Check DB file size and delete the file if it is too big.

// Checking is controlled by a central repository key.

//

// Note that this function deletes the file and after that panics, because

// the error is very serious. 

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

//

void CDiagResultsDbStore::CheckMaximumFileSizeLimitL( RFs& aRfs, 

													  const TDesC& aFileName,

													  TInt aFileSize )

	{

	//Read central repository value

	TInt maxFileSize = GetMaximumFileSizeL();

	//If == 0, feature is disabled i.e. there is no limitation

	//to the size of DB files.

	if ( maxFileSize == 0 )

		{

		return;		

		}

	else

		{

		if ( aFileSize > maxFileSize )

			{

			//Delete the file. 

			aRfs.Delete( aFileName );		

			User::Panic(_L("Maxfile Size exceeded"), 

			            DiagResultsDbCommon::EMaximumFileSizeExceeded );

			}

		}	

	}

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

// Create a stream for last results.

// The stream is created when DB file is created.

// 

// Because this is the first stream in the PermanentFileStore,

// we do not need to store the stream ID anywhere. Consider it as a constant.

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

//

void CDiagResultsDbStore::CreateLastResultsBufferStreamL()

    {        

    RArray<TUid>* uids = new (ELeave) RArray<TUid>;

    CDiagResultsDbRecordEngineParam* params = 

        CDiagResultsDbRecordEngineParam::NewL( uids, EFalse );

    CleanupStack::PushL( params );

    TStreamId id = iStore->ExtendL();

    //We assume that the permanent file store uses this as the first stream ID.

    __ASSERT_ALWAYS( id == TStreamId( KFirstStreamId ), 

                        User::Panic( _L("DiagServer Incorrect Last Results Buffer"), 

                        DiagResultsDbCommon::EIncorrectExtendNumberForLastResults)  );

    CleanupStack::Pop();

    CDiagResultsDbTestRecordHandle* handle = CDiagResultsDbTestRecordHandle::NewL( 

                                                    id, 

                                                    iDbUid, 

                                                    params );

    CleanupStack::PushL( handle );

    WriteHandleIntoDbL( *handle ); //writes a new stream

    //Do not append on to the root stream!!

    //this should be visible only for the server.                  

    CleanupStack::PopAndDestroy();                                

    }