/*

* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 feeds server database.

*

*/

#include <badesca.h>

#include <e32math.h>

#include "FeedsDatabase.h"

#include "PackedAttributes.h"

#include "Logger.h"

#include "PackedFeed.h"

#include "PackedFolder.h"

#include "FeedsServer.h"

// Constants

// Database file name.

const TUid KSecureUid = {0x10281F95};

_LIT(KSecure,	"SECURE");

_LIT(KDatabaseFileName, "FeedsDatabase");

_LIT(KDbExtension, ".db");    

// Table names.

_LIT(KVersionTable, "VersionTable");

_LIT(KFolderListTable, "FolderListTable");

_LIT(KFeedTable, "FeedTable");

_LIT(KItemTable, "ItemTable");

_LIT(KEnclosureTable, "EnclosureTable");

_LIT(KSettingsTable, "SettingsTable");

// Table index names.

_LIT(KFolderListTableIndex, "FolderListTableIndex");

_LIT(KFeedTableIndex, "FeedTableIndex");

_LIT(KItemTableIndex, "ItemTableIndex");

_LIT(KEnclosureTableIndex, "EnclosureTableIndex");

_LIT(KSettingsTableIndex, "SettingsTableIndex");

// Table field names.

_LIT(KFolderListId, "FolderListId");

_LIT(KFolderItemId, "FolderItemId");

_LIT(KIsFolder, "IsFolder");

_LIT(KItemId, "ItemId");

_LIT(KParentId, "ParentId");

_LIT(KSiblingOrder, "SiblingOrder");

_LIT(KStatus,"Status");

_LIT(KVersion, "Version");

_LIT(KVersionId, "VersionID");

_LIT(KTitle_100MaxLen, "Title");

_LIT(KFeedId, "FeedId");

_LIT(KDate, "Date");

_LIT(KFeedUrl, "FeedUrl");

_LIT(KWebUrl, "WebUrl");

_LIT(KDescription, "Description");

_LIT(KItemStatus, "ItemStatus");

_LIT(KEnclosureId, "EnclosureId");

_LIT(KLength_100MaxLen, "Length");

_LIT(KContentType_100MaxLen, "ContentType");

_LIT(KItemIdStr, "ItemIdStr");

_LIT(KUnreadCount, "UnreadCount");

_LIT(KAccessPoint, "AccessPoint");

_LIT(KAutoUpdate, "AutoUpdate");

_LIT(KAutoUpdateWhileRoaming, "AutoUpdateWhileRoaming");

_LIT(KAutoUpdateFreq, "AutoUpdateFreq");

_LIT(KLastAutoUpdate, "LastAutoUpdate");

// Misc string consts.

_LIT(KSpace, " ");

_LIT(KNew, "new");

_LIT(KUnread, "unread");

_LIT(KRead, "read");

// Root folder related.

const TInt  KRootFolderId = 0;

_LIT(KRootFolder, "Root Folder");

// Misc consts.

const TInt K100MaxLen = 100;

const TInt KIntLength = 15;

const TInt KInt64Length = 25;

const TInt KVersion31 = 1;

//const TInt KVersion32 = 2;

const TInt KVersion50 = 3;

const TInt KVersion71 = 4;

const TInt KResvSpaceForDupTitles = 6; //Space should be left in feed/folder title to append number in case of duplicate titles.

const TInt KAutoUpdatingOff = 0;

// DATA TYPES

struct TAttribute

    {

    TUint  token;

    TPtrC  value;

    };

// TODO: RDbDatabase::Begin/Commit/RollBack and RDbRowSet::Cancel needs to be

//      used to guard the consistancy of the databse.  See CMidRecordStoreDb 

//      (CMidRecordStoreDb.cpp) for a good example.

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

// CFeedsDatabase::NewL

//

// Two-phased constructor.

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

//

