/*
* 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:   CNcdEngineConfiguration implementation
 *
*/


#include <bautils.h>

#include "ncdengineconfigurationimpl.h"
#include "ncdproviderutils.h"
#include "catalogsutils.h"
#include "catalogsuids.h"
#include "ncdprotocolutils.h"
#include "catalogsconstants.h"
#include "ncdproviderdefines.h"
#include "ncdutils.h"
#include "ncddeviceservice.h"

namespace NcdEngineConfiguration
    {
    _LIT8( KVersion, "version" );
    _LIT8( KType, "type" );
    _LIT8( KProvisioning, "provisioning" );
    _LIT8( KNetwork, "network" );
    _LIT8( KMcc, "mcc" );
    _LIT8( KMnc, "mnc" );
    _LIT8( KFixedAp, "fixed-access-point" );
    _LIT8( KAccessPointSettings, "access-point-settings" );
    _LIT8( KApId, "id" );
    _LIT8( KApDetail, "detail" );
    _LIT8( KApDetailId, "id" );
    _LIT8( KApDetailValue, "value" );
    }

_LIT( KEngineDefaultType, "vanilla" );
_LIT( KEngineDefaultVersion, "1.0" );


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CNcdEngineConfiguration* CNcdEngineConfiguration::NewL( MNcdDeviceService& aDeviceService )
    {
    CNcdEngineConfiguration* self = new( ELeave ) CNcdEngineConfiguration( aDeviceService );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;    
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CNcdEngineConfiguration::~CNcdEngineConfiguration()
    {
    DLTRACEIN((""));
    delete iType;
    delete iVersion;
    delete iProvisioning;
    delete iUid;    
    delete iMcc;
    delete iMnc;
    delete iApId;
    delete iApDetailId;
    delete iApDetailValue;
    delete iCorrectApId;
    
    iHomeMcc.Close();
    iHomeMnc.Close();
    
    iApDetails.ResetAndDestroy();
    }

// ---------------------------------------------------------------------------
// Configuration reader
// ---------------------------------------------------------------------------
//
void CNcdEngineConfiguration::ReadConfigurationL( const TDesC& aFilename )
    {
    DLTRACEIN(( _L("Config file: %S"), &aFilename ));
    CNcdConfigurationParser* parser = CNcdConfigurationParser::NewLC( *this );
    DLTRACE(("Reading file"));

    // find the file from engine's private paths
    HBufC* filename = FindEngineFileL( CNcdProviderUtils::FileSession(),
        aFilename );
    CleanupStack::PushL( filename );                        

    // Read the file
    HBufC8* data = ReadFileL( CNcdProviderUtils::FileSession(), *filename );
    
    CleanupStack::PopAndDestroy( filename );
    CleanupStack::PushL( data );
    DLTRACE(("Start parsing"));
    
    // Parse the file
    parser->ParseL( *data );
    CleanupStack::PopAndDestroy( 2, parser ); // data, parser
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
const TDesC& CNcdEngineConfiguration::EngineType() const
    {
    return *iType;
    }
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
const TDesC& CNcdEngineConfiguration::EngineVersion() const
    {
    return *iVersion;
    }
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
const TDesC& CNcdEngineConfiguration::EngineUid() const
    {
    return *iUid;
    }

// ---------------------------------------------------------------------------
// Provisioning getter
// ---------------------------------------------------------------------------
//
const TDesC& CNcdEngineConfiguration::EngineProvisioning() const
    {    
    return *iProvisioning;
    }


// ---------------------------------------------------------------------------
// Installation drive getter
// ---------------------------------------------------------------------------
//
const TDesC& CNcdEngineConfiguration::EngineInstallDrive() const
    {
    return iInstallationDrive;
    }


// ---------------------------------------------------------------------------
// Engine temp drive
// ---------------------------------------------------------------------------
//
TInt CNcdEngineConfiguration::EngineTempDrive() const
    {
    return static_cast<TInt>( iDataDrive );
    }
    

// ---------------------------------------------------------------------------
// Client data path getter
// ---------------------------------------------------------------------------
//
HBufC* CNcdEngineConfiguration::ClientDataPathLC(
    const TDesC& aClientId,
    TBool aTemp )
    {
    DLTRACEIN((""));
    TPath path;
    CreatePrivatePathL( 
        CNcdProviderUtils::FileSession(), 
        iDataDrive.Name(), 
        path );

    path.Append( aClientId );
    path.Append( KDirectorySeparator );
    if ( aTemp ) 
        {
        path.Append( NcdProviderDefines::KTempNamespace() );
        }
    else
        {
        path.Append( NcdProviderDefines::KDataNamespace() );
        }
    path.Append( KDirectorySeparator );
    BaflUtils::EnsurePathExistsL( CNcdProviderUtils::FileSession(), path );
    
    DLTRACEOUT( ( _L("Path: %S"), &path ) );
    return path.AllocLC();
    }

    
TBool CNcdEngineConfiguration::UseFixedAp() const 
    {
    DLTRACEIN((""));
    TBool retValue = iApDetails.Count() > 0;
    DLINFO(("retValue: %d", retValue ))
    return retValue;
    }
    
    
const RPointerArray<CNcdKeyValuePair>& CNcdEngineConfiguration::FixedApDetails() const 
    {
    DLTRACEIN((""));
    return iApDetails;
    }


// ---------------------------------------------------------------------------
// Client data path cleaner
// ---------------------------------------------------------------------------
//
void CNcdEngineConfiguration::ClearClientDataL( 
    const TDesC& aClientId, 
    TBool aTemp )
    {
    DLTRACEIN(( _L("aClient: %S"), &aClientId ));
    // Get the path and delete the directory
    HBufC* path = ClientDataPathLC( aClientId, aTemp );
    CFileMan* fileman = CFileMan::NewL( CNcdProviderUtils::FileSession() );
    CleanupStack::PushL( fileman );    
    User::LeaveIfError( fileman->RmDir( *path ) );
    CleanupStack::PopAndDestroy( 2, path ); // fileman, path        
    
    DLTRACEOUT(("Client data path cleaned successfully"));
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdEngineConfiguration::ConfigurationElementEndL( 
    const TDesC8& aElement, 
    const TDesC8& aData )
    {
    DLTRACEIN(( "Element: %S, data: %S", &aElement, &aData ));
    
    if ( aElement == NcdEngineConfiguration::KAccessPointSettings() ) 
        {
        iParseApDetails = EFalse;
        }
    else if ( iParseApDetails && aElement == NcdEngineConfiguration::KApDetail() )
        {
        DASSERT( iApDetailId && iApDetailValue );
        CNcdKeyValuePair* detail = CNcdKeyValuePair::NewLC( *iApDetailId, *iApDetailValue );
        iApDetails.AppendL( detail );
        CleanupStack::Pop( detail );
        delete iApDetailId;
        iApDetailId = NULL;
        delete iApDetailValue;
        iApDetailValue = NULL;
        }
    else if ( !aData.Length() )
        {
        DLTRACEOUT(("No data."));
        return;
        }        
    else if ( aElement == NcdEngineConfiguration::KType() ) 
        {        
        NcdProtocolUtils::AssignDesL( iType, aData );
        }
    else if ( aElement == NcdEngineConfiguration::KVersion() ) 
        {
        NcdProtocolUtils::AssignDesL( iVersion, aData );
        }
    else if ( aElement == NcdEngineConfiguration::KProvisioning() ) 
        {
        NcdProtocolUtils::AssignDesL( iProvisioning, aData );
        }
    else 
        {
        DLINFO(("Unknown element in the engine configuration file"));
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdEngineConfiguration::ConfigurationAttributeL( 
    const TDesC8& aElement, 
    const TDesC8& aAttribute, 
    const TDesC8& aValue )
    {
    DLTRACEIN(( "Element: %S, attribute: %S, value: %S", &aElement, &aAttribute, &aValue ));
    
    if ( aElement == NcdEngineConfiguration::KNetwork() && !iApIdFound ) 
        {
        if ( aAttribute == NcdEngineConfiguration::KMcc() ) 
            {
            NcdProtocolUtils::AssignDesL( iMcc, aValue );
            }
        else if ( aAttribute == NcdEngineConfiguration::KMnc() ) 
            {
            NcdProtocolUtils::AssignDesL( iMnc, aValue );
            }
        else if ( aAttribute == NcdEngineConfiguration::KFixedAp() ) 
            {
            NcdProtocolUtils::AssignDesL( iApId, aValue );
            }
        if ( iMcc && iMnc && iApId ) 
            {
            // All the attributes read, check whether the MCC/MNC match the current ones.
            iDeviceService.HomeNetworkInfoL( iHomeMcc, iHomeMnc );
            if ( iHomeMcc == *iMcc && iHomeMnc == *iMnc ) 
                {
                // Now we know the AP id we must use.
                iApIdFound = ETrue;
                NcdProtocolUtils::AssignDesL( iCorrectApId, *iApId );
                DLINFO((("correct ap id found: %S"), iCorrectApId ));
                }
            delete iMcc;
            iMcc = NULL;
            delete iMnc;
            iMnc = NULL;
            delete iApId;
            iApId = NULL;  
            }
        }                
    
    if ( aElement == NcdEngineConfiguration::KAccessPointSettings() ) 
        {
        if ( aAttribute == NcdEngineConfiguration::KApId() ) 
            {
            if ( iApIdFound && *iCorrectApId == aValue ) 
                {
                // This is the correct AP.
                iParseApDetails = ETrue;
                }
            }
        else 
            {
            DLINFO(("Unknown attribute in the engine configuration file"));
            }
        }
        
    if ( iParseApDetails && aElement == NcdEngineConfiguration::KApDetail() ) 
        {
        if ( aAttribute == NcdEngineConfiguration::KApDetailId() ) 
            {            
            NcdProtocolUtils::AssignDesL( iApDetailId, aValue );
            }
        else if ( aAttribute == NcdEngineConfiguration::KApDetailValue() ) 
            {
            NcdProtocolUtils::AssignDesL( iApDetailValue, aValue );
            }
        }
    }
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdEngineConfiguration::ConfigurationError( TInt /*aError*/ )
    {
    DLERROR(("Some error occurred during parsing"));
    }
    

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CNcdEngineConfiguration::CNcdEngineConfiguration( MNcdDeviceService& aDeviceService )
    : iParseApDetails( EFalse ), iApIdFound( EFalse ), iDeviceService( aDeviceService )
    {
    }
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CNcdEngineConfiguration::ConstructL()
    {
    DLTRACEIN((""));
    iType = KEngineDefaultType().AllocL();
    iVersion = KEngineDefaultVersion().AllocL();
    iProvisioning = KNullDesC().AllocL();
    iUid = CleanUidName( TUid::Uid( KCatalogsServerUid ) ).AllocL();
    iHomeMcc.CreateL( MNcdDeviceService::KMccLength );
    iHomeMnc.CreateL( MNcdDeviceService::KMncLength );
    
    TFileName engineExe( RProcess().FileName() );
    TParsePtrC parseDrive( engineExe );
    iInstallationDrive = parseDrive.Drive();
        
    // Determine the drive used for temp and data
    iDataDrive = TDriveUnit( DetermineDataDriveL() );    
       
    DLTRACEOUT(( _L("Install drive: %S"), &iInstallationDrive ));
    }


// ---------------------------------------------------------------------------
// Determines the drive where data files are stored (temporarily)
// ---------------------------------------------------------------------------
//
TDriveNumber CNcdEngineConfiguration::DetermineDataDriveL() const
    {
    DLTRACEIN((""));
    TInt64 freeOnE = 0;
    TInt64 freeOnC = 0;
        
    TDriveNumber drive = EDriveC;
    TRAPD( err, freeOnE = FreeDiskSpaceL( CNcdProviderUtils::FileSession(),
        EDriveE ) );
    
    // Drive E exists and has free space
    if ( freeOnE && err == KErrNone ) 
        {
        // No trap because if this fails then we're in trouble already
        freeOnC = FreeDiskSpaceL( CNcdProviderUtils::FileSession(),
            EDriveC );
        if ( freeOnE > freeOnC ) 
            {
            DLINFO(("Using E: as temp drive"));
            drive = EDriveE;
            }
        }
    return drive;
    }