/*
* Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "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:  ?Description
*
*/


#include <bautils.h>

#include "irdebug.h" 
#include "irnmslogdb.h"
#include "irnmslogger.h"

_LIT(KNmsLogTable,"NmsLog"); 
_LIT(KID,"id");
_LIT(KNmsLogCol,  "NmsLogData");
_LIT(KNmsLogIndex,"NmsLogIndex");

const TInt KMaxNoNmsLog = 15;


// ======== LOCAL FUNCTIONS ========


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

// ---------------------------------------------------------------------------
// Function : NewL()
// two phased construction
// ---------------------------------------------------------------------------
//
  CIRNmsLogDb* CIRNmsLogDb::NewL()
	{
	IRLOG_DEBUG( "CIRNmsLogDb::NewL" );
	CIRNmsLogDb* self;
	self=CIRNmsLogDb::NewLC();
	CleanupStack::Pop(self);
	IRLOG_DEBUG( "CIRNmsLogDb::NewL - Exiting." );
	return self;
	}
 
 
// ---------------------------------------------------------------------------
// Function : NewLC()
// Two phased construction
// ---------------------------------------------------------------------------
//
  CIRNmsLogDb* CIRNmsLogDb::NewLC()
	{
	IRLOG_DEBUG( "CIRNmsLogDb::NewLC" );
	CIRNmsLogDb *self;
	self=new(ELeave)CIRNmsLogDb;
	CleanupStack::PushL(self);
	self->ConstructL();
	IRLOG_DEBUG( "CIRNmsLogDb::NewLC - Exiting." );
	return self;
	}
 

// ---------------------------------------------------------------------------
// CIRNmsLogDb::~CIRNmsLogDb()
// default destructor
// ---------------------------------------------------------------------------
//
CIRNmsLogDb::~CIRNmsLogDb()
	{
	IRLOG_DEBUG( "CIRNmsLogDb::~CIRNmsLogDb" );
	CloseDb();
	iFsSession.Close();
	IRLOG_DEBUG( "CIRNmsLogDb::~CIRNmsLogDb - Exiting." );
	}

// ---------------------------------------------------------------------------
// CIRNmsLogDb::CreateDbConditional()
// Creates both the dbms files conditionally(only if not yet created)
// calls CreateDbL()
// ---------------------------------------------------------------------------
//
 TInt CIRNmsLogDb::CreateDbConditional(TFileName &aNmsLog)
	{
	IRLOG_DEBUG( "CIRNmsLogDb::CreateDbConditional" );
	iDbFile.Copy(aNmsLog);
	if( !BaflUtils::FileExists(iFsSession, iDbFile) )
		{
		TRAPD(error,CreateDbL(iDbFile));
		if( error )
			{
			IRLOG_DEBUG( "CIRNmsLogDb::CreateDbConditional - Exiting (1)." );
			return error;
			}	
		}
	IRLOG_DEBUG( "CIRNmsLogDb::CreateDbConditional - Exiting (2)." );
	return KErrNone;
	}

