/*

* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB

*

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

* EmbedDev AB - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include "FeedEngine.h"

#include <f32file.h>

#include <bautils.h>

#include <s32file.h>

#include "SettingsEngine.h"

#include "ShowEngine.h"

#include <e32hashtab.h>

#include "OpmlParser.h"

#include "PodcastUtils.h"

#include <utf.h>

#include "Podcatcher.pan"

#include <centralrepository.h>

#include <ProfileEngineSDKCRKeys.h>

_LIT(KFeedParseStorePath, "feeds\\");

CFeedEngine* CFeedEngine::NewL(CPodcastModel& aPodcastModel)

	{

	CFeedEngine* self = new (ELeave) CFeedEngine(aPodcastModel);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CFeedEngine::ConstructL()

	{

	iParser = new (ELeave) CFeedParser(*this, iPodcastModel.FsSession());

	iFeedClient = CHttpClient::NewL(iPodcastModel, *this);

	iFeedTimer.ConstructL();

	TInt err = KErrNone;

	TInt feedCount = 0;

	TRAP(err, feedCount = DBGetFeedCountL());

    if (err == KErrNone && feedCount > 0)

    	{

		DP("Loading feeds from DB");

		TRAP(err, DBLoadFeedsL());

    	}		

	if (err != KErrNone || iPodcastModel.IsFirstStartup()) {

		TFileName defaultFile = iPodcastModel.SettingsEngine().DefaultFeedsFileName();

		DP1("Loading default feeds from %S", &defaultFile);

		if (BaflUtils::FileExists(iPodcastModel.FsSession(), defaultFile)) {

			ImportFeedsL(defaultFile);

		}

	} 

	// clean out feeds temp directory

	TFileName feedTempPath;

	feedTempPath.Copy (iPodcastModel.SettingsEngine().PrivatePath ());

	feedTempPath.Append(KFeedParseStorePath);

	feedTempPath.Append(_L("*"));

	BaflUtils::EnsurePathExistsL(iPodcastModel.FsSession(), feedTempPath);

	BaflUtils::DeleteFile(iPodcastModel.FsSession(),feedTempPath);

    TFileName importFile = iPodcastModel.SettingsEngine().ImportFeedsFileName();

    if (BaflUtils::FileExists(iPodcastModel.FsSession(), importFile)) {

    	DP("Importing feeds");

    	TRAP_IGNORE(ImportFeedsL(importFile));

		}

    // offline profile support

    iRepository = CRepository::NewL( KCRUidProfileEngine );

	RunFeedTimer();

	}

CFeedEngine::CFeedEngine(CPodcastModel& aPodcastModel)

		: iClientState(EIdle),

		  iFeedTimer(this),

		  iPodcastModel(aPodcastModel),

		  iDB(*aPodcastModel.DB())

	{

	}

CFeedEngine::~CFeedEngine()

	{

	iObservers.Close();

	iFeedsUpdating.Close();

	iSortedFeeds.ResetAndDestroy();

	iSearchResults.ResetAndDestroy();

	delete iParser;

	delete iFeedClient;

	delete iOpmlParser;

	//

	delete iRepository;

	}

/**

 * Returns the current internal state of the feed engine4

 */

EXPORT_C TClientState CFeedEngine::ClientState()

	{

	return iClientState;

	}

/**

 * Returns the current updating client UID if clientstate is != ENotUpdateing

 * @return TUint

 */

EXPORT_C TUint CFeedEngine::ActiveClientUid()

	{

	if(iActiveFeed != NULL)

		{

		return iActiveFeed->Uid();

		}

	return 0;	

	}

void CFeedEngine::RunFeedTimer()

	{

	iFeedTimer.Cancel();

	if (iPodcastModel.SettingsEngine().UpdateAutomatically() != EAutoUpdateOff)

		{

		TInt interval = iPodcastModel.SettingsEngine().UpdateFeedInterval();

		if (interval != 0)

			{

			iFeedTimer.SetPeriod(interval);

			iFeedTimer.RunPeriodically();

			}

		}

	}

