/*

* Copyright (c) 2007 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: 

*

*/

#include "TIptvRssSearchQuery.h"

#include "CIptvEpgCategory.h"

#include "CIptvEpgPluginInterface.h"

#include "IptvDebug.h"

#include "CIptvEpgContent.h"

#include "CIptvMediaContent.h"

#include <uri8.h>

#include <uriutils.h>

#include <bautils.h>

#include <f32file.h>

#include <centralrepository.h>

#include "CIptvMyVideosGlobalFileId.h"

#include "CIptvService.h"

#include "CIptvSearchManager.h"

#include "CIptvServer.h"

#include "CIptvServiceManager.h"

#include "CIptvVodContentContentBriefDetails.h"

#include "CIptvVodContentCategoryBriefDetails.h"

#include "CIptvVodContentContentFullDetails.h"

#include "CIptvEpgVodMsqQueue.h"

#include "CIptvContentIdMediaContentItem.h"

#include "CIptvEpgSession.h"

_LIT( KIptvSearchStringKeyword, "#search#" );

const TInt KParentalRatingOff = 0;

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

// CIptvSearchManager::NewL

// 

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

CIptvSearchManager* CIptvSearchManager::NewL( CIptvServer& aServer,

                                              CIptvEpgSession& aParent,

											  CIptvEpgVodMsqQueue* aVodMsgQueue )

	{

	CIptvSearchManager* self = new (ELeave) CIptvSearchManager( aServer, aParent );

	CleanupStack::PushL( self );

	self->ConstructL( aVodMsgQueue );

	CleanupStack::Pop( self );

	return self;

	}

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

// CIptvSearchManager::~CIptvSearchManager

// 

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

CIptvSearchManager::~CIptvSearchManager()

	{

	IPTVLOGSTRING_LOW_LEVEL("Search Mgr ## CIptvSearchManager::~CIptvSearchManager()");

	iUsedContentKeys.Reset();

	ClearAllResults();

	delete iFileMan;

	iVodMsgQueues.Reset();

	delete iUpdater;

	delete iSearchCategory;

	delete iCurrentService;

	iAllContentFullDetails.ResetAndDestroy();

	iMediaContents.ResetAndDestroy();

	iFs.Close();

    delete iRssPlugin;

    if ( iCenRepNotifyHandler )

        {

        iCenRepNotifyHandler->StopListening();

        delete iCenRepNotifyHandler;

        }

    delete iCenRepSession;

    delete iSearchUrlTemplate;

	}

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

// CIptvSearchManager::CIptvSearchManager

// 

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

CIptvSearchManager::CIptvSearchManager( CIptvServer& aServer,

                                        CIptvEpgSession& aParent ) :

										iServer( aServer ),

										iParent( aParent ),

										iParentalControl( KParentalRatingOff )

	{

	ResetContentKey();

	}

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

// CIptvSearchManager::ConstructL

// 

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

void CIptvSearchManager::ConstructL( CIptvEpgVodMsqQueue* aVodMsgQueue )

	{

	IPTVLOGSTRING_LOW_LEVEL("Search Mgr ## CIptvSearchManager::ConstructL()");

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

	iFileMan = CFileMan::NewL( iFs );

	iVodMsgQueues.InsertInAddressOrder( aVodMsgQueue );

	iUpdater = CIptvEpgManagerUpdater::NewL(*this);

    iSearchCategory = CIptvVodContentCategoryBriefDetails::NewL();

    iSearchCategory->iCategoryId = KIptvVodContentCategoryRootId;

    iSearchCategory->iIsSearchCategory = ETrue;

    TRAPD( ret, iCenRepSession = CRepository::NewL( KIptvCenRepUid ) );

    if ( ret == KErrNone && iCenRepSession )

        {

        // Register CenRep change notifier.

        iCenRepNotifyHandler = CCenRepNotifyHandler::NewL(

            *this,

            *iCenRepSession,

            CCenRepNotifyHandler::EIntKey,

            KIptvCenRepParentControlKey );

        iCenRepNotifyHandler->StartListeningL();

        // Read settings from CenRep.

        ReadCenRepData();

        }

    // Just to make sure we dont have null pointer available

    iSearchUrlTemplate = HBufC::NewL( 0 );

	}

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

// CIptvSearchManager::ReadCenRepData()

// CenRep

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

//

