/*

* Copyright (c) 2006 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:    Offers interface to IPTV Epg database*

*/

// INCLUDE FILES

#include <badesca.h>    // CDesCArrayFlat

#include <bautils.h>    // file helpers

#include <d32dbms.h>

#include <eikenv.h>

#include "CIptvEpgLatestEpgAvailable.h"

#include "IptvLiveLogger.h"

#include "CIptvEpgDatabase.h"

#include "CIptvEpgChannel.h"

#include "CIptvEpgProgram.h"

#include "CIptvEpgProgramWithSchedule.h"

#include "CIptvEpgSchedule.h"

#include "CIptvEpgScheduleSearch.h"

// CONSTANTS

// constant for program guide: day changes at 04:00 AM

// Note: If you modify this, the range is 0-23, otherwise

// USER 3 panic will happen in GetSchedulesByChannelAndDayL

const TInt KIptvDefaultDayOffsetHours( 4 ); 

const TInt KIptvDefaultUriCount( 5 );

// ============================ MEMBER FUNCTIONS ===============================

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

// CIptvEpgDatabase::CIptvEpgDatabase

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

// might leave.

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

CIptvEpgDatabase::CIptvEpgDatabase( const TFileName& aDbFile ) : 

	iDbFile( aDbFile ), iLocalState( EReady )

    {

    }

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

// CIptvEpgDatabase::ConstructL

// Second phase construction. Leaves, if RFs session cannot be created.

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

void CIptvEpgDatabase::ConstructL()

	{

	LIVE_TV_TRACE1(_L("CIptvEpgDatabase::ConstructL()"));

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

    MakeSqlStrings();

    // Create database and connect into it

	CreateDbL();

	TRAPD( error, CreateMulticastDbSessionL());

    if ( error != KErrNone )

        {

        LIVE_TV_TRACE2(_L("CIptvEpgDatabase:: Could not open session to db (%d)"), error);

        if ( error != KErrNoMemory && 

             error != KErrLocked && 

             error != KErrDisMounted &&

             error != KErrDiskFull &&

             error != KErrNotReady )

            {

            // Delete and recreate database file. Cannot recover other way. 

            LIVE_TV_TRACE1(_L("CIptvEpgDatabase:: fatal error occured while opening db, recreating db"));

            iFsSession.Delete( iDbFile ); //ignore error

            TRAP( error, CreateDbL() );

            if ( error != KErrNone )

                {

                LIVE_TV_TRACE2(_L("CIptvEpgDatabase:: couldnt recreate db (%d), leaving."), error);

                User::Leave( error );

                }

            TRAP( error, CreateMulticastDbSessionL() );

            if ( error != KErrNone )

                {

                LIVE_TV_TRACE2(_L("CIptvEpgDatabase:: couldnt open session to db (%d), leaving."), error);

                User::Leave( error );

                }

            }

        else

            {

            LIVE_TV_TRACE1(_L("CIptvEpgDatabase:: temporary error occured while opening db, leaving db intact, leaving."));

            User::Leave( error );

            }

        }

	iLocalState = EReady;

	// Register to listen the file for backup

	iBackupWrapper = CBaBackupSessionWrapper::NewL();

	iBackupWrapper->RegisterFileL( iDbFile, *this );

	iActiveWait = new (ELeave) CActiveSchedulerWait();

    }

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

// CIptvEpgDatabase::NewL

// Two-phased constructor.

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

EXPORT_C CIptvEpgDatabase* CIptvEpgDatabase::NewL(const TFileName& aDbFile)

    {

    LIVE_TV_TRACE1(_L("CIptvEpgDatabase::NewL()"));

    CIptvEpgDatabase* self = new ( ELeave ) CIptvEpgDatabase( aDbFile );    

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );    

    return self;

    }

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

// CIptvEpgDatabase::~CIptvEpgDatabase()

// Destructor

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