EXPORT_C void CFeedEngine::UpdateAllFeedsL(TBool aAutoUpdate)

	{

	if (iClientState != EIdle)

		{

		User::Leave(KErrInUse);

		}

	// check for offline profile, done by polling here, perhpas CenRep notifier woudl be better

	TInt currentProfileId = 0; // general profile

	TBool isOfflineProfile = EFalse;

	// Get ID of current profile

	if(KErrNone == iRepository->Get( KProEngActiveProfile, currentProfileId ) ) // better to assume online then leave if CRep fails

		{

		// Check value to determine the active profile if no error

		if ( 5 == currentProfileId)

			{

			// current profile is the offline profile

			isOfflineProfile = ETrue;

			}

	    }

	//

	iAutoUpdatedInitiator = aAutoUpdate;

	if ((iFeedsUpdating.Count() > 0) || (isOfflineProfile && aAutoUpdate)) 

		{

		DP("Cancelling update");

		iFeedClient->Stop();

		iFeedsUpdating.Reset();

		return;

		}

	TInt cnt = iSortedFeeds.Count();

	for (int i=0;i<cnt;i++)

		{

		iFeedsUpdating.Append(iSortedFeeds[i]->Uid());

		}

	UpdateNextFeedL();

	}

EXPORT_C void CFeedEngine::CancelUpdateAllFeeds()

	{

	if(iClientState != EIdle)

		{

		iCancelRequested = ETrue;

		iFeedsUpdating.Reset();

		iFeedClient->Stop();

		}

	}

void CFeedEngine::UpdateNextFeedL()

	{

	DP1("UpdateNextFeed. %d feeds left to update", iFeedsUpdating.Count());

	if (iClientState != EIdle)

		{

		User::Leave(KErrInUse);

		}

	// reset active feed, will be set again in UpdateFeedL if needed

	iActiveFeed = NULL;

	if (iFeedsUpdating.Count() > 0)

		{

		CFeedInfo *info = GetFeedInfoByUid(iFeedsUpdating[0]);

		iFeedsUpdating.Remove(0);

		if (info == NULL)

			{

			UpdateNextFeedL();

			}

		else

			{

			TBool result = EFalse;

			//DP2("** UpdateNextFeed: %S, ID: %u", &(info->Url()), info->Uid());

			TRAPD(error, result = UpdateFeedL(info->Uid()));

			if (error != KErrNone || !result)

				{

				DP("Error while updating all feeds");

				for (TInt i=0;i<iObservers.Count();i++) 

					{

					TRAP_IGNORE(iObservers[i]->FeedUpdateAllCompleteL(iAutoUpdatedInitiator?MFeedEngineObserver::EFeedAutoUpdate:MFeedEngineObserver::EFeedManualUpdate));

					}

				}

			}

		}

	else

		{

		iClientState = EIdle;

		for (TInt i=0;i<iObservers.Count();i++) 

			{

			TRAP_IGNORE(iObservers[i]->FeedUpdateAllCompleteL(iAutoUpdatedInitiator?MFeedEngineObserver::EFeedAutoUpdate:MFeedEngineObserver::EFeedManualUpdate));

			}

		}

	}

