/*
* 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 "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: provides handling of indexing in database
*
*
*/


#include <e32base.h>
#include <epos_cposlmlocaldbaccess.h>
#include <epos_poslmlandmarkhandler.h>
#include <epos_poslmdatabaseutility.h>

#include "EPos_CPosLmServer.h"
#include "EPos_CPosLmNameIndex.h"
#include "epos_lmdebug.h"
#include "epos_poslmserverutility.h"
#include "epos_cposlmindexmanager.h"

const TTimeIntervalMicroSeconds KPosLmMaxIndexOlderThanDb = 1*1000*1000; // 1 sec
const TTimeIntervalMicroSeconds KPosLmMaxIndexNewerThanDb = 60*1000*1000; // 1 min

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

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLmIndexManager::CItem::~CItem()
    {
    delete iDbAccess;
    delete iIndex;
    delete iDbUri;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLmIndexManager::CPosLmIndexManager( CPosLmServer& aServer )
: 	iServer( aServer )
    {
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLmIndexManager::~CPosLmIndexManager()
    {
    ASSERT( iIndexes.Count() == 0 ); // all indexes should be already disconnected
    iIndexes.ResetAndDestroy();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLmIndexManager* CPosLmIndexManager::NewL( CPosLmServer& aServer )
    {
    CPosLmIndexManager* self = new (ELeave) CPosLmIndexManager( aServer );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmIndexManager::ConstructL()
    {
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmIndexManager::AddIndexUserL( const TDesC& aUri )
    {
    TInt pos = Find( aUri );
    if ( pos != KErrNotFound )
        {
        CItem* item = iIndexes[pos];
        item->iRefCount++;
        }
    else
        {
        LoadIndexL( aUri );
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmIndexManager::RemoveIndexUser( const TDesC& aUri )
    {
    TInt pos = Find( aUri );
    if ( pos != KErrNotFound )
        {
        CItem* item = iIndexes[pos];
        if ( --(item->iRefCount) <= 0 )
            {
            iIndexes.Remove( pos );
            ASSERT( !item->iHasWriteLock && !item->iHasReadLock );
            item->iHasWriteLock = ETrue;
#ifdef _DEBUG
            TRAPD( err, SaveIndexL( *item ) );
            LOG2( "IndexManager: Saved index for db '%S', err %d", &aUri, err );
#else
            TRAP_IGNORE( SaveIndexL( *item ) );
#endif            
            delete item;
            }
        }
    }

// -----------------------------------------------------------------------------
// This one should always succeed, because any client should first register
// for the URI before asking index
// -----------------------------------------------------------------------------
//
CPosLmNameIndex& CPosLmIndexManager::Index( const TDesC& aUri )
    {
    TInt pos = Find( aUri );
    ASSERT( pos >= 0 ); 
    return *(iIndexes[pos]->iIndex); // there is always valid index pointer
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TInt CPosLmIndexManager::Find( const TDesC& aUri ) const
    {
    for ( int i = 0; i < iIndexes.Count(); ++i ) 
        {
        if ( iIndexes[i]->iDbUri->CompareF( aUri ) == 0 )
            {
            return i;
            }
        }
    return KErrNotFound;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmIndexManager::LoadIndexL( const TDesC& aUri )
    {
    CItem* item = new (ELeave) CItem();
    CleanupStack::PushL( item );

    item->iDbUri = aUri.AllocL();
    item->iRefCount = 1;
    
    CPosLmLocalDbAccess* dbAccess = CPosLmLocalDbAccess::NewL();
    item->iDbAccess = dbAccess;
    TInt err = dbAccess->OpenDatabaseL( aUri );
    User::LeaveIfError( err );

    item->iIndex = CPosLmNameIndex::NewL( *dbAccess );
    if ( item->iIndex->Status() == KErrNone && 
         PosLmServerUtility::TotalLandmarkCountL( *dbAccess ) > 0 )
        {
        // advanced check: 
        // verify that index timestamp is not older
        // than timestamp of the database
        if ( !IsIndexValidL( DatabaseStampL( aUri ), item->iIndex->TimeStamp() ) )
            {
            item->iIndex->Reset();
            }
        }
    
    iIndexes.AppendL( item );
    CleanupStack::Pop( item );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TBool CPosLmIndexManager::HasWriteLock( const TDesC& aUri ) const
    {
    TInt pos = Find( aUri );
    if ( pos != KErrNotFound )
        {
        CItem* item = iIndexes[pos];
        if ( item->iHasWriteLock )
            {
            return ETrue;
            }
        }

    return EFalse;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TBool CPosLmIndexManager::HasAnyLock( const TDesC& aUri ) const
    {
    TInt pos = Find( aUri );
    if ( pos != KErrNotFound )
        {
        CItem* item = iIndexes[pos];
        if ( item->iHasWriteLock || item->iHasReadLock )
            {
            return ETrue;
            }
        }

    return EFalse;
    }

// -----------------------------------------------------------------------------
// RDb does not expose any method to detect database modification timestamp
// or any automatic timestamp. This is a workaround.
// -----------------------------------------------------------------------------
//
TTime CPosLmIndexManager::DatabaseStampL( const TDesC& aDbUri ) const 
    {
    LOG1("IndexManager::DatabaseStamp: dbUri '%S'", &aDbUri );

    TFileName dbPath( aDbUri );
    TPtrC path( dbPath );
    PosLmDatabaseUtility::RemoveProtocolFromUriL( path );

    _LIT( KDatabaseFilePath, "\\private\\100012a5\\DBS_%X_" );
    TFileName filename;
    // drive
    TInt delimPos = path.Locate(':'); 
    filename.Copy( path.Left( delimPos + 1 ) );
    filename.AppendFormat( KDatabaseFilePath(), KPosLmDbSecureUid );
    filename.Append( path.Mid( delimPos + 1 ) );
    
    LOG1("IndexManager::DatabaseStamp: file '%S'", &filename );

    TTime modified;
    TInt err = iServer.FileSession().Modified( filename, modified );
#ifdef _DEBUG    
    TBuf<64> mtime;
    modified.FormatL( mtime, KPosLmTimeFormat );
    LOG2("IndexManager::DatabaseStamp: file modtime %S, error %d", &mtime, err );
#endif    
    if ( err ) 
        {
        modified.UniversalTime();
        modified += TTimeIntervalDays( 1 );
        }
    
    return modified;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CPosLmIndexManager::SaveIndexL( CItem& aItem )
    {
    TChar drive = (*(aItem.iDbUri))[KPosLocalDbFileProtocol().Length()];
    aItem.iIndex->SaveL( drive );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
TBool CPosLmIndexManager::IsIndexValidL( const TTime& aDbStamp, const TTime& aIndexStamp ) const
    {
    TTime now;
    now.UniversalTime();
    
#ifdef _DEBUG
    TBuf<64> dtime, itime;
    aDbStamp.FormatL( dtime, KPosLmTimeFormat );
    aIndexStamp.FormatL( itime, KPosLmTimeFormat );
    LOG2("IndexManager: timestamps: index %S, db %S", &itime, &dtime );

    TTimeIntervalMicroSeconds diff = aIndexStamp.MicroSecondsFrom( aDbStamp );
#endif 

    if ( aDbStamp > now || aIndexStamp > now )
        {
        LOG("IndexManager: index and/or db time is in future, index invalid");
        return EFalse;
        }
    else if ( aIndexStamp + KPosLmMaxIndexOlderThanDb < aDbStamp )
        {
        LOG1("IndexManager: database newer than index, diff %ld us, index invalid", diff.Int64() );
        return EFalse;
        }
    else if ( aIndexStamp - KPosLmMaxIndexNewerThanDb > aDbStamp )
        {
        LOG1("IndexManager: index is too much newer than database, diff %ld us, index invalid", diff.Int64() );
        return EFalse;
        }
    else
        {
        return ETrue;
        }
    }