CIptvEpgDatabase::~CIptvEpgDatabase()

    {

    LIVE_TV_TRACE1(_L("CIptvEpgDatabase::~CIptvEpgDatabase in"));

	if ( iBackupWrapper )

		{

		iBackupWrapper->DeregisterFile( iDbFile );

		}

	delete iBackupWrapper;

    iFsSession.Close();

    CloseMulticastDbSession();

    if ( iActiveWait && iActiveWait->IsStarted() )

    	{

    	iActiveWait->AsyncStop();

    	}

    delete iActiveWait;

    LIVE_TV_TRACE1(_L("CIptvEpgDatabase::~CIptvEpgDatabase out"));    

    }

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

// CIptvEpgDatabase::CreateDbL()

//

// Create a new database. 

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

void CIptvEpgDatabase::CreateDbL()

    {

    LIVE_TV_TRACE1(_L("CIptvEpgDatabase::CreateDbL()"));

    if ( !BaflUtils::FileExists( iFsSession, iDbFile ) )

        {

        LIVE_TV_TRACE1( _L("Database file wasn't found, creating new"));

    	RDbNamedDatabase database;

		CleanupClosePushL( database );

		BaflUtils::EnsurePathExistsL( iFsSession, iDbFile );

    	User::LeaveIfError( database.Create( iFsSession, iDbFile ) );

		CreateChannelTableL( database );

        CreateProgramTableL( database );

        CreateScheduleTableL( database );

		CreateLatestEpgAvailableTableL( database );

		CreateLastModifiedTableL( database );

        CleanupStack::PopAndDestroy( &database );

        }

    }

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

// CIptvEpgDatabase::CreateMulticastDbSessionL()

//

// Open a new database session and the database

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

void CIptvEpgDatabase::CreateMulticastDbSessionL()

    {

    LIVE_TV_TRACE1(_L("CIptvEpgDatabase::CreateMulticastDbSessionL()"));

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

    User::LeaveIfError( iMulticastDb.Open( iMulticastDbSession, iDbFile ) );

    User::LeaveIfError( iMulticastDb.Compact() );

    }

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

// CIptvEpgDatabase::CloseMulticastDbSession()

//

// Closes a database session and the database

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

void CIptvEpgDatabase::CloseMulticastDbSession()

    {

    LIVE_TV_TRACE1(_L("CIptvEpgDatabase::CloseMulticastDbSession()"));

    iMulticastDb.Close();

    iMulticastDbSession.Close();

    }

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

// CIptvEpgDatabase::CreateScheduleTableL()

//

// Creates schedule database table

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

void CIptvEpgDatabase::CreateScheduleTableL( RDbNamedDatabase& aDatabase ) const

	{

	LIVE_TV_TRACE1(_L("CIptvEpgDatabase::CreateScheduleTableL()"));

	TDbCol keyCol( KIptvEpgScheduleTableKeyCol, EDbColUint32 );

	keyCol.iAttributes = TDbCol::EAutoIncrement;

	TDbCol serviceIdCol( KIptvEpgScheduleServiceProviderIdCol, EDbColUint32 );

	TDbCol channelIdCol( KIptvEpgScheduleChannelIdCol, EDbColInt64 );

	TDbCol programIdCol( KIptvEpgScheduleProgramIdCol, EDbColInt64 );

	TDbCol startTimeCol( KIptvEpgScheduleStartTimeCol, EDbColDateTime );

	TDbCol endTimeCol( KIptvEpgScheduleEndTimeCol, EDbColDateTime );

    CDbColSet* scheduleColSet = CDbColSet::NewLC();

    scheduleColSet->AddL( keyCol );

    scheduleColSet->AddL( serviceIdCol );

    scheduleColSet->AddL( channelIdCol );

    scheduleColSet->AddL( programIdCol );

    scheduleColSet->AddL( startTimeCol );

    scheduleColSet->AddL( endTimeCol );

    User::LeaveIfError( aDatabase.CreateTable( KIptvEpgScheduleTable, *scheduleColSet ) );

    CleanupStack::PopAndDestroy( scheduleColSet );

	}

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

// CIptvEpgDatabase::CreateChannelProgramTableL()

//

// Creates ChannelProgram table. Leaves, if the table cannot be created.

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

void CIptvEpgDatabase::CreateChannelProgramTableL( 

										RDbNamedDatabase& /*aDatabase*/ ) const

    {

    }

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