EXPORT_C TBool CFeedEngine::UpdateFeedL(TUint aFeedUid)

	{

	DP("FeedEngine::UpdateFeedL BEGIN");

	if (iActiveFeed)

		{

		User::Leave(KErrInUse);

		}

	iActiveFeed = GetFeedInfoByUid(aFeedUid);

	iCancelRequested = EFalse;

	if (iActiveFeed->LastUpdated() == 0)

		{

		newFeed = ETrue;	

		}

	showsAdded = 0;

	iActiveFeed->SetLastError(KErrNone);

	DBUpdateFeedL(*iActiveFeed);

	iUpdatingFeedFileName.Copy (iPodcastModel.SettingsEngine().PrivatePath ());

	iUpdatingFeedFileName.Append(KFeedParseStorePath);

	BaflUtils::EnsurePathExistsL(iPodcastModel.FsSession(), iUpdatingFeedFileName);

	_LIT(KFileNameFormat, "%lu.xml");

	iUpdatingFeedFileName.AppendFormat(KFileNameFormat, aFeedUid);

	iClientState = EUpdatingFeed;

	for (TInt i=0;i<iObservers.Count();i++)

		{

		TRAP_IGNORE(iObservers[i]->FeedDownloadStartedL(iAutoUpdatedInitiator?MFeedEngineObserver::EFeedAutoUpdate:MFeedEngineObserver::EFeedManualUpdate, iActiveFeed->Uid()));

		}

	if(iFeedClient->GetL(iActiveFeed->Url(), iUpdatingFeedFileName, iPodcastModel.SettingsEngine().SpecificIAP()))

		{

		DP("FeedEngine::UpdateFeedL END, return ETrue");

		return ETrue;

		}

	else

		{

		DP("FeedEngine::UpdateFeedL END, return EFalse");

		return EFalse;

		}

	}

void CFeedEngine::NewShowL(CShowInfo& aItem)

	{

	HBufC* description = HBufC::NewLC(KMaxDescriptionLength);

	TPtr ptr(description->Des());

	ptr.Copy(aItem.Description());

	PodcastUtils::CleanHtmlL(ptr);

	aItem.SetDescriptionL(*description);

	CleanupStack::PopAndDestroy(description);

	if (newFeed) {

		// for new feeds, set all shows played

		aItem.SetPlayState(EPlayed);

		// except the first one

		if (showsAdded == 0) {

			aItem.SetPlayState(ENeverPlayed);	

		}

	}

	TRAPD(err, iPodcastModel.ShowEngine().AddShowL(aItem));

	if (err == KErrNone && aItem.PlayState() == ENeverPlayed && 

			iPodcastModel.SettingsEngine().DownloadAutomatically()) 

		{

		iPodcastModel.ShowEngine().AddDownloadL(aItem);

		}

	showsAdded++;

	}

void CFeedEngine::GetFeedImageL(CFeedInfo *aFeedInfo)

	{

	DP("GetFeedImage");

	TFileName filePath;

	filePath.Copy(iPodcastModel.SettingsEngine().BaseDir());

	// create relative file name

	TFileName relPath;

	relPath.Copy(aFeedInfo->Title());

	relPath.Append('\\');

	TFileName fileName;

	PodcastUtils::FileNameFromUrl(aFeedInfo->ImageUrl(), fileName);

	relPath.Append(fileName);

	PodcastUtils::EnsureProperPathName(relPath);

	// complete file path is base dir + rel path

	filePath.Append(relPath);

	aFeedInfo->SetImageFileNameL(filePath, NULL);

	if(iFeedClient->GetL(aFeedInfo->ImageUrl(), filePath, ETrue))

		{

			iClientState = EUpdatingImage;

		}

	}

EXPORT_C TBool CFeedEngine::AddFeedL(const CFeedInfo&aItem) 

	{

	DP2("CFeedEngine::AddFeed, title=%S, URL=%S", &aItem.Title(), &aItem.Url());

	for (TInt i=0;i<iSortedFeeds.Count();i++) 

		{

		if (iSortedFeeds[i]->Uid() == aItem.Uid()) 

			{

			DP1("Already have feed %S, discarding", &aItem.Url());			

			return EFalse;

			}

		}

	TLinearOrder<CFeedInfo> sortOrder( CFeedEngine::CompareFeedsByTitle);

	CFeedInfo* newItem = aItem.CopyL();

	CleanupStack::PushL(newItem);

	User::LeaveIfError(iSortedFeeds.InsertInOrder(newItem, sortOrder));

	CleanupStack::Pop(newItem);

	// Save the feeds into DB

	DBAddFeedL(aItem);

	return ETrue;

	}

