/*

* 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 "PodcastFeedView.h"

#include "PodcastAppUi.h"

#include "ShowEngine.h"

#include "SettingsEngine.h"

#include "PodcastApp.h"

#include "PodcastUtils.h"

#include "PodcastFeedViewUpdater.h"

#include "Podcast.hrh"

#include <caknfileselectiondialog.h> 

#include <podcast.rsg>

#include <podcast.mbg>

#include <gulicon.h>

#include <aknquerydialog.h>

#include <caknmemoryselectiondialog.h> 

#include <caknfilenamepromptdialog.h> 

#include <BAUTILS.H> 

#include <pathinfo.h> 

const TInt KMaxFeedNameLength = 100;

const TInt KMaxUnplayedFeedsLength =64;

const TInt KADayInHours = 24;

const TInt KDefaultGran = 5;

const TInt KNumberOfFilesMaxLength = 4;

#define KMaxMessageLength 200

#define KMaxTitleLength 100

const TInt KMimeBufLength = 100;

_LIT(KFeedFormat, "%d\t%S\t%S%S");

enum 

{

 EFeedIcon

};

CPodcastFeedView* CPodcastFeedView::NewL(CPodcastModel& aPodcastModel)

    {

    CPodcastFeedView* self = CPodcastFeedView::NewLC(aPodcastModel);

    CleanupStack::Pop( self );

    return self;

    }

CPodcastFeedView* CPodcastFeedView::NewLC(CPodcastModel& aPodcastModel)

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CPodcastFeedView::CPodcastFeedView(CPodcastModel& aPodcastModel):iPodcastModel(aPodcastModel)

	{

	iFirstActivateAfterLaunch = ETrue;

	}

#define KAsterisk iEikonEnv->EikAppUi()->Application()->BitmapStoreName()

void CPodcastFeedView::ConstructL()

	{

	DP("CPodcastFeedView::ConstructL BEGIN");

	//_LIT(KAsterisk, "*");

	BaseConstructL(R_PODCAST_FEEDVIEW);

	iNeverUpdated = iEikonEnv->AllocReadResourceL(R_PODCAST_FEEDS_NEVER_UPDATED);

	iFeedsFormat = iEikonEnv->AllocReadResourceL(R_PODCAST_FEEDS_STATUS_FORMAT);

	CPodcastListView::ConstructL();

	iPodcastModel.FeedEngine().AddObserver(this);

	CArrayPtr< CGulIcon >* icons = new(ELeave) CArrayPtrFlat< CGulIcon >(1);

	CleanupStack::PushL( icons );

	CFbsBitmap* bitmap = NULL;

	CFbsBitmap* mask = NULL;

	// Load the bitmap for empty icon	

	TFileName fname = KAsterisk;

	TParsePtr parser(fname);

	SetEmptyTextL(R_PODCAST_NO_FEEDS);

	// Load svg.-image and mask with a single call

		AknIconUtils::CreateIconL(bitmap,

		                          mask,

		                          iEikonEnv->EikAppUi()->Application()->BitmapStoreName(),

		                          EMbmPodcastFeed,

		                          EMbmPodcastFeed_mask);

	/*bitmap = iEikonEnv->CreateBitmapL(KAsterisk,EMbmPodcastFeed_40x40);

	 * */

	CleanupStack::PushL( bitmap );		

	// Load the mask for feed icon	

	//mask = iEikonEnv->CreateBitmapL(KAsterisk,EMbmPodcastFeed_40x40m );	

	CleanupStack::PushL( mask );

	// Append the feed icon to icon array

	icons->AppendL( CGulIcon::NewL( bitmap, mask ) );

	CleanupStack::Pop(2); // bitmap, mask

	iListContainer->Listbox()->ItemDrawer()->FormattedCellData()->SetIconArrayL( icons );

	CleanupStack::Pop(icons); // icons

	iListContainer->Listbox()->SetListBoxObserver(this);

    iStylusPopupMenu = CAknStylusPopUpMenu::NewL( this , TPoint(0,0));

    TResourceReader reader;

    iCoeEnv->CreateResourceReaderLC(reader,R_FEEDVIEW_POPUP_MENU);

    iStylusPopupMenu->ConstructFromResourceL(reader);

    CleanupStack::PopAndDestroy();

    iUpdater = CPodcastFeedViewUpdater::NewL(*this);

	DP("CPodcastFeedView::ConstructL END");

	}

CPodcastFeedView::~CPodcastFeedView()

    {

	iPodcastModel.FeedEngine().RemoveObserver(this);

	delete iFeedsFormat;

	delete iNeverUpdated;

	delete iStylusPopupMenu;

	delete iUpdater;

    }