// CIptvEpgDatabase::CreateProgramTableL()

//

// Creates Program table. Leaves, if the table cannot be created.

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

void CIptvEpgDatabase::CreateProgramTableL( RDbNamedDatabase& aDatabase ) const

    {

	LIVE_TV_TRACE1( _L("CIptvEpgDatabase::CreateProgramTableL" ) );

    // Key  

    TDbCol keyCol( KIptvEpgProgramDbKeyCol, EDbColUint32 );

    keyCol.iAttributes = TDbCol::EAutoIncrement;

    TDbCol idCol( KIptvEpgProgramIdCol, EDbColInt64 );

    TDbCol channelIdCol( KIptvEpgProgramChannelId, EDbColInt64 );

	TDbCol servProvIdCol( KIptvEpgProgramServProviderIdCol, EDbColUint32 );

    TDbCol uriCol( KIptvEpgProgramURICol, EDbColText, KIptvEpgUriMaxLength );

    TDbCol genreCol( KIptvEpgProgramGenreCol, EDbColText );

    TDbCol nameCol( KIptvEpgProgramNameCol, EDbColText, KIptvEpgProgramMaxLength );

    TDbCol descriptionCol( KIptvEpgProgramDescriptionCol, EDbColLongText );

    TDbCol languageCol( KIptvEpgProgramLanguageCol, EDbColText );

    TDbCol parentalCol( KIptvEpgProgramParentalRatingCol, EDbColText );

    CDbColSet* programColSet = CDbColSet::NewLC();

    programColSet->AddL( keyCol );

    programColSet->AddL( idCol );

    programColSet->AddL( channelIdCol );

	programColSet->AddL( servProvIdCol );

    programColSet->AddL( uriCol );

    programColSet->AddL( genreCol );

    programColSet->AddL( nameCol );

    programColSet->AddL( descriptionCol );

    programColSet->AddL( languageCol );

    programColSet->AddL( parentalCol );

    TInt error = aDatabase.CreateTable( KIptvEpgProgramTable, 

										*programColSet );

    if ( error != KErrNone )

        {

        LIVE_TV_TRACE2( _L("\t\tCIptvEpgDatabase::CreateProgramTableL CreateTable returned %d"), error );

        User::Leave( error );

        }

    CleanupStack::PopAndDestroy( programColSet ); 

    }

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

// CIptvEpgDatabase::CreateChannelTableL()

//

// Creates Channel table. Leaves, if the table cannot be created.

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

void CIptvEpgDatabase::CreateChannelTableL( RDbNamedDatabase& aDatabase ) const

    {

	LIVE_TV_TRACE1( _L("CIptvEpgDatabase::CreateChannelTableL" ) );

    // Key    

    TDbCol keyCol( KIptvEpgChannelDbKeyCol, EDbColUint32 );

    keyCol.iAttributes = TDbCol::EAutoIncrement;

    TDbCol idCol( KIptvEpgChannelIdCol, EDbColInt64 );

    TDbCol servProvIdCol( KIptvEpgChannelServProviderIdCol, EDbColUint32 );

    TDbCol nameCol( KIptvEpgChannelNameCol, EDbColText, KIptvEpgChannelNameMaxLength );

    TDbCol logoPathCol( KIptvEpgChannelLogoPathCol, EDbColText, KIptvEpgLogoPathMaxLength );

    TDbCol descriptionCol( KIptvEpgChannelDescriptionCol, EDbColText,

                           KIptvEpgDescrMaxLength );

    TDbCol uriCol( KIptvEpgChannelURICol, EDbColText, KIptvEpgUriMaxLength );

    TDbCol sdpCol( KIptvEpgChannelSDPCol, EDbColLongText );

	TDbCol orderCol( KIptvEpgChannelOrderCol, EDbColUint32 );

	// Create column set and add defined columns in to the set

    CDbColSet* channelColSet = CDbColSet::NewLC();

    channelColSet->AddL( keyCol );

    channelColSet->AddL( idCol );

    channelColSet->AddL( servProvIdCol );

    channelColSet->AddL( nameCol );

    channelColSet->AddL( logoPathCol );

    channelColSet->AddL( descriptionCol );

    channelColSet->AddL( uriCol );

    channelColSet->AddL( sdpCol );

    channelColSet->AddL( orderCol );

    // Create new table to the database with created columnset

    TInt error = aDatabase.CreateTable( KIptvEpgChannelTable, 

										*channelColSet );

    if ( error != KErrNone )

    	{

    	LIVE_TV_TRACE2( _L("\n\t\tCIptvEpgDatabase::CreateChannelTableL: CreateTable returned %d" ), error );

        User::Leave( error );

        }

    CleanupStack::PopAndDestroy( channelColSet );

    }

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