// ---------------------------------------------------------------------------
// CIRNmsLogDb:AddNmsLogStartL()
// adds the NmsLog log entry into data base
// ---------------------------------------------------------------------------
//
void CIRNmsLogDb::AddNmsLogStartL(CIRNmsLogger& aNmsLog)
	{
	IRLOG_DEBUG( "CIRNmsLogDb::AddNmsLogStartL" );
	OpenDbL();
	RDbTable nmsLogtable;
	TInt error=nmsLogtable.Open(iNmsLogDb,KNmsLogTable,nmsLogtable.
		EUpdatable);
	CleanupClosePushL(nmsLogtable);
	if( error )
		{
		CloseDb();
		User::LeaveIfError(error);	
		}
	
	//! arrange the presets in incresing order of index
	nmsLogtable.SetIndex(KNmsLogIndex);
	nmsLogtable.Reset();

	//if NmsLog log is greater or equal to than 5
	if( nmsLogtable.CountL() >= KMaxNoNmsLog )
		{
		//first row is selected
		nmsLogtable.FirstL();
		//the current row is selected
		nmsLogtable.GetL();
		//delete that entry
		nmsLogtable.DeleteL();
		}	
    CleanupStack::PopAndDestroy(&nmsLogtable);
	//Algorithm : else condition need not handle seperatly
	//Algorithm : add NmsLogid and informations like
	//starttime,connectedfrom,NmsLogid,connectiontype,channelid
	//currentnetwork,homenetwork,NmsLogtable 
	//Algorithm: if no. of NmsLog is greater than 5

	_LIT(query,"SELECT * FROM %S");	
    HBufC* sqlStr=HBufC::NewLC(query().Length() + KNmsLogTable().Length());
	sqlStr->Des().Format(query,&KNmsLogTable);
	
	// Create a view on the database
    RDbView view;     
    error = view.Prepare(iNmsLogDb,*sqlStr);
    if( error )
		{
		CloseDb();
		User::LeaveIfError(error);	
		}
    CleanupStack::PopAndDestroy(sqlStr);     
    CleanupClosePushL(view);
    error = view.EvaluateAll();
    if( error )
		{
		CloseDb();
		User::LeaveIfError(error);	
		}
    CDbColSet* columns = view.ColSetL();
    CleanupStack::PushL(columns);
    
    RDbColWriteStream writeStream;
	TRAP(error,//trap start
	   // Insert a row. Column order matches sql select statement
	    view.InsertL();
		//get index
		view.SetColL(columns->ColNo(KID), aNmsLog.NmsLogId());	
		//!open stream
		writeStream.OpenLC(view,columns->ColNo(KNmsLogCol));
		aNmsLog.ExternalizeL(writeStream);
		writeStream.CommitL();
		CleanupStack::PopAndDestroy(&writeStream);
 		);
 		
 	CleanupStack::PopAndDestroy(columns);
 	if( error!=KErrNone )
	 	{
	 	CloseDb();
	 	User::LeaveIfError(error);
	 	}
	view.PutL();
 	CleanupStack::PopAndDestroy(&view);
 	CloseDb();
 	IRLOG_DEBUG( "CIRNmsLogDb::AddNmsLogStartL - Exiting." );
	}

// ---------------------------------------------------------------------------
// CIRNmsLogDb::GetAllNmsLogL()
// gets all the preset into an array 
// ---------------------------------------------------------------------------
//
void CIRNmsLogDb::GetAllNmsLogL(
	CArrayPtrFlat<CIRNmsLogger>& aNmsLogDataList)
	{
	IRLOG_DEBUG( "CIRNmsLogDb::GetAllNmsLogL" );
	OpenDbL();
	//not sure about this resetanddestroy
	 //! Open for preset master
	aNmsLogDataList.ResetAndDestroy();	    
	//! temp item for holding the retrived data
	CIRNmsLogger *item;
	RDbColReadStream instream;    
	RDbTable table;
	TInt error = table.Open(iNmsLogDb, KNmsLogTable, table.EReadOnly);
	CleanupClosePushL(table);
	if( error!=KErrNone )
	 	{
	 	//if open fails function leaves
	 	CloseDb();
	 	User::LeaveIfError(error);
	 	}

	CDbColSet* colSet = table.ColSetL();
	CleanupStack::PushL(colSet);

	//! arrange the presets in incresing order of index
	table.SetIndex(KNmsLogIndex);
	table.Reset();
	//! recursively retrive the preset data from the master table
	for (table.FirstL(); table.AtRow(); table.NextL())
	    {
	    item=CIRNmsLogger::NewL();
	    CleanupStack::PushL(item);
	    table.GetL();
	    instream.OpenLC( table, colSet->ColNo( KNmsLogCol ) );
		item->InternalizeL(instream);
		//update NmsLogid
	    aNmsLogDataList.AppendL(item);
	    CleanupStack::PopAndDestroy(&instream);
	    CleanupStack::Pop(item);
	    }
	    
	CleanupStack::PopAndDestroy(colSet);
	//!close the master table
	CleanupStack::PopAndDestroy(&table);
	CloseDb();
	IRLOG_DEBUG( "CIRNmsLogDb::GetAllNmsLogL - Exiting." );
	}