void CIptvSearchManager::ReadCenRepData()

    {

    IPTVLOGSTRING_LOW_LEVEL( "Search Mgr ## CIptvSearchManager::ReadCenRepData" );

    if ( iCenRepSession )

        {

        TInt age;

        if ( iCenRepSession->Get( KIptvCenRepParentControlKey, age ) != KErrNone )

            {

            age = KIptvCenRepParentControlKeyDefault;

            }

        iParentalControl = age;

        }

    IPTVLOGSTRING2_LOW_LEVEL("Search Mgr ## Currently used parental rating = %d", iParentalControl );

    }

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

// CIptvSearchManager::HandleNotifyInt

// 

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

void CIptvSearchManager::HandleNotifyInt( TUint32 aId, TInt aNewValue )

	{

	IPTVLOGSTRING_LOW_LEVEL("Search Mgr ## CIptvSearchManager::HandleNotifyInt");

    if ( aId == KIptvCenRepParentControlKey )

        {

        IPTVLOGSTRING2_LOW_LEVEL( "Search Mgr ## Parental control key changed. New value = %d", aNewValue );

        iParentalControl = aNewValue;

        }

	}

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

// CIptvSearchManager::AddEpgVodMsgQueue

// 

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

void CIptvSearchManager::AddEpgVodMsgQueue( CIptvEpgVodMsqQueue* aVodMsgQueue )

    {

    IPTVLOGSTRING_LOW_LEVEL("Search Mgr ## CIptvSearchManager::UpdateEpgVodMsgQueue()");

    if ( aVodMsgQueue )

        {

        iVodMsgQueues.InsertInAddressOrder( aVodMsgQueue );

        }

    }

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

// CIptvSearchManager::RemoveEpgVodMsgQueue

// 

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

void CIptvSearchManager::RemoveEpgVodMsgQueue( CIptvEpgVodMsqQueue* aVodMsgQueue )

    {

    IPTVLOGSTRING_LOW_LEVEL("Search Mgr ## CIptvSearchManager::RemoveEpgVodMsgQueue()");

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

        {

        if ( iVodMsgQueues[i] == aVodMsgQueue )

            {

            iVodMsgQueues.Remove( i );

            return;

            }

        }

    }

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

// CIptvSearchManager::ParseSearchAddressL

// 

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

void CIptvSearchManager::ParseSearchAddressL( TIptvRssSearchQuery& aQuery )

	{

	IPTVLOGSTRING_LOW_LEVEL("Search Mgr ## CIptvSearchManager::ParseSearchAddressL()");

	TInt newTotalLength = aQuery.SearchString().Length() +

						  iSearchUrlTemplate->Length();

	HBufC* parsedSearchUrl = HBufC::NewL( newTotalLength );

	CleanupStack::PushL( parsedSearchUrl );

	parsedSearchUrl->Des().Copy( *iSearchUrlTemplate );

	// Try searching the 'search=' string from the template

	TInt queryLocation = parsedSearchUrl->Find( KIptvSearchStringKeyword );

	if( queryLocation != KErrNotFound )

		{

		// Replace KIptvSearchStringKeyword with given search string

		parsedSearchUrl->Des().Replace( queryLocation,

								 		KIptvSearchStringKeyword().Length(),

								 		aQuery.SearchString() );

		}

    CUri8* inetUri = UriUtils::CreateUriL( *parsedSearchUrl );

    CleanupStack::PushL( inetUri );

    HBufC8* parameter = HBufC8::NewLC( inetUri->Uri().UriDes().Length() );

    _LIT8( KStringFormat, "%S");

    parameter->Des().Format( KStringFormat, 

                             &inetUri->Uri().UriDes() );

    HBufC* actualSearchUrl = HBufC::NewLC( parameter->Length() );

    actualSearchUrl->Des().Copy( *parameter );

    iCurrentService->SetSearchUrlL( *actualSearchUrl );

    CleanupStack::PopAndDestroy( actualSearchUrl );

    CleanupStack::PopAndDestroy( parameter );

	CleanupStack::PopAndDestroy( inetUri );

	CleanupStack::PopAndDestroy( parsedSearchUrl );

	}

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

// CIptvSearchManager::UpdateUsedContentIdsListL

// 

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

void CIptvSearchManager::UpdateUsedContentIdsListL( RArray<TInt>& aUsedIdArray )

    {

    iUsedContentKeys.Reset();

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

        {

        IPTVLOGSTRING2_LOW_LEVEL("Search Mgr ## CIptvSearchManager::UpdateUsedContentIdsListL() adding Content ID %d to used list.", aUsedIdArray[i]);

        iUsedContentKeys.AppendL( aUsedIdArray[i] );

        }

    }

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

// CIptvSearchManager::Search

// 

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

