/*

* Copyright (c) 2002 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:  Implementation of core part of Notepad Model.

*

*/

// INCLUDE FILES

#include <txtglobl.h>

#include <barsread.h>

#include <eikenv.h>

#include "NpdModel_platsec.h"

#include "NpdLib.hrh"

#include "NpdLib.h"

#include "NpdUtil.h"

#include "NpdLibPanic.h"

// next is for KNotepadPseudoKeyIdForNewNote.

//

#include "NpdApi.h"

#include "AknUtils.h"

// CONSTANTS

_LIT(KNotepadKey, "key");

_LIT(KNotepadUpdateTime, "time");

_LIT(KNotepadMemo, "memo");

_LIT(KNotepadTableName, "Table1");

_LIT(KNotepadSqlInsert, "SELECT * FROM Table1");

_LIT(KNotepadSqlFormatSeek, "SELECT * FROM Table1 WHERE key=%d");

const TUid KSecureUid = {0x101F8878};

_LIT(KSecure,	"SECURE");

const TInt KNotepadSqlStringMaxLength(128);

const TInt KNotepadLanguagePostfixWidth(2); // TLanuguage is 00 -- 99

const TInt KNotepadModelMinimumEntrySize(24);

const TInt KNotepadModelMinimumDataFileSize(300);

const TInt KNotepadDiskSpaceNeededForSingleDeletion(8192);

const TInt KNotepadListEntryLength ( 60 );

// ============================ MEMBER FUNCTIONS ===============================

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

// CNotepadCoreModel::CNotepadCoreModel

// C++ constructor

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

//

CNotepadCoreModel::CNotepadCoreModel()

    : iEnv(CEikonEnv::Static()),

    iModeOp(ENotepadModelRowNop),

    iKey(-1),

    iNpdItemLastChanged(Time::MinTTime())

    {

    }

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

// CNotepadCoreModel::ConstructL

// second phase constructor.

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

//

void CNotepadCoreModel::ConstructL(TInt aResId)

    {

    iDataResourceId = aResId; // used by IsTemplates()

    iDataFile = iEnv->AllocReadResourceL(aResId);

    if ( IsTemplates() )

        {

        const TInt language( User::Language() );

        __ASSERT_DEBUG( language >= 0 && language <= 999, 

            User::Leave( KErrUnknown ) );

        __ASSERT_DEBUG( iDataFile->Length() >= KNotepadLanguagePostfixWidth,

            User::Leave( KErrUnknown ) );

        TInt width( KNotepadLanguagePostfixWidth );

        if ( language > 99 )

            {

            iDataFile = iDataFile->ReAllocL( iDataFile->Length() + 1 );

            width++;

            }

        TPtr ptr = iDataFile->Des();

        ptr.SetLength(iDataFile->Length() - KNotepadLanguagePostfixWidth);

        ptr.AppendNumFixedWidth( language, EDecimal, width );

        }

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

    OpenDatabaseL();

    iDatabase.Compact();

    if ( iDatabase.IsDamaged() )

        {

        iDatabase.Recover();

        }

    }

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

// CNotepadCoreModel::~CNotepadCoreModel

// Destructor.

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

//

CNotepadCoreModel::~CNotepadCoreModel()

    {

    iDatabase.Close();

    iDbs.Close();

    delete iDataFile;

    }

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

// CNotepadCoreModel::ContentByKeyL

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

//

HBufC* CNotepadCoreModel::ContentByKeyL(const TInt aKey)

    {

    __ASSERT_DEBUG( aKey >= 0, Panic(ENotepadLibraryPanicInvalidKey) );

    TBuf<KNotepadSqlStringMaxLength> sql;

    sql.Format(KNotepadSqlFormatSeek, aKey);

    RDbView dbView;

    CleanupClosePushL(dbView);

    User::LeaveIfError( dbView.Prepare(

        iDatabase, TDbQuery(sql), RDbView::EReadOnly ) );

    User::LeaveIfError(dbView.EvaluateAll());

    HBufC* content = NULL;

    TInt isAtRow(dbView.FirstL());

    User::LeaveIfError(isAtRow);

    if ( isAtRow )

        {

        dbView.GetL();

        RDbColReadStream blob;

        blob.OpenLC(dbView, ENotepadMemo);

        TInt colLength( dbView.ColLength(ENotepadMemo) );

        content = HBufC::NewLC(colLength);

        TPtr ptr = content->Des();

        blob.ReadL(ptr, colLength);

        CleanupStack::Pop(); // content

        CleanupStack::PopAndDestroy(); // blob

        }

    CleanupStack::PopAndDestroy(); // dbView

    return content;

    }

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