void CPodcastFeedView::UpdateItemL(TInt aIndex)

	{

	_LIT(KPanicCategory, "CPodcastFeedView::UpdateItemL");

	__ASSERT_DEBUG(iListContainer->IsVisible(), User::Panic(KPanicCategory, 0));

	__ASSERT_ALWAYS(iItemIdArray.Count() > aIndex, User::Panic(KPanicCategory, 1));

	const RFeedInfoArray& sortedItems = iPodcastModel.FeedEngine().GetSortedFeeds();

	__ASSERT_ALWAYS(sortedItems.Count() > aIndex, User::Panic(KPanicCategory, 2));

	// Update UID of for the feed at aIndex

	iItemIdArray[aIndex] = sortedItems[aIndex]->Uid();

	// Prepare data to update the listbox item with

	FormatFeedInfoListBoxItemL(*sortedItems[aIndex], EFalse);

	// If nothing has changed, we are done here

	if (iListboxFormatbuffer == iItemArray->MdcaPoint(aIndex))

		{

		return;

		}

	// Something has changed, update the listbox item

	TListItemProperties itemProps;			

	itemProps.SetDimmed(EFalse);	

	iItemArray->Delete(aIndex);	

	iItemArray->InsertL(aIndex, iListboxFormatbuffer);

	iListContainer->Listbox()->ItemDrawer()->SetPropertiesL(aIndex, itemProps);

	// If item is visible, redraw it

	if (iListContainer->Listbox()->TopItemIndex() <= aIndex

			&& iListContainer->Listbox()->BottomItemIndex() >= aIndex)

		{

		iListContainer->Listbox()->DrawItem(aIndex);

		}

	}

TUid CPodcastFeedView::Id() const

	{

	return KUidPodcastFeedViewID;

	}

void CPodcastFeedView::DoActivateL(const TVwsViewId& aPrevViewId,

	                                  TUid aCustomMessageId,

	                                  const TDesC8& aCustomMessage)

	{

	UpdateToolbar();

	CPodcastListView::DoActivateL(aPrevViewId, aCustomMessageId, aCustomMessage);

	if (iFirstActivateAfterLaunch)

		{

		iFirstActivateAfterLaunch = EFalse;

		}

	}

void CPodcastFeedView::DoDeactivate()

	{

	iUpdater->StopUpdate();

	CPodcastListView::DoDeactivate();

	}

void CPodcastFeedView::HandleListBoxEventL(CEikListBox* /* aListBox */, TListBoxEvent aEventType)

	{

	DP("CPodcastFeedView::HandleListBoxEventL BEGIN");

	switch(aEventType)

		{

	case EEventEnterKeyPressed:

	case EEventItemDoubleClicked:

	case EEventItemActioned:

			{

			const RFeedInfoArray* sortedItems = NULL;

			TInt index = iListContainer->Listbox()->CurrentItemIndex();

			sortedItems = &iPodcastModel.FeedEngine().GetSortedFeeds();

			if(index >= 0 && index < sortedItems->Count())

				{

				iPodcastModel.ActiveShowList().Reset();

				iPodcastModel.SetActiveFeedInfo((*sortedItems)[index]);			

				AppUi()->ActivateLocalViewL(KUidPodcastShowsViewID,  TUid::Uid(0), KNullDesC8());

				}

			}

		break;

	default:

		break;

		}

	DP("CPodcastFeedView::HandleListBoxEventL END");

	}

void CPodcastFeedView::FeedUpdateAllCompleteL(TFeedState /*aState*/)

	{

	iUpdatingAllRunning = EFalse;

	UpdateToolbar();

	}

void CPodcastFeedView::FeedDownloadStartedL(TFeedState /*aState*/, TUint aFeedUid)

	{

	// Update status text

	UpdateFeedInfoStatusL(aFeedUid, ETrue);

	UpdateToolbar();

	}

void CPodcastFeedView::FeedDownloadFinishedL(TFeedState aState,TUint aFeedUid, TInt aError)

	{

	switch(aError)

		{

		case KErrCouldNotConnect:

			{

			if(aState == MFeedEngineObserver::EFeedManualUpdate)

				{

				TBuf<KMaxMessageLength> message;

				iEikonEnv->ReadResourceL(message, R_PODCAST_CONNECTION_ERROR);

				ShowErrorMessage(message);

				}

			}

			break;

		default: // Do nothing

			break;

		}

	UpdateFeedInfoStatusL(aFeedUid, EFalse);

	}

