/*
* Copyright (c) 2009 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:  The implementation for presentation elements.
*
*/


#include <bautils.h>

#include "irdebug.h" 
#include "irsessiondb.h"
#include "irsessionloggerutility.h"

_LIT( KSessionTable, "Session" ); 
_LIT( KID, "id" );
_LIT( KSessionLogCol,  "SessionData" );
_LIT( KSessionIndex, "SessionIndex" );

const TInt KMaxNoSession = 15;


// ---------------------------------------------------------------------------
// Function : NewL()
// two phased construction
// ---------------------------------------------------------------------------
//
  CIRSessionDb* CIRSessionDb::NewL()
    {
    IRLOG_DEBUG( "CIRSessionDb::NewL" );
    CIRSessionDb* self;
    self = CIRSessionDb::NewLC();
    CleanupStack::Pop( self );
    IRLOG_DEBUG( "CIRSessionDb::NewL - Exiting." );
    return self;
    }

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

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

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

// ---------------------------------------------------------------------------
// CIRSessionDb:AddSessionStartL()
// adds the session log entry into data base
// ---------------------------------------------------------------------------
//
void CIRSessionDb::AddSessionStartL( CIRSessionLogger& aSession )
    {
    IRLOG_DEBUG( "CIRSessionDb::AddSessionStartL" );
    OpenDbL();
    RDbTable sessionlogtable;
    TInt error=sessionlogtable.Open( iSessionDb, KSessionTable, sessionlogtable.
        EUpdatable );
    CleanupClosePushL( sessionlogtable );
    if ( error )
        {
        CloseDb();
        User::LeaveIfError( error );    
        }
    
    //! arrange the presets in incresing order of index
    sessionlogtable.SetIndex( KSessionIndex );
    sessionlogtable.Reset();

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

    _LIT( query, "SELECT * FROM %S" );    
    HBufC* sqlStr = HBufC::NewLC( query().Length() + KSessionTable().Length() );
    sqlStr->Des().Format( query, &KSessionTable );
    
    // Create a view on the database
    RDbView view;     
    error = view.Prepare( iSessionDb, *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 ), aSession.SessionId() );    
        //!open stream
        writeStream.OpenLC( view, columns->ColNo( KSessionLogCol ) );
        aSession.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( "CIRSessionDb::AddSessionStartL - Exiting." );
    }