// CNotepadCoreModel::CountL

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

//

TInt CNotepadCoreModel::CountL()

    {

    RDbTable table;

    User::LeaveIfError( table.Open(

        iDatabase, KNotepadTableName, RDbRowSet::EReadOnly ) );

    CleanupClosePushL(table);

    TInt count( table.CountL() );

    CleanupStack::PopAndDestroy(); // table

    return count;

    }

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

// CNotepadCoreModel::InsertL

// Never leave once the database has committed.

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

//

TInt CNotepadCoreModel::InsertL(const TDesC& aDes, TInt& aKey)

    {

    if ( NotepadUtil::IsEmpty(aDes) )

        {

        return ENotepadModelRowNop;

        }

    aKey = KNotepadPseudoKeyIdForNewNote;

    return InsertOrUpdateL(aDes, aKey);

    }

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

// CNotepadCoreModel::UpdateL

// Never leave once the database has committed.

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

//

TInt CNotepadCoreModel::UpdateL(const TDesC& aDes, TInt& aKey)

    {

    __ASSERT_DEBUG( aKey >= 0, Panic(ENotepadLibraryPanicInvalidKey) );

    TInt resultStatus( NotepadUtil::IsEmpty(aDes) ? DeleteL(aKey) :

        InsertOrUpdateL(aDes, aKey) );

    if ( resultStatus == ENotepadModelRowDeleted )

        {

        aKey = KNotepadPseudoKeyIdForNewNote;

        }

    return resultStatus;

    }

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

// CNotepadCoreModel::DeleteL

// Never leave once the database has committed.

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

//

TInt CNotepadCoreModel::DeleteL(TInt aKey)

    {

    TInt resultStatus(ENotepadModelRowNop);

    iModeOp = ENotepadModelRowNop;

    RFs fileSession;

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

   	CleanupClosePushL(fileSession);

    TInt retval = fileSession.ReserveDriveSpace( KDefaultDrive, KNotepadDiskSpaceNeededForSingleDeletion );

    if ( retval == KErrNone )

    {

    	retval = fileSession.GetReserveAccess( KDefaultDrive );

    }

    TBuf<KNotepadSqlDeleteHeadSize> sql;

    sql.Append(KNotepadSqlDeleteHead);

    sql.AppendNum(aKey);

    TInt rowCount( iDatabase.Execute(sql) );

    User::LeaveIfError( rowCount );

    if ( rowCount > 0 ) 

        {

        resultStatus = ENotepadModelRowDeleted;

    	if ( !IsTemplates() )

    		{

        	iModeOp = ENotepadModelRowDeleted;

    		}

        TInt err(KErrNone);

        err = iDatabase.Compact();

        if ( err != KErrNone )

            {

            iEnv->HandleError(err);

            }

        }

    if ( retval == KErrNone )

    {

    	retval = fileSession.ReleaseReserveAccess( KDefaultDrive );

    }

	fileSession.Close();

	CleanupStack::PopAndDestroy();

    iKey = aKey;

    return resultStatus;

    }

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

// CNotepadCoreModel::Compact

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

//

TInt CNotepadCoreModel::Compact()

    {

    return iDatabase.Compact();

    }

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

// CNotepadCoreModel::SetModeOp

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

//

void CNotepadCoreModel::SetModeOp(CNotepadCoreModel::TNotepadModelRowResult aModeOp)

	{

	iModeOp = aModeOp;

	}

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

// CNotepadCoreModel::AppendContentAsLabelL

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

//

void CNotepadCoreModel::AppendContentAsLabelL(TDes& aDes, const TInt aKey)

    {

    __ASSERT_DEBUG( aKey >= 0, Panic(ENotepadLibraryPanicInvalidKey) );

    TBuf<KNotepadSqlStringMaxLength> sql;

    sql.Format(KNotepadSqlFormatSeek, aKey);

    RDbView dbView;

    CleanupClosePushL(dbView);

    User::LeaveIfError( dbView.Prepare(

        iDatabase, TDbQuery(sql), RDbView::EReadOnly ) );

    User::LeaveIfError(dbView.EvaluateAll());

    dbView.FirstL();

    dbView.GetL();

    AppendContentAsLabelL(aDes, dbView);

    CleanupStack::PopAndDestroy(); // dbView

    }

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