CFeedsDatabase* CFeedsDatabase::NewL(CFeedsServer* aFeedsServer, TBool &aDatabaseCreated)

    {

    CFeedsDatabase* self = new (ELeave) CFeedsDatabase(aFeedsServer);

    aDatabaseCreated = EFalse;

    CleanupStack::PushL(self);

    self->ConstructL(aDatabaseCreated);

    CleanupStack::Pop();

    return self;

    }

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

// CFeedsDatabase::NewL

//

// Symbian 2nd phase constructor can leave.

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

//

void CFeedsDatabase::ConstructL(TBool &aDatabaseCreated)

    {

    TInt     err;

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

    // Create the path to the database file.

    TParse aParse;

    TDriveName cDrive = TDriveUnit( EDriveC ).Name(); 

    User::LeaveIfError( aParse.SetNoWild( KDatabaseFileName, &cDrive, &KDbExtension() ) );

    // Determine if the database exists.    

    TBool isDbExists = EFalse;  

    CDbDatabaseNames *dbNames = iDBs.DatabaseNamesL(EDriveC, KSecureUid);   

    for(int i = 0; i < dbNames->Count(); i++)

    	{

    	if( (*dbNames)[i] == aParse.NameAndExt() )

    		{

    		isDbExists = ETrue;

    		break;

    		}

    	}

    delete dbNames;

    iDatabasePath = aParse.FullName();

    // If the database file doesn't exit create it and create the tables.

    if ( !isDbExists )

        {

        TRAP( err, ResetDatabaseL() );

        // Ensure that the database isn't partially initialized.

        if ( err != KErrNone )

            {

            iDBs.DeleteDatabase( iDatabasePath, KSecureUid );

            User::Leave( err );

            }

        aDatabaseCreated = ETrue;

        }

    // Otherwise, just open the database.

    else

        {

    	TBuf<32> format;

        format.Copy(KSecure);

        format.Append(KSecureUid.Name());

        User::LeaveIfError(iDatabase.Open(iDBs, iDatabasePath, format));

        // check version

        UseVersionTableLC( RDbTable::EReadOnly );

        // Get the row.

        iVersionTable.FirstL();

        iVersionTable.GetL();

        // Get version

        TInt version = iVersionTable.ColUint16(iVersionColSet->ColNo(KVersionId));

        //

        CleanupStack::PopAndDestroy(/*version Table*/);

        // If version is lower than 5.0, add a new column into old database, then update the version table.

        if ( version < KVersion50 )

            {                

            UseFolderListTableLC(RDbTable::EUpdatable);

            // get the exiting col set

            CDbColSet* colSet = iDatabase.ColSetL(KFolderListTable);

            colSet->AddL(TDbCol(KStatus, EDbColInt32));

            iDatabase.AlterTable(KFolderListTable, *colSet);

            CleanupStack::PopAndDestroy(/* FolderListTable */);  		     

		    // Set the status as KErrorNone

            // Prep the item table.

    	    UseFolderListTableLC(RDbTable::EUpdatable);

            while( iFolderListTable.NextL() )

                {

                // Get the row. and add the default value.

                iFolderListTable.GetL();

                iFolderListTable.UpdateL();

                iFolderListTable.SetColL(iFolderListColSet->ColNo(KStatus), KErrNone);

                iFolderListTable.PutL();

                }

            CleanupStack::PopAndDestroy(/* FolderListTable */);

            //Add a new colum KAutoUpdateFreq to FeedTable

            AlterFeedTableWithAutoFequencyL();

            // Add the version as 7.1

            UseVersionTableLC(RDbTable::EUpdatable);

            // Update the version table.There is only one row in this table.

            iVersionTable.FirstL();

            if (iVersionTable.AtRow())

                {        

                iVersionTable.GetL();

                iVersionTable.UpdateL();

                }

            else

                {

                iVersionTable.Reset();

                iVersionTable.InsertL();

                }

		    // Add the version as 7.1

            iVersionTable.SetColL(iVersionColSet->ColNo(KVersionId), KVersion71);

            iVersionTable.PutL();

            CleanupStack::PopAndDestroy(/* version table */);

            }

        else if( version < KVersion71 )

            {

            //Add a new colum KAutoUpdateFreq to FeedTable

            AlterFeedTableWithAutoFequencyL();

	        // Add the version as 7.1 in DB

            UseVersionTableLC(RDbTable::EUpdatable);

            // Update the database.  There is only one row in this table...

            iVersionTable.FirstL();

            if (iVersionTable.AtRow())

                {        

                iVersionTable.GetL();

                iVersionTable.UpdateL();

                }

            else

                {

                iVersionTable.Reset();

                iVersionTable.InsertL();

                }

            // Add the version as 7.1

            iVersionTable.SetColL(iVersionColSet->ColNo(KVersionId), KVersion71);

            iVersionTable.PutL();

            CleanupStack::PopAndDestroy(/* version table */);

            }

        else if ( version == KVersion31 )

            {                

            // JH todo: transform here!

            }

        }        

    }

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