// ---------------------------------------------------------------------------
// Function : DeleteAllNmsLog
// delete all the NmsLog from NmsLog log entry
// ---------------------------------------------------------------------------
//
void CIRNmsLogDb::DeleteAllNmsLogL()
	{ 
	IRLOG_DEBUG( "CIRNmsLogDb::DeleteAllNmsLogL" ); 
	//opening a data base 
	OpenDbL();
	RDbTable nmsLogtable;
	//data base table opened
    TInt error=nmsLogtable.Open(iNmsLogDb,KNmsLogTable,nmsLogtable.
    	EUpdatable);
    CleanupClosePushL(nmsLogtable);
    if( error!=KErrNone )
	 	{
	 	//if error we leave
	 	CloseDb();
	 	User::LeaveIfError(error);
	 	}
	//data base begin 	
    error = iNmsLogDb.Begin();
    if( error!=KErrNone )
	 	{
	 	//if open fails function leaves
	 	CloseDb();
	 	User::LeaveIfError(error);
	 	}

    //! arrange the presets in incresing order of index
    nmsLogtable.SetIndex(KNmsLogIndex);
    nmsLogtable.Reset();
    nmsLogtable.FirstL();
    while(nmsLogtable.AtRow())
	    {
	    //deleting all the rows in the table
	    nmsLogtable.GetL();
	    nmsLogtable.DeleteL();
		nmsLogtable.FirstL();
	    }
	//saving the change
	CleanupStack::PopAndDestroy(&nmsLogtable);
    iNmsLogDb.Commit();
    CloseDb();	
    IRLOG_DEBUG( "CIRNmsLogDb::DeleteAllNmsLogL - Exiting." );
	}   

// ---------------------------------------------------------------------------
// CIRNmsLogDb::ConstructL()
// Standard 2nd phase construction
// ---------------------------------------------------------------------------
//
void CIRNmsLogDb::ConstructL()
	{
	IRLOG_DEBUG( "CIRNmsLogDb::ConstructL" );
	User::LeaveIfError(iFsSession.Connect());
	IRLOG_DEBUG( "CIRNmsLogDb::ConstructL- Exiting." );	
	}

// ---------------------------------------------------------------------------
// CIRNmsLogDb::CloseDb()
// Closes the database 
// ---------------------------------------------------------------------------
//
void CIRNmsLogDb::CloseDb()
	{
	IRLOG_DEBUG( "CIRNmsLogDb::CloseDb" );
	iNmsLogDb.Close();
	IRLOG_DEBUG( "CIRNmsLogDb::CloseDb - Exiting." );
	}


// ---------------------------------------------------------------------------
// Function : CreateNmsLogTableL
// creates NmsLogtable with two column one is NmsLogid and rest of NmsLog
// log data
// ---------------------------------------------------------------------------
//NmsLogTable
//---------------------------
//| KID   |	 KNmsLogCol |
//---------------------------
//|TInt32 | EDbColLongText8 |
//---------------------------
//
void CIRNmsLogDb::CreateNmsLogTableL()
	{
	IRLOG_DEBUG( "CIRNmsLogDb::CreateNmsLogTableL" );
	//start time of NmsLog
	TDbCol nmsLogid(KID, EDbColInt32);
	nmsLogid.iAttributes = TDbCol::ENotNull; 
	
    //!this column is used to store preset data
    //!The column stores a potentially large amount of non-Unicode text data.
    TDbCol nmsLogcol(KNmsLogCol, EDbColLongText8);
   	nmsLogcol.iAttributes = TDbCol::ENotNull; 
   	
	CDbColSet* nmsLogcolset = CDbColSet::NewLC();
	nmsLogcolset->AddL(nmsLogid);
	nmsLogcolset->AddL(nmsLogcol);

	// Create the NmsLoglog table with two columns
	
	User::LeaveIfError(iNmsLogDb.CreateTable(KNmsLogTable,
		 *nmsLogcolset));
	
	//Create the KeyIndex for the table
	CreateNmsLogIndexL();
	CleanupStack::PopAndDestroy(nmsLogcolset);
	IRLOG_DEBUG( "CIRNmsLogDb::CreateNmsLogTableL - Exiting." );	
	}