// CNotepadCoreModel::AppendContentAsLabelL

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

//

void CNotepadCoreModel::AppendContentAsLabelL(TDes& aDes, RDbView& aDbView)

    {

    __ASSERT_DEBUG( aDbView.AtRow(), 

        Panic(ENotepadLibraryPanicInvalidRowInView) );

    HBufC* hbuf = HBufC::NewLC(aDes.MaxLength());

    TPtr buf = hbuf->Des();

    RDbColReadStream blob;

    blob.OpenLC(aDbView, ENotepadMemo);

    const TInt colLength( aDbView.ColLength(ENotepadMemo) );

    TInt unreadLength( colLength );

    TInt orgLength(aDes.Length());

    while ( aDes.Length() < aDes.MaxLength() && unreadLength > 0 )

        {

        blob.ReadL(buf, 

            unreadLength < buf.MaxLength() ? unreadLength : buf.MaxLength() );

        unreadLength -= buf.Length();

        NotepadUtil::AppendLabel(aDes, buf, (aDes.Length() == orgLength));

        }

    CleanupStack::PopAndDestroy(2); // blob, hbuf

    }

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

// CNotepadCoreModel::ModeOp

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

//

CNotepadCoreModel::TNotepadModelRowResult CNotepadCoreModel::ModeOp()

	{

	return iModeOp;

	}

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

// CNotepadCoreModel::DoUpdateNotepadItemArrayAndKeyArrayL

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

//

void CNotepadCoreModel::DoUpdateNotepadItemArrayAndKeyArrayL(CDesCArray& aItemArray,

															RArray<TInt>& aKeyArray,

															HBufC& aTimeFormat)

	{

	switch(iModeOp)

		{

		//delete the items from list arrays

		case ENotepadModelRowDeleted:

			{

			TInt index = aKeyArray.Find(iKey);

			if(index != KErrNotFound) //if found

				{

				aItemArray.Delete(index);

				aItemArray.Compress();

				aKeyArray.Remove(index);

				}

			iModeOp = ENotepadModelRowNop;

			}

			break;

		//add new item in list arrays			

		case ENotepadModelRowAdded:

			{

			TTime time;

			time = iNpdItemLastChanged;

    		TTimeIntervalMinutes offset;

    		TTime now;

    		now.HomeTime();

    		TTime gmt;

    		gmt.UniversalTime();

    		now.MinutesFrom(gmt, offset);

    		time += offset; // including summertime adjustment

	 		HBufC* hbuf = HBufC::NewLC(KNotepadListEntryLength);

	    	TPtr lBuf = hbuf->Des();

	        lBuf.SetLength(0);

	        time.FormatL( lBuf, aTimeFormat);

	        AknTextUtils::LanguageSpecificNumberConversion(lBuf);

	        lBuf.Append(KColumnListSeparator);

	        AppendContentAsLabelL(lBuf, iKey);

	        TInt lIndex = GetInsertionIndex(lBuf,aItemArray);

	        aItemArray.InsertL(lIndex,lBuf);

	        User::LeaveIfError(aKeyArray.Insert(iKey,lIndex));

	        CleanupStack::PopAndDestroy(); // hbuf

			iModeOp = ENotepadModelRowNop;

			}

			break;

		//update the existing item.

		case ENotepadModelRowUpdated:

			{

			TTime time = iNpdItemLastChanged;

    		TTimeIntervalMinutes offset;

    		TTime now;

    		now.HomeTime();

    		TTime gmt;

    		gmt.UniversalTime();

    		now.MinutesFrom(gmt, offset);

    		time += offset; // including summertime adjustment

	 		HBufC* hbuf = HBufC::NewLC(KNotepadListEntryLength);

	    	TPtr lBuf = hbuf->Des();

	        lBuf.SetLength(0);

	        time.FormatL( lBuf, aTimeFormat);

	        lBuf.Append(KColumnListSeparator);

	        AppendContentAsLabelL(lBuf, iKey);

	        AknTextUtils::LanguageSpecificNumberConversion(lBuf);

	        TInt index = aKeyArray.Find(iKey);

	        if(index != KErrNotFound) //if found

				{

				aItemArray.Delete(index);

				aItemArray.Compress();

				aKeyArray.Remove(index);

				}

	        TInt lIndex = GetInsertionIndex(lBuf,aItemArray);

	        aItemArray.InsertL(lIndex,lBuf);

	        User::LeaveIfError(aKeyArray.Insert(iKey,lIndex));

	        CleanupStack::PopAndDestroy(); // hbuf

			iModeOp = ENotepadModelRowNop;	        

			}

			break;

		default:

			iModeOp = ENotepadModelRowNop;

			break;

		}

	}

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