// CFeedsDatabase::CFeedsDatabase

//

// C++ default constructor can NOT contain any code that

// might leave.

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

//

CFeedsDatabase::CFeedsDatabase(CFeedsServer* aFeedsServer):

    iLeakTracker(CLeakTracker::EFeedsDatabase),iFeedsServer(aFeedsServer),iIsFolderTableUpdateNeeded(EFalse)

    {

    }

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

// CFeedsDatabase::~CFeedsDatabase

//

// Destructor

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

//

CFeedsDatabase::~CFeedsDatabase()

    {

    delete iFolderListColSet;

    iFolderListTable.Close();

    delete iFeedColSet;

    iFeedTable.Close();

    delete iItemColSet;

    iItemTable.Close();

    delete iEnclosureColSet;

    iEnclosureTable.Close();

    delete iVersionColSet;

    iVersionTable.Close();

    delete iSettingsColSet;

    iSettingsTable.Close();

    iDatabase.Close();

    iDBs.Close();

    }

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

// CFeedsDatabase::FeedIdFromUrlL

//

// Returns the feed if of the feed with the given url.

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

//

TBool CFeedsDatabase::FeedIdFromUrlL(const TDesC& aFeedUrl, TInt aFolderListId, TInt& aFeedId)

    {

    RDbView  view;

    TBool    found = EFalse;

    HBufC*   query = NULL;

    // Create a view given this select...    

    // SELECT FeedId FROM FeedTable WHERE FeedUrl = 'aFeedUrl' AND FolderListId = aFolderListId

    _LIT(KQuery, "SELECT FeedId FROM FeedTable WHERE FeedUrl = \'%S\' AND FolderListId = %d");

    query = HBufC::NewLC( KQuery().Length() + aFeedUrl.Length() + KIntLength );

    query->Des().Format( KQuery, &aFeedUrl, aFolderListId );

    User::LeaveIfError(view.Prepare(iDatabase, TDbQuery(*query), RDbView::EReadOnly));

    CleanupClosePushL(view);

    CDbColSet* colSet = view.ColSetL();

    CleanupStack::PushL(colSet);

    // Search for the feed.

    if (view.Evaluate() >= 0)

        {

        if (view.FirstL())

            {

            // Get the feed id.

            view.GetL();        

            aFeedId = view.ColUint16(colSet->ColNo(KFeedId));

            found = ETrue;

            }

        }

    CleanupStack::PopAndDestroy(colSet);

    CleanupStack::PopAndDestroy(/*view*/);

    CleanupStack::PopAndDestroy(query);

    return found;

    }

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

// CFeedsDatabase::FolderListIdFromFeedIdL

//

// Returns the feed if of the feed with the given url.

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

//

void CFeedsDatabase::FolderListIdFromFeedIdL( TInt aFeedId, TInt& aFolderListId )

    {

    TDbSeekKey  seekKey((TUint16) aFeedId);

    // Prep the feed table.

    UseFeedTableLC(RDbTable::EReadOnly);

    // Get the information about the feed.

    if (iFeedTable.SeekL(seekKey))

        {        

        // Get the row.

        iFeedTable.GetL();

        // Extract the fields.

        aFolderListId = iFeedTable.ColInt32(iFeedColSet->ColNo(KFolderListId));        

        }

    else

        {

        User::Leave(KErrCorrupt);

        }

    CleanupStack::PopAndDestroy(/*Feed Table*/);

    }

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