// CIptvEpgDatabase::CreateLastModifiedTableL()

//

// Creates table for last modified data

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

void CIptvEpgDatabase::CreateLastModifiedTableL( RDbNamedDatabase& aDatabase ) const

	{

	// First create columns

	TDbCol keyCol( KIptvEpgLastModifiedTableKeyCol, EDbColUint32 );

    keyCol.iAttributes = TDbCol::EAutoIncrement;

    TDbCol serviceIdCol( KIptvEpgLastModifiedTableServiceIdCol, EDbColUint32 );

	TDbCol eTagCol( KIptvEpgLastModifiedTableETagCol, EDbColText );

	TDbCol lastModifiedDateTime( KIptvEpgLastModifiedTableTimeCol, EDbColText );

	CDbColSet* lastModifiedColSet = CDbColSet::NewLC();

	lastModifiedColSet->AddL( keyCol );

	lastModifiedColSet->AddL( serviceIdCol );

	lastModifiedColSet->AddL( eTagCol );

	lastModifiedColSet->AddL( lastModifiedDateTime );

	TInt error = aDatabase.CreateTable( KIptvEpgLastModifiedTable, *lastModifiedColSet );

	CleanupStack::PopAndDestroy( lastModifiedColSet );

	if ( error != KErrNone )

		{

		LIVE_TV_TRACE2( _L("aDatabase.CreateTable for last modified table caused leave: %d"), error );

		User::Leave( error );

		}

	}

// SET OF GETTERS FOR CHANNEL AND PROGRAM DATA

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

// CIptvEpgDatabase::GetChannelsL()

// 

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

//

EXPORT_C void CIptvEpgDatabase::GetChannelsL( const TUint32 aServiceProviderId,

											  RPointerArray<CIptvEpgChannel>*

											  aResultArray )

	{

	LIVE_TV_TRACE1(_L("CIptvEpgDatabase::GetChannelsL()"));    	

	if ( iLocalState == EBackup )

		{

		return;

		}

    if ( !aResultArray )

        {

        User::Leave( KErrArgument );

        }

	TBuf<KCustomSqlLength> sqlStatement;

    sqlStatement.Append( _L("SELECT * FROM "));

    sqlStatement.Append( KIptvEpgChannelTable );

    sqlStatement.Append( _L(" WHERE ") );

    sqlStatement.Append( KIptvEpgChannelServProviderIdCol );

    sqlStatement.Append( _L(" = ") );

    sqlStatement.AppendNum( aServiceProviderId );

	DoGetChannelsL( sqlStatement, aResultArray );    

    }

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

// CIptvEpgDatabase::DoGetChannelsL()

// 

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

//