void CFeedEngine::DBAddFeedL(const CFeedInfo& aItem)

	{

	DP2("CFeedEngine::DBAddFeed BEGIN, title=%S, URL=%S", &aItem.Title(), &aItem.Url());

	CFeedInfo *info;

	TRAPD(err, info = DBGetFeedInfoByUidL(aItem.Uid()));

	if (err == KErrNone && info) {

		delete info;

		User::Leave(KErrAlreadyExists);

	}

	HBufC* titleBuf = HBufC::NewLC(KMaxLineLength);

	TPtr titlePtr(titleBuf->Des());

	titlePtr.Copy(aItem.Title());

	PodcastUtils::SQLEncode(titlePtr);

	HBufC* descBuf = HBufC::NewLC(KMaxLineLength);

	TPtr descPtr(descBuf->Des());

	descPtr.Copy(aItem.Description());

	PodcastUtils::SQLEncode(descPtr);

	iSqlBuffer.Format(KSqlStatement,

			&aItem.Url(), titleBuf, descBuf, &aItem.ImageUrl(), &aItem.ImageFileName(), &aItem.Link(),

	CleanupStack::PopAndDestroy(descBuf);

	CleanupStack::PopAndDestroy(titleBuf);

	sqlite3_stmt *st;

	int rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st, (const void**) NULL);

	if (rc==SQLITE_OK)

		{

		Cleanup_sqlite3_finalize_PushL(st);

		rc = sqlite3_step(st);

		if (rc != SQLITE_DONE)

			{

			User::Leave(KErrCorrupt);

			}

		CleanupStack::PopAndDestroy(); // st

		}

	else

		{

		User::Leave(KErrCorrupt);

		}

	DP("CFeedEngine::DBAddFeed END");

	}

EXPORT_C void CFeedEngine::RemoveFeedL(TUint aUid) 

	{

	if (iActiveFeed && iActiveFeed->Uid() == aUid)

		{

		User::Leave(KErrInUse);

		}

	for (int i=0;i<iSortedFeeds.Count();i++) 

		{

		if (iSortedFeeds[i]->Uid() == aUid) 

			{

			iPodcastModel.ShowEngine().DeleteAllShowsByFeedL(aUid);

			CFeedInfo* feedToRemove = iSortedFeeds[i];

			//delete the image file if it exists

			if ((feedToRemove->ImageFileName().Length() >0)

					&& BaflUtils::FileExists(iPodcastModel.FsSession(), feedToRemove->ImageFileName()))

				{

				iPodcastModel.FsSession().Delete(feedToRemove->ImageFileName());

				}

			//delete the folder. It has the same name as the title.

			TFileName filePath;

			filePath.Copy(iPodcastModel.SettingsEngine().BaseDir());

			filePath.Append(feedToRemove->Title());

			filePath.Append('\\');

			iPodcastModel.FsSession().RmDir(filePath);

			iSortedFeeds.Remove(i);

			delete feedToRemove;

			DP("Removed feed from array");

			// now remove it from DB

			DBRemoveFeedL(aUid);

		}

	}

}

void CFeedEngine::DBRemoveFeedL(TUint aUid)

	{

	DP("CFeedEngine::DBRemoveFeed BEGIN");

	_LIT(KSqlStatement, "delete from feeds where uid=%u");

	iSqlBuffer.Format(KSqlStatement, aUid);

	sqlite3_stmt *st;

	int rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st,	(const void**) NULL);

	if (rc==SQLITE_OK)

		{

		Cleanup_sqlite3_finalize_PushL(st);

		rc = sqlite3_step(st);

		if (rc != SQLITE_DONE)

			{

			User::Leave(KErrNotFound);

			}

		CleanupStack::PopAndDestroy(); //st

		}

	else

		{