/*

* 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 <BAUTILS.H> 

#include <pathinfo.h> 

#include <akncommondialogsdynmem.h> 

#include "Podcatcher.pan"

const TInt KMaxFeedNameLength = 100;

const TInt KMaxUnplayedFeedsLength =64;

const TInt KADayInHours = 24;

#define KMaxMessageLength 200

#define KMaxTitleLength 100

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

//_LIT(KFeedFormatPortrait, "%d\t%S");

_LIT(KFeedFormatLandscape, "%d\t%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;

    }

void CPodcastFeedView::LoadIcons()

	{

	iFeedIdForIconArray.Reset();

	CFbsBitmap* bitmap = NULL;

	CFbsBitmap* mask = NULL;

	_LIT(KAsterisk, "*");

	// Load the bitmap for empty icon	

	TFileName fname;

	fname.Copy(KAsterisk);

	TParsePtr parser(fname);

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

	CleanupStack::PushL( iconArray );

	// 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

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

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

	iListContainer->SetListboxIcons(iconArray);

	CleanupStack::Pop(iconArray); // icons

	}

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);

	SetEmptyTextL(R_PODCAST_NO_FEEDS);

	LoadIcons();

    iUpdater = CPodcastFeedViewUpdater::NewL(*this);

	DP("CPodcastFeedView::ConstructL END");

	}

CPodcastFeedView::~CPodcastFeedView()

    {

	iPodcastModel.FeedEngine().RemoveObserver(this);

	delete iFeedsFormat;

	delete iNeverUpdated;

	delete iUpdater;

	iFeedIdForIconArray.Close();

    }

void CPodcastFeedView::UpdateItemL(TInt aIndex)

	{

	__ASSERT_DEBUG(iListContainer->IsVisible(), Panic(EPodcatcherPanicFeedView));

	__ASSERT_ALWAYS(iItemIdArray.Count() > aIndex, Panic(EPodcatcherPanicFeedView));

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

	__ASSERT_ALWAYS(sortedItems.Count() > aIndex, Panic(EPodcatcherPanicFeedView));

	// Update UID of for the feed at aIndex

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

	// Prepare data to update the listbox item with

	FormatFeedInfoListBoxItemL(*sortedItems[aIndex], sortedItems[aIndex]->Uid() == iFeedUpdating);

	// 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);

	iItemArrayShort->Delete(aIndex);	

	iItemArrayShort->InsertL(aIndex, iListboxFormatbufferShort);

	//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)

	{

	DP("CPodcastFeedView::DoActivateL BEGIN");

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

	UpdateListboxItemsL();		

	UpdateToolbar();

	if (aPrevViewId.iViewUid == KUidPodcastShowsViewID)

		{

		// back key from shows view

		iViewingShows = EFalse;

		}

	// when we receive a UID argument, this comes from search view after

	// a new feed has been added

	if (aCustomMessageId.iUid != 0)

		{

		TUint feedUid = aCustomMessageId.iUid;

		ShowItem(feedUid);

		TBuf<KMaxMessageLength> message;

		iEikonEnv->ReadResourceL(message, R_ADD_FEED_SUCCESS);

		if(ShowQueryMessageL(message))

			{

			iPodcastModel.FeedEngine().UpdateFeedL(feedUid);

			}

		}

	if (iFirstActivateAfterLaunch)

		{

		iFirstActivateAfterLaunch = EFalse;

		}

	DP("CPodcastFeedView::DoActivateL END");

	}

void CPodcastFeedView::DoDeactivate()

	{

	iUpdater->StopUpdate();

	CPodcastListView::DoDeactivate();

	}

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

	{

//	DP("CPodcastFeedView::HandleListBoxEventL BEGIN");

	switch(aEventType)

		{

	case EEventItemSingleClicked:

	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.SetActiveFeedInfo((*sortedItems)[index]);			

				iViewingShows = ETrue;

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

				}

			}

		break;

	default:

		break;

		}

//	DP("CPodcastFeedView::HandleListBoxEventL END");

	}

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

	{

	DP("FeedUpdateAllCompleteL");

	iFeedUpdating = 0;

	UpdateToolbar();

	}

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

	{

	// Update status text

	iFeedUpdating = aFeedUid;

	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);

				ShowErrorMessageL(message);

				}

			}

			break;

		default: // Do nothing

			break;

		}

	UpdateFeedInfoStatusL(aFeedUid, EFalse);

	}

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

	{

	DP("CPodcastFeedView::UpdateFeedInfoStatusL BEGIN");

	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);

			iItemArrayShort->Delete(listboxIdx);

			iItemArrayShort->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);

			}

		DP("CPodcastFeedView::UpdateFeedInfoStatusL END");

	}

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

	{

	DP("CPodcastFeedView::FormatFeedInfoListBoxItemL BEGIN");

	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

		{

		// we will get a leave if there are no shows for this feed, for instance, which is fine

		TRAP_IGNORE(iPodcastModel.FeedEngine().GetStatsByFeedL(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());

				}

			}

		if(aFeedInfo.LastError() != KErrNone)

			{

			GetFeedErrorText(unplayedShows, aFeedInfo.LastError());

			updatedDate.Zero();

			}

		}

	iconIndex = iFeedIdForIconArray.Find(aFeedInfo.Uid());

	if(iconIndex == KErrNotFound && aFeedInfo.FeedIcon() != NULL && aFeedInfo.ImageFileName().Length() > 0 && 

			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());

		CArrayPtr<CGulIcon>* icons = iListContainer->ListboxIcons();

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

		iFeedIdForIconArray.Append(aFeedInfo.Uid());

		CleanupStack::Pop(bmpCopy);			

		iconIndex = icons->Count()-1;

		}	

	else 

		{

		iconIndex++;

		}	

	if (unplayedShows.Length() > 0 && updatedDate.Length() > 0) {

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

	}

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

	iListboxFormatbufferShort.Format(KFeedFormatLandscape(), iconIndex, &(aFeedInfo.Title()));

	DP("CPodcastFeedView::FormatFeedInfoListBoxItemL END");

	}

void CPodcastFeedView::ImageOperationCompleteL(TInt aError, TUint aHandle, CPodcastModel& /*aPodcastModel*/)

	{

	if (aError == KErrNone) {

		UpdateFeedInfoStatusL(aHandle, EFalse);

		}

	}

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

	{

	DP("CPodcastFeedView::UpdateFeedInfoDataL BEGIN");

	TListItemProperties itemProps;			

	itemProps.SetDimmed(aIsUpdating);	

	FormatFeedInfoListBoxItemL(*aFeedInfo, aIsUpdating);

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

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

		iItemArray->Delete(aIndex);

		iItemArrayShort->Delete(aIndex);

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

				{

				iItemArray->AppendL(iListboxFormatbuffer);

				iItemArrayShort->AppendL(iListboxFormatbufferShort);

				}

			else

				{

				iItemArray->InsertL(aIndex, iListboxFormatbuffer);

				iItemArrayShort->InsertL(aIndex, iListboxFormatbufferShort);

				}

	}

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

	DP("CPodcastFeedView::UpdateFeedInfoDataL END");

	}

void CPodcastFeedView::UpdateListboxItemsL()

	{

	DP("CPodcastFeedView::UpdateListboxItemsL BEGIN");

	// 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);

			iItemArrayShort->AppendL(KNullDesC);

			TListItemProperties itemProps;

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

			}

		while (iItemArray->Count() > nbrItems)

			{

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

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

			}

		//iListContainer->Listbox()->

		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();

		iItemArrayShort->Reset();

		iItemIdArray.Reset();

		TListItemProperties itemProps;

		itemProps.SetDimmed(ETrue);

		itemProps.SetHiddenSelection(ETrue);								

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

		}

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