// CNotepadCoreModel::OpenDatabaseL

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

//

void CNotepadCoreModel::OpenDatabaseL()

    {

    __ASSERT_DEBUG(iDataFile, Panic(ENotepadLibraryPanicNullDataFileName));

    __ASSERT_DEBUG(iDbs.ResourceCount() == 0, 

        Panic(ENotepadLibraryPanicDatabaseAlreadyOpened));

       TBuf<32> format;

       format.Copy(KSecure);

       format.Append(KSecureUid.Name());

    TInt err(iDatabase.Open(iDbs, *iDataFile,format));

    if ( err == KErrNone && IsInvalidTableL() )

        {

        err = KErrCorrupt;

        }

    switch ( err )

        {

        case KErrArgument: // when the datafile is empty

        case KErrNotSupported: // UID mismatch, corrupted

        case KErrEof: // read error, corrupted

        case KErrCorrupt:

            // delete corrupted file

            NotepadUtil::ShowCorruptedNoteL(*iEnv);

            DeleteFileL();

            // go through into next case

        case KErrNotFound:

            // try to create a new data file

            iDatabase.Close();

            CreateDataFileL();

            User::LeaveIfError(iDatabase.Open(iDbs, *iDataFile,format));

            // go through into next case

        case KErrNone: // database open succeed

            break;

        default:

            User::Leave(err);

            break;

        }

    }

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

// CNotepadCoreModel::CreateDataFileL

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

//

void CNotepadCoreModel::CreateDataFileL()

    {

    NotepadUtil::LeaveIfCriticalLevelL(*iEnv, 

        KNotepadModelMinimumDataFileSize );

    iDatabase.Close(); // for safty

    //User::LeaveIfError(iDatabase.Create(iEnv->FsSession(), *iDataFile));

    TBuf<32> format;

       format.Copy(KSecure);

       format.Append(KSecureUid.Name());

	TInt rr(0);

    TRAP(rr,iDatabase.Create(iDbs,*iDataFile,format); )

    TRAP(rr, InitDataFileL(); );

    if ( rr != KErrNone )

        {

        DeleteFileL(); // including iDatabase.Close()

        User::Leave(rr);

        }

    iDatabase.Close();

    }

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

// CNotepadCoreModel::InitDataFileL

//

// [Q] CreateIndex is needed?

// [A] No.

// We made a comparison experiment whether the data file with the index 

// has better performance than without it.

// 

// Pre-condition: The "C:\System\Data\Notepad.dat" does not exist and 

//     the folder "C:\System\favorites" should be empty.

// 

//                             Without Index         With Index   

// 1. Create 300 memos             200 sec             218 sec

//   (using NpdTest.app)

// 2. Notepad.dat size             9546 b              9546 b

//    after 1.

// 3. Boot up time of Notepad      2.2 sec             2.4 sec

//    with the 300 memos.

// 4. Delete the 300 memos.         18 sec              18 sec

//

// So our conclusion is that the data file without the index is better.

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

//

void CNotepadCoreModel::InitDataFileL()

    {

    // create table

    CDbColSet* columns = CreateDbColSetLC();

    User::LeaveIfError(iDatabase.CreateTable(KNotepadTableName, *columns));

    CleanupStack::PopAndDestroy(); // columns

    if ( IsTemplates() )

        {

        SetDefaultTemplatesL();

        }

    }

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

// CNotepadCoreModel::SetDefaultTemplatesL

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

//

void CNotepadCoreModel::SetDefaultTemplatesL()

    {

    CDesCArray* data = iEnv->ReadDesCArrayResourceL(

        R_NOTEPAD_DEFAULT_TEMPLATES );

    CleanupStack::PushL(data);

    const TInt count(data->Count());

    TInt estimatedSize(0);

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

        {

        estimatedSize += KNotepadModelMinimumEntrySize + (*data)[i].Size();

        }

    NotepadUtil::LeaveIfCriticalLevelL(*iEnv, estimatedSize);

    TTime gmt;

    gmt.UniversalTime();

    gmt.RoundUpToNextMinute();

    gmt -= TTimeIntervalMinutes(1);