// CFeedsDatabase::FeedIdFromFolderItemIdL

//

// Return the feed-id of the given folder-item-id.

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

//

TBool CFeedsDatabase::FeedIdFromFolderItemIdL(TInt aFolderItemId, TInt& aFeedId)

    {

    TDbSeekKey  seekKey((TUint16) aFolderItemId);

    TBool       found = EFalse;

    // Prep the FolderList table.

    UseFolderListTableLC(RDbTable::EReadOnly);

    // Get the folder item.

    if (iFolderListTable.SeekL(seekKey))

        {        

        TBool  isFolder;

        // Get the row.

        iFolderListTable.GetL();

        isFolder = iFolderListTable.ColUint8(iFolderListColSet->ColNo(KIsFolder));

        if (!isFolder)

            {                

            aFeedId = iFolderListTable.ColUint16(iFolderListColSet->ColNo(KFeedId));

            found = ETrue;

            }

        }

    CleanupStack::PopAndDestroy(/*folder list Table*/);

    return found;

    }

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

// CFeedsDatabase::FolderItemInfoL

//

// Return the folder item info from folder-item-id.

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

//

void CFeedsDatabase::FolderItemInfoL(TInt aFolderItemId, TBool &aIsFolder, HBufC*& aTitle, HBufC*& aFeedUrl)

	{

	TDbSeekKey  seekKey((TUint16) aFolderItemId);

	// Prep the FolderList table.

	UseFolderListTableLC(RDbTable::EReadOnly);

	// Get the folder item.

	if (iFolderListTable.SeekL(seekKey))

		{        

		// Get the row.

		iFolderListTable.GetL();

		aIsFolder = iFolderListTable.ColUint8(iFolderListColSet->ColNo(KIsFolder));

		*aTitle = iFolderListTable.ColDes16(iFolderListColSet->ColNo(KTitle_100MaxLen));

		TInt FeedId = iFolderListTable.ColUint16(iFolderListColSet->ColNo(KFeedId));

		if(!aIsFolder)

			{

			RDbView  view;

			HBufC*   query = NULL;

			// Create a view given this select...    

			// SELECT FeedUrl FROM FeedTable WHERE FeedId = aFeedId

			_LIT(KQuery, "SELECT FeedUrl FROM FeedTable WHERE FeedId = %d");

			query = HBufC::NewLC(KQuery().Length() + KIntLength);

			query->Des().Format(KQuery, FeedId);

			User::LeaveIfError(view.Prepare(iDatabase, TDbQuery(*query), RDbView::EReadOnly));

			CleanupClosePushL(view);

			CDbColSet* colSet = view.ColSetL();

			CleanupStack::PushL(colSet);

			// Search for the feed.

			if (view.Evaluate() >= 0)

				{

				if (view.FirstL())

					{

					// Get the feed id.

					view.GetL();        

					ReadLongTextL(view, colSet->ColNo(KFeedUrl), aFeedUrl);

					}

				}

			CleanupStack::PopAndDestroy(/*colSet*/);

			CleanupStack::PopAndDestroy(/*view*/);

			CleanupStack::PopAndDestroy(/*query*/);

			}

        }

	CleanupStack::PopAndDestroy(/*folder list Table*/);

	}

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

// CFeedsDatabase::UrlFromFeedIdL

//

// Return the url of the feed with the given feed-id.

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

//

TBool CFeedsDatabase::UrlFromFeedIdL(TInt aFeedId, HBufC*& aFeedUrl)

    {

    RDbView  view;

    TBool    found = EFalse;

    HBufC*   query = NULL;

    // Create a view given this select...    

    // SELECT FeedUrl FROM FeedTable WHERE FeedId = aFeedId