TInt CIptvSearchManager::Search( TIptvRssSearchQuery& aQuery )

	{

	IPTVLOGSTRING_LOW_LEVEL("Search Mgr ## CIptvSearchManager::Search()");

	TInt retVal = KErrNone;

	ClearAllResults();

	if( IsSearchPossible() && !iPluginIsRunning )

		{

		TInt err = KErrNone;

		TRAP( err, HandleSearchL( aQuery ) );

		retVal = err;

		}

	else

		{

		retVal = KErrNotReady;

		}

	return retVal;

	}

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

// CIptvSearchManager::CancelSearch

// 

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

TInt CIptvSearchManager::CancelSearch()

	{

    iUpdater->Stop();

	iPluginIsRunning = EFalse;

	delete iRssPlugin;

	iRssPlugin = NULL;

	// If vod update aint running, close ecom session

    if ( ! iParent.IsPluginRunning() )

        {

        REComSession::FinalClose();

        }

	ClearAllResults();

	return KErrNone;

	}

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

// CIptvSearchManager::HandleSearchL

// 

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

void CIptvSearchManager::HandleSearchL( TIptvRssSearchQuery& aQuery )

	{

	IPTVLOGSTRING_LOW_LEVEL("Search Mgr ## CIptvSearchManager::HandleSearchL()");

	ParseSearchAddressL( aQuery );

	if( iRssPlugin )

		{

		delete iRssPlugin;

		iRssPlugin = NULL;

		}

    iUpdater->Start();

	iRssPlugin = CIptvEpgPluginInterface::NewL( iCurrentService->iUid );

	iRssPlugin->SetVodCallback( this );

	iRssPlugin->SetServiceInformation( iCurrentService, ETrue );

	iPluginIsRunning = ETrue;

	iRssPlugin->RunPlugin();

	}

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

// CIptvSearchManager::SearchCategoryBriefDetailsL

// 

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

CIptvVodContentCategoryBriefDetails* CIptvSearchManager::SearchCategoryContentBriefDetailsL()

	{

	IPTVLOGSTRING_LOW_LEVEL("Search Mgr ## CIptvSearchManager::SearchCategoryContentBriefDetailsL()");

	CIptvVodContentCategoryBriefDetails* searchCat = NULL;

	if( IsSearchPossible() )

		{

		searchCat = CIptvVodContentCategoryBriefDetails::NewL();

		searchCat->iCategoryId = KIptvRssSearchCategoryId;

		searchCat->iIsSearchCategory = ETrue;

		searchCat->iContentCount = iSearchCategory->iContentCount;

		IPTVLOGSTRING2_LOW_LEVEL( "Content count for search category = %u", searchCat->iContentCount );

		}

	return searchCat;

	}

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

// CIptvSearchManager::GetSearchContentBriefDetailsL

// 

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

void CIptvSearchManager::GetSearchContentBriefDetailsL( TIptvCategoryId aContentId,

														TDesC& /*aSearchString*/,

														TUint32 /*aFrom*/,

														TUint32 /*aAmount*/,

														TUint32& aTotalAmount,

														RPointerArray<CIptvVodContentContentBriefDetails>& aEcgList )

	{

	IPTVLOGSTRING_LOW_LEVEL("Search Mgr ## CIptvSearchManager::GetSearchContentBriefDetailsL()");

	TInt contentsAdded = 0;

	if( aContentId == KIptvRssSearchCategoryId )

		{

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

			{

			CIptvVodContentContentFullDetails* fullDetails = iAllContentFullDetails[i]; // Owned by the array

			// Check the parental control

			if( iParentalControl == KParentalRatingOff ||

				fullDetails->iRatingAge < iParentalControl )

				{

				IPTVLOGSTRING_LOW_LEVEL("Search Mgr ## Parental rating check passed");

				CIptvVodContentContentBriefDetails* bd = CIptvVodContentContentBriefDetails::NewL();

				CleanupStack::PushL( bd );

				bd->iContentId = fullDetails->iContentId;

				bd->iName.Copy( fullDetails->iName );

				bd->iThumbnailPath.Copy( fullDetails->iThumbnailPath );

				bd->iPlaytime = fullDetails->iPlaytime;

				bd->iSize = fullDetails->iSize;

				bd->iFileId->iDrive = fullDetails->iFileId->iDrive;

				bd->iFileId->iFileId = fullDetails->iFileId->iFileId;

				bd->iPreviewGlobalFileId->iDrive = fullDetails->iPreviewGlobalFileId->iDrive;

				bd->iPreviewGlobalFileId->iFileId = fullDetails->iPreviewGlobalFileId->iFileId;

				bd->iPubDate= fullDetails->iPubDate;

				bd->iLanguage.Copy( fullDetails->iLanguage );

				bd->iRatingAge = fullDetails->iRatingAge;

				bd->SetBrowserUrlL( fullDetails->GetBrowserUrlL() );

				aEcgList.AppendL( bd );

				CleanupStack::Pop( bd );

				contentsAdded++;

				}

			else

				{

				IPTVLOGSTRING_LOW_LEVEL("Search Mgr ## Content skipped. Reason: Parental Rating");

				IPTVLOGSTRING2_LOW_LEVEL("Search Mgr ## Device parental rating = %d", iParentalControl );

				IPTVLOGSTRING2_LOW_LEVEL("Search Mgr ## Contents parental rating = %d", fullDetails->iRatingAge );

				}

			}

		}

	aTotalAmount = contentsAdded;

	}

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