void CIptvEpgDatabase::DoGetChannelsL( const TDesC& aQuery,

											  RPointerArray<CIptvEpgChannel>*

											  aResultArray )

	{

	LIVE_TV_TRACE1(_L("CIptvEpgDatabase::DoGetChannelsL() in"));

	if ( iLocalState == EBackup )

		{

		return;

		}

	TInt err( KErrNone ); 

    if ( !aResultArray )

        {

        User::Leave( KErrArgument );

        }

    RDbView view;

    CleanupClosePushL( view );

    LIVE_TV_TRACE1( _L("CIptvEpgDatabase::DoGetChannelsL about to prepare") ); 

    err =  view.Prepare( iMulticastDb,

    					 TDbQuery(aQuery),

    					 TDbWindow::EUnlimited,

    					 RDbView::EReadOnly );

    LIVE_TV_TRACE2( _L("CIptvEpgDatabase::DoGetChannelsL  prepare = %d"), err ); 

    User::LeaveIfError ( err ); 

    LIVE_TV_TRACE1( _L("CIptvEpgDatabase::DoGetChannelsL about to eval") );        								  

    User::LeaveIfError( view.EvaluateAll() );

    LIVE_TV_TRACE1( _L("CIptvEpgDatabase::DoGetChannelsL about to get colset ") );        

    CDbColSet* colSet = view.ColSetL();

	CleanupStack::PushL( colSet );

    TInt idColNo = colSet->ColNo( KIptvEpgChannelIdCol );

    TInt servProbIdColNo = colSet->ColNo( KIptvEpgChannelServProviderIdCol );

    TInt nameColNo = colSet->ColNo( KIptvEpgChannelNameCol );

    TInt logoColNo = colSet->ColNo( KIptvEpgChannelLogoPathCol );

    TInt descrColNo = colSet->ColNo( KIptvEpgChannelDescriptionCol );

    TInt uriColNo = colSet->ColNo( KIptvEpgChannelURICol );

    TInt sdpColNo = colSet->ColNo( KIptvEpgChannelSDPCol );

	TInt orderColNo = colSet->ColNo( KIptvEpgChannelOrderCol );

	CleanupStack::PopAndDestroy( colSet );

    LIVE_TV_TRACE1( _L("CIptvEpgDatabase::DoGetChannelsL getting first") );        

    view.FirstL();

    while ( view.AtRow() )

        {

        view.GetL();            

        CIptvEpgChannel* channel = CIptvEpgChannel::NewL();

        CleanupStack::PushL( channel );

		channel->SetChannelId( view.ColInt64( idColNo ) );

		channel->SetServiceId( view.ColUint32( servProbIdColNo ) );

		channel->SetChannelName( view.ColDes( nameColNo ).AllocL() );

		channel->SetChannelLogoPath( view.ColDes( logoColNo ).AllocL() );

		channel->SetChannelDescription( view.ColDes( descrColNo ).AllocL() );

		channel->SetChannelURI( view.ColDes( uriColNo ).AllocL() );

		// SDP data is stored in long text field, so it needs to be read

		// through stream

		TInt sdpLength = view.ColLength( sdpColNo );

		HBufC* temp = HBufC::NewL( sdpLength );

		CleanupStack::PushL( temp );

		RDbColReadStream read;

		read.OpenLC( view, sdpColNo );

		TPtr ptr = temp->Des();

		read.ReadL( ptr, sdpLength );

		read.Close();

		CleanupStack::PopAndDestroy(); // read;

		channel->SetChannelSDP( temp ); // Ownership transferred

		CleanupStack::Pop( temp );

		channel->SetChannelOrder( view.ColUint32( orderColNo ) );

		TLinearOrder<CIptvEpgChannel> order(

							CIptvEpgChannel::LinearOrderByOrderNum );

		// Insert the channel to the array ordered by 

		// CIptvEpgChannel::LinearOrderByOrderNum function

		User::LeaveIfError( aResultArray->InsertInOrderAllowRepeats( channel,

							order ) );

        CleanupStack::Pop( channel ); // ownership transferred to aResultArray

        view.NextL();

        }

	LIVE_TV_TRACE2( _L("Added %d channels to aResultArray"), aResultArray->Count() );

	CleanupStack::PopAndDestroy( &view ); // closes view

	LIVE_TV_TRACE1(_L("CIptvEpgDatabase::DoGetChannelsL() out"));

    }

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

// CIptvEpgDatabase::GetProgramsByChannelIdL()

// 

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

//

EXPORT_C void CIptvEpgDatabase::GetProgramsByChannelIdL( 

								const TUint32 aServiceProviderId,

								const TInt64 aChannelKey,

								RPointerArray<CIptvEpgProgram>* aResultArray )

    {

    LIVE_TV_TRACE3(_L("CIptvEpgDatabase::GetProgramsByChannelIdL() ser %d cha %Li"), (int)aServiceProviderId, aChannelKey);

	if ( iLocalState == EBackup )

		{