void CPodcastFeedView::UpdateFeedInfoStatusL(TUint aFeedUid, TBool aIsUpdating)

	{

	const RFeedInfoArray& feeds = iPodcastModel.FeedEngine().GetSortedFeeds();

	// Find the index for the feed i both the feed-array and the listbox 

	TInt feedsIdx = KErrNotFound;

	TInt listboxIdx = KErrNotFound;

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

		{

		if (feeds[i]->Uid() == aFeedUid)

			{

			feedsIdx = i;

			break;

			}

		}

	for (TInt j = 0; j < iItemIdArray.Count(); j++)

		{

		if (iItemIdArray[j] == aFeedUid)

			{

			listboxIdx = j;

			break;

			}

		}

	if (feedsIdx != KErrNotFound && listboxIdx != KErrNotFound)

		{

		// TODO In the long run we want to move the sorting resposibility from

		// CFeedEngine to CPodcastFeedView.

		// Hackish fix to make sure the listbox is sorted.

		if (listboxIdx != feedsIdx)

			{

			iItemIdArray.Remove(listboxIdx);

			iItemIdArray.InsertL(aFeedUid, feedsIdx);

			iItemArray->Delete(listboxIdx);

			iItemArray->InsertL(feedsIdx, KNullDesC);

			iListContainer->Listbox()->HandleItemAdditionL();

			}

		// Update the listbox info

		UpdateFeedInfoDataL(feeds[feedsIdx], feedsIdx, aIsUpdating);

		//TODO sort the listbox after update

		}

		// Update all visible listbox items that are affected by sorting and update.

		TInt minIdx = Max(Min(feedsIdx, listboxIdx), iListContainer->Listbox()->TopItemIndex());

		TInt maxIdx = Min(Max(feedsIdx, listboxIdx), iListContainer->Listbox()->BottomItemIndex());

		for (TInt k = minIdx; k <= maxIdx; k++)

			{

			iListContainer->Listbox()->DrawItem(k);

			}

	}

void CPodcastFeedView::FormatFeedInfoListBoxItemL(CFeedInfo& aFeedInfo, TBool aIsUpdating)

	{

	TBuf<KMaxShortDateFormatSpec*2> updatedDate;

	TBuf<KMaxUnplayedFeedsLength> unplayedShows;

	TUint unplayedCount = 0;

	TUint showCount = 0;

	TInt iconIndex = EFeedIcon;

	if(aIsUpdating)

		{

		iEikonEnv->ReadResourceL(updatedDate, R_PODCAST_FEEDS_IS_UPDATING);

		unplayedShows = KNullDesC();			

		}

	else

		{

		iPodcastModel.FeedEngine().GetStatsByFeed(aFeedInfo.Uid(), showCount, unplayedCount);	

		if (unplayedCount) {

			unplayedShows.Format(*iFeedsFormat, unplayedCount);

		} else {

			unplayedShows.Zero();

		}

		if (aFeedInfo.LastUpdated().Int64() == 0) 

			{

			updatedDate.Copy(*iNeverUpdated);					

			unplayedShows.Zero();

			}

		else 

			{

			TTime now;

			TTimeIntervalHours interval;

			now.HomeTime();

			now.HoursFrom(aFeedInfo.LastUpdated(), interval);

			if (interval.Int() < KADayInHours) 

				{

				aFeedInfo.LastUpdated().FormatL(updatedDate, KTimeFormat());

				}

			else 

				{

				aFeedInfo.LastUpdated().FormatL(updatedDate, KDateFormatShort());

				}

			}

		}

	CArrayPtr<CGulIcon>* icons = iListContainer->Listbox()->ItemDrawer()->FormattedCellData()->IconArray();

	if (aFeedInfo.FeedIconIndex() != -1) {

		iconIndex = aFeedInfo.FeedIconIndex();

	} else {

		if(aFeedInfo.FeedIcon() != NULL && 

				aFeedInfo.FeedIcon()->SizeInPixels().iHeight > 0 &&

				aFeedInfo.FeedIcon()->SizeInPixels().iWidth > 0)

			{

			// Hopefully temporary haxx to prevent double delete. I would prefer if

			// this could be solved with a little better design.

			CFbsBitmap* bmpCopy = new (ELeave) CFbsBitmap;

			CleanupStack::PushL(bmpCopy);

			bmpCopy->Duplicate(aFeedInfo.FeedIcon()->Handle());

			icons->AppendL( CGulIcon::NewL(bmpCopy, NULL));

			CleanupStack::Pop(bmpCopy);

			iconIndex = icons->Count()-1;

			aFeedInfo.SetFeedIconIndex(iconIndex);

			}

		else {

			if(BaflUtils::FileExists(iPodcastModel.FsSession(), aFeedInfo.ImageFileName()))

			{

			// If this fails, no reason to worry

			TRAP_IGNORE(iPodcastModel.ImageHandler().LoadFileAndScaleL(aFeedInfo.FeedIcon(), aFeedInfo.ImageFileName(), TSize(64,56), *this));

			}

		}

	}

	if(aFeedInfo.LastError() != KErrNone)

		{

		GetFeedErrorText(unplayedShows, aFeedInfo.LastError());

		}

	if (unplayedShows.Length() > 0) {

		unplayedShows.Insert(0,_L(", "));

	}

	iListboxFormatbuffer.Format(KFeedFormat(), iconIndex, &(aFeedInfo.Title()), &updatedDate,  &unplayedShows);

	}