// CIptvSearchManager::GetParentCategory

// 

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

TInt CIptvSearchManager::GetParentCategory( TIptvCategoryId aCategoryId,

											TIptvCategoryId& aParentCategoryId )

	{

	IPTVLOGSTRING_LOW_LEVEL("Search Mgr ## CIptvSearchManager::GetParentCategory()");

	TInt retVal = KErrNotSupported;

	if( aCategoryId == KIptvRssSearchCategoryId )

		{

		aParentCategoryId = KIptvVodContentCategoryRootId;

		retVal = KErrNone;

		}

	return retVal;

	}

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

// CIptvSearchManager::SetServiceId

// 

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

TInt CIptvSearchManager::SetServiceId( TUint32 aServiceId )

	{

	IPTVLOGSTRING2_LOW_LEVEL("Search Mgr ## CIptvSearchManager::SetServiceId(%d)", aServiceId);

	iServiceId = aServiceId;

	return KErrNone;

	}

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

// CIptvSearchManager::SetServiceL

// 

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

void CIptvSearchManager::SetServiceL( CIptvEpgService* aService )

	{

	IPTVLOGSTRING_LOW_LEVEL("Search Mgr ## CIptvSearchManager::SetServiceL()");

	if( iCurrentService )

		{

		delete iCurrentService;

		iCurrentService = NULL;

		}

	iCurrentService = CIptvEpgService::NewL();

    iCurrentService->iAddress.Copy( aService->iAddress);      

    iCurrentService->SetSearchUrlL( aService->SearchUrl() );

    iCurrentService->iIap = aService->iIap;

    iCurrentService->iUserName.Copy( aService->iUserName );

    iCurrentService->iPassword.Copy( aService->iPassword );

    iCurrentService->iUid = aService->iUid;

    iCurrentService->iUpdateSet = aService->iUpdateSet;

    iCurrentService->iServiceType = aService->iServiceType;

    iCurrentService->iServiceId = aService->iServiceId;

    iCurrentService->iLastUpdated = aService->iLastUpdated;

	iServiceId = iCurrentService->iServiceId;

	if( iSearchUrlTemplate )

		{

		delete iSearchUrlTemplate;

		iSearchUrlTemplate = NULL;

		}

	iSearchUrlTemplate = aService->SearchUrl().AllocL();

	ResolveThumbnailDirectory();

    }

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

// CIptvSearchManager::ResolveThumbnailDirectory

// 

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

void CIptvSearchManager::ResolveThumbnailDirectory()

	{

	IPTVLOGSTRING_LOW_LEVEL("Search Mgr ## CIptvSearchManager::ResolveThumbnailDirectory");

	iThumbnailDirectory.Zero();

	TRAPD( error, CIptvUtil::GetPathL( iFs,

									   EIptvPathRssSearchThumbnail,

									   iServiceId,

									   iThumbnailDirectory,

									   EFalse ) );

	if( error != KErrNone )

		{

		IPTVLOGSTRING2_LOW_LEVEL("CIptvUtil::GetPathL failed with error %d", error );

		}

	}

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

// CIptvSearchManager::SetIap

// 

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

void CIptvSearchManager::SetIap( TUint32 aIap )

	{

	IPTVLOGSTRING2_LOW_LEVEL("Search Mgr ## CIptvSearchManager::SetIap(%d)", aIap);

	iIap = aIap;

	}

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

// CIptvSearchManager::StartedL

// 

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

void CIptvSearchManager::StartedL()

	{

	IPTVLOGSTRING_LOW_LEVEL("Search Mgr ## CIptvSearchManager::StartedL() -- RSS Plugin STARTED!");

	}

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

// CIptvSearchManager::ContentUpdateCompletedL

// 

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

void CIptvSearchManager::ContentUpdateCompletedL()