// ---------------------------------------------------------------------------
// Function : CreateNmsLogIndexL
// sets NmsLogid as the primary key
// ---------------------------------------------------------------------------
//
void CIRNmsLogDb::CreateNmsLogIndexL()
	{
	IRLOG_DEBUG( "CIRNmsLogDb::CreateNmsLogIndexL" );
	TDbKeyCol nmsLogid(KID);
	CDbKey* index = CDbKey::NewLC();
	index->AddL(nmsLogid);
	User::LeaveIfError(iNmsLogDb.CreateIndex( KNmsLogIndex, KNmsLogTable,
		*index));
	CleanupStack::PopAndDestroy(index);
	IRLOG_DEBUG( "CIRNmsLogDb::CreateNmsLogIndexL - Exiting." );
	}
	
// ---------------------------------------------------------------------------
// CIRNmsLogDb::OpenDbL()
// opening the data base 
// ---------------------------------------------------------------------------
//
 void CIRNmsLogDb::OpenDbL()
	{
	IRLOG_DEBUG( "CIRNmsLogDb::OpenDbL" );
	CloseDb();
	TInt error = KErrNone;
	if( !BaflUtils::FileExists(iFsSession, iDbFile) )
	    {
	    //if file doesn't exist function leaves with error code
	    //KErrNotFound
	    error = KErrNotFound;
	    User::LeaveIfError(error);
	    }

	error = iNmsLogDb.Open(iFsSession,iDbFile);	
	if( error!=KErrNone )
		{
		//if database is failed to open then 
		//function leaves
		IRLOG_ERROR2( "CIRNmsLogDb::OpenDbL - Opening NmsLog database failed (%d)", error );
		User::LeaveIfError(error);
		}
	if( iNmsLogDb.IsDamaged() || !iNmsLogDb.InTransaction() )
		{
		//if data base is damaged then 
		//it tried to recover
		//if recovery is not possible function leaves
		error = iNmsLogDb.Recover();
		if ( KErrNone == error)
			{
			//if recovered data base is compacted
			error = iNmsLogDb.Compact();	
			}
	    User::LeaveIfError(error);	
		}
	IRLOG_DEBUG( "CIRNmsLogDb::OpenDbL - Exiting." );
	}
	

// ---------------------------------------------------------------------------
// CIRNmsLogDb::CreateDbL()
// Creates both the dbms files 
// calls CreateFavMasterTableL(),CreateFavUrlTableL
// database filename
// ---------------------------------------------------------------------------
//
 void CIRNmsLogDb::CreateDbL(TFileName& aNmsLog)
	{
	IRLOG_DEBUG( "CIRNmsLogDb::CreateDbL" );
	CloseDb();
	TInt error = iNmsLogDb.Replace(iFsSession,aNmsLog);
	if ( error != KErrNone )
	    {
	    IRLOG_ERROR2( "CIRNmsLogDb::CreateDbL - Creating NmsLog database failed (%d)", error );
	    }
	User::LeaveIfError(error);
	CreateNmsLogTableL();
	IRLOG_DEBUG( "CIRNmsLogDb::CreateDbL - Exiting." );
	}