void CPodcastFeedView::ImageOperationCompleteL(TInt aError)

	{

	if (aError == KErrNone) {

		UpdateListboxItemsL();

	}

	}

void CPodcastFeedView::UpdateFeedInfoDataL(CFeedInfo* aFeedInfo, TInt aIndex, TBool aIsUpdating )

	{			

	TListItemProperties itemProps;			

	itemProps.SetDimmed(aIsUpdating);	

	FormatFeedInfoListBoxItemL(*aFeedInfo, aIsUpdating);

	TPtrC compareTo((*iItemArray)[aIndex]);

	if (iListboxFormatbuffer.Compare(compareTo) != 0) {

		iItemArray->Delete(aIndex);

		if(aIndex>= iItemArray->MdcaCount())

				{

				iItemArray->AppendL(iListboxFormatbuffer);

				}

			else

				{

				iItemArray->InsertL(aIndex, iListboxFormatbuffer);

				}

	}

	iListContainer->Listbox()->ItemDrawer()->SetPropertiesL(aIndex, itemProps);

	}

void CPodcastFeedView::UpdateListboxItemsL()

	{

	// No reason to do any work if it isn't going to show..

	if(!iListContainer->IsVisible())

		{

		return;

		}

	TInt nbrItems = iPodcastModel.FeedEngine().GetSortedFeeds().Count();

	if (nbrItems > 0)

		{

		// Ensure that there are as many elements in iItemIdArray as in FeedEngine

		while (iItemIdArray.Count() < nbrItems)

			{

			iItemIdArray.AppendL(0);

			}

		while (iItemIdArray.Count() > nbrItems)

			{

			iItemIdArray.Remove(iItemIdArray.Count() - 1);

			}

		// Ensure that there are as many elements in iItemArray as in FeedEngine

		while (iItemArray->Count() < nbrItems)

			{

			iItemArray->AppendL(KNullDesC);

			TListItemProperties itemProps;

			iListContainer->Listbox()->ItemDrawer()->SetPropertiesL(iItemArray->Count() - 1, itemProps);

			}

		while (iItemArray->Count() > nbrItems)

			{

			iItemArray->Delete(iItemArray->Count() - 1);

			}

		iUpdater->StartUpdate(nbrItems);

		}

	else

		{

		// No feeds at all in the list , add dummy list item

		TBuf<KMaxFeedNameLength> itemName;

		iEikonEnv->ReadResourceL(itemName, R_PODCAST_FEEDS_NO_FEEDS);

		iItemArray->Reset();

		iItemIdArray.Reset();

		TListItemProperties itemProps;

		itemProps.SetDimmed(ETrue);

		itemProps.SetHiddenSelection(ETrue);								

		iListContainer->Listbox()->ItemDrawer()->SetPropertiesL(0, itemProps);

		}

	iListContainer->Listbox()->HandleItemAdditionL();		

	}

/** 

 * Command handling function intended for overriding by sub classes. 

 * Default implementation is empty.  

 * @param aCommand ID of the command to respond to. 

 */

void CPodcastFeedView::HandleCommandL(TInt aCommand)

	{

	//CloseToolbarExtension();

	switch(aCommand)

		{

        case EPodcastHide:

			AppUi()->HandleCommandL(EEikCmdExit);

			break;

		case EPodcastAddFeed:

			HandleAddFeedL();

			break;

		case EPodcastImportFeeds:

			HandleImportFeedsL();

			break;

		case EPodcastExportFeeds:

			HandleExportFeedsL();

			break;

		case EPodcastEditFeed:

			HandleEditFeedL();

			break;

		case EPodcastDeleteFeedHardware:

		case EPodcastDeleteFeed:

			HandleRemoveFeedL();

			break;

		case EPodcastUpdateAllFeeds:

			{

			iUpdatingAllRunning = ETrue;			

			iPodcastModel.FeedEngine().UpdateAllFeedsL();

			UpdateToolbar();

			}break;

		case EPodcastUpdateFeed:

			{

			HandleUpdateFeedL();

			}break;

		case EPodcastCancelUpdateAllFeeds:

			{

			if(iUpdatingAllRunning)

				{

				iUpdatingAllRunning = EFalse;

				iPodcastModel.FeedEngine().CancelUpdateAllFeeds();

				}

			}break;

		case EAknSoftkeyExit:

			{

			RShowInfoArray dlQueue;

			iPodcastModel.ShowEngine().GetShowsDownloadingL(dlQueue);

			TUint queueCount = dlQueue.Count();