// ---------------------------------------------------------------------------
// CIRSessionDb::GetAllPresetL()
// gets all the preset into an array 
// ---------------------------------------------------------------------------
//
void CIRSessionDb::GetAllSessionL(
    CArrayPtrFlat<CIRSessionLogger>& aSessionDataList )
    {
    IRLOG_DEBUG( "CIRSessionDb::GetAllSessionL" );
    OpenDbL();
    //not sure about this resetanddestroy
     //! Open for preset master
    aSessionDataList.ResetAndDestroy();        
    //! temp item for holding the retrived data
    CIRSessionLogger *item;
    RDbColReadStream instream;    
    RDbTable table;
    TInt error = table.Open( iSessionDb, KSessionTable, 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( KSessionIndex );
    table.Reset();
    //! recursively retrive the preset data from the master table
    for ( table.FirstL(); table.AtRow(); table.NextL() )
        {
        item = CIRSessionLogger::NewL();
        CleanupStack::PushL( item );
        table.GetL();
        instream.OpenLC( table, colSet->ColNo( KSessionLogCol ) );
        item->InternalizeL( instream );
        //update sessionid
        aSessionDataList.AppendL( item );
        CleanupStack::PopAndDestroy( &instream );
        CleanupStack::Pop( item );
        }
        
    CleanupStack::PopAndDestroy( colSet );
    //!close the master table
    CleanupStack::PopAndDestroy( &table );
    CloseDb();
    IRLOG_DEBUG( "CIRSessionDb::GetAllSessionL - Exiting." );
    }

// ---------------------------------------------------------------------------
// Function : DeleteAllSession
// delete all the session from session log entry
// ---------------------------------------------------------------------------
//
void CIRSessionDb::DeleteAllSessionL()
    { 
    IRLOG_DEBUG( "CIRSessionDb::DeleteAllSessionL" ); 
    //opening a data base 
    OpenDbL();
    RDbTable sessionlogtable;
    //data base table opened
    TInt error = sessionlogtable.Open( iSessionDb, KSessionTable, sessionlogtable.
        EUpdatable );
    CleanupClosePushL( sessionlogtable );
    if ( error != KErrNone )
         {
         //if error we leave
         CloseDb();
         User::LeaveIfError( error );
         }
    //data base begin     
    error = iSessionDb.Begin();
    if ( error != KErrNone )
         {
         //if open fails function leaves
         CloseDb();
         User::LeaveIfError( error );
         }

    //! arrange the presets in incresing order of index
    sessionlogtable.SetIndex( KSessionIndex );
    sessionlogtable.Reset();
    sessionlogtable.FirstL();
    while( sessionlogtable.AtRow() )
        {
        //deleting all the rows in the table
        sessionlogtable.GetL();
        sessionlogtable.DeleteL();
        sessionlogtable.FirstL();
        }
    //saving the change
    CleanupStack::PopAndDestroy( &sessionlogtable );
    iSessionDb.Commit();
    CloseDb();    
    IRLOG_DEBUG( "CIRSessionDb::DeleteAllSessionL - Exiting." );
    }   

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

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

// ---------------------------------------------------------------------------
// Function : CreateSessionTableL
// creates sessionlogtable with two column one is sessionid and rest of session
// log data
// ---------------------------------------------------------------------------
//SessionTable
//---------------------------
//| KID   |     KSessionLogCol |
//---------------------------
//|TInt32 | EDbColLongText8 |
//---------------------------
//
void CIRSessionDb::CreateSessionTableL()
    {
    IRLOG_DEBUG( "CIRSessionDb::CreateSessionTableL" );
    //start time of session
    TDbCol sessionid( KID, EDbColInt32 );
    sessionid.iAttributes = TDbCol::ENotNull; 
    
    //!this column is used to store preset data
    //!The column stores a potentially large amount of non-Unicode text data.
    TDbCol sessionlogcol( KSessionLogCol, EDbColLongText8 );
       sessionlogcol.iAttributes = TDbCol::ENotNull; 
       
    CDbColSet* sessionlogcolset = CDbColSet::NewLC();
    sessionlogcolset->AddL( sessionid );
    sessionlogcolset->AddL( sessionlogcol );

    // Create the sessionlog table with two columns
    
    User::LeaveIfError( iSessionDb.CreateTable( KSessionTable,
         *sessionlogcolset ) );
    
    //Create the KeyIndex for the table
    CreateSessionIndexL();
    CleanupStack::PopAndDestroy( sessionlogcolset );
    IRLOG_DEBUG( "CIRSessionDb::CreateSessionTableL - Exiting." );    
    }

// ---------------------------------------------------------------------------
// Function : CreateSessionIndexL
// sets sessionid as the primary key
// ---------------------------------------------------------------------------
//
void CIRSessionDb::CreateSessionIndexL()
    {
    IRLOG_DEBUG( "CIRSessionDb::CreateSessionIndexL" );
    TDbKeyCol sessionid( KID );
    CDbKey* index = CDbKey::NewLC();
    index->AddL( sessionid );
    User::LeaveIfError( iSessionDb.CreateIndex( KSessionIndex, KSessionTable,
        *index ) );
    CleanupStack::PopAndDestroy( index );
    IRLOG_DEBUG( "CIRSessionDb::CreateSessionIndexL - Exiting." );
    }
    
// ---------------------------------------------------------------------------
// CIRSessionDb::OpenDbL()
// opening the data base 
// ---------------------------------------------------------------------------
//
 void CIRSessionDb::OpenDbL()
    {
    IRLOG_DEBUG( "CIRSessionDb::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 = iSessionDb.Open( iFsSession, iDbFile );    
    if ( error != KErrNone )
        {
        //if database is failed to open then 
        //function leaves
        IRLOG_ERROR2( "CIRSessionDb::OpenDbL - Opening session database failed ( %d )", error );
        User::LeaveIfError( error );
        }
    if ( iSessionDb.IsDamaged() || !iSessionDb.InTransaction() )
        {
        //if data base is damaged then 
        //it tried to recover
        //if recovery is not possible function leaves
        error = iSessionDb.Recover();
        if ( KErrNone == error )
            {
            //if recovered data base is compacted
            error = iSessionDb.Compact();    
            }
        User::LeaveIfError( error );    
        }
    IRLOG_DEBUG( "CIRSessionDb::OpenDbL - Exiting." );
    }

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