/*
* Copyright (c) 2008 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:  
 *
*/

// INCLUDE FILES

#include <ecom/implementationproxy.h>
#include <sacls.h>

#include "chfactorysettingsplugin.h"
#include "chfactorysettingsparser.h"
#include "chfactorysettingsinstallnotifier.h"
#include "cpdebug.h"
#include "chdbstatehandler.h"

// LOCAL CONSTANTS AND MACROS
const TInt KADatFactorySettingsServerPluginUid( 0x102830EF);
// Dynamically loaded data storage handler

const TInt KDefaultGranularity = 5;

_LIT( KDirFSNew, "import\\fs\\" );
_LIT( KParsedDir, "parsed\\fs\\" );
_LIT( KParsed, "parsed\\" );
_LIT( KFs, "fs\\" );

_LIT( KDriveC, "C:" );
_LIT( KColen, ":" );

// Map the interface UIDs to implementation factory functions
const TImplementationProxy ImplementationTable[] =
    {
        {
            {
            KADatFactorySettingsServerPluginUid
            }, ( TProxyNewLPtr )CCHFactorySettings::NewL
        }
    };

// ----------------------------------------------------------------------------
// ImplementationGroupProxy
// Exported proxy for instantiation method resolution
// ----------------------------------------------------------------------------
//
EXPORT_C const TImplementationProxy*
ImplementationGroupProxy( TInt& aTableCount )
    {
    aTableCount = sizeof( ImplementationTable ) /
    sizeof( TImplementationProxy );
    return ImplementationTable;
    }

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

// -----------------------------------------------------------------------------
// CCHFactorySettings::CCHFactorySettings
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CCHFactorySettings::CCHFactorySettings()
    {

    }

// -----------------------------------------------------------------------------
// CCHFactorySettings::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CCHFactorySettings::ConstructL( MLiwInterface* aInterface )
    {
    CP_DEBUG(_L8("CCHFactorySettings::ConstructL" ));
    iCPSInterface = aInterface;
    iFileNewList = new (ELeave) CDesCArrayFlat(KDefaultGranularity);
    User::LeaveIfError( iFs.Connect( ) );
    iInstallNotifier = CCHFactorySettingsInstallNotifier::NewL( this,
        KUidSystemCategory, KSAUidSoftwareInstallKeyValue );

    iParser = CCHFactorySettingsParser::NewL( iCPSInterface );

    iFileMan = CFileMan::NewL( iFs );
    iFilePath.CreateL( KMaxPath );

    iFs.CreatePrivatePath( EDriveC );
    User::LeaveIfError( iFs.PrivatePath( iFilePath ) );

    //create "parsed" directory if it doesn't exist yet;
    RBuf filePath;
    filePath.CreateL( KMaxPath );
    filePath.Append( KDriveC );
    filePath.Append( iFilePath );
    filePath.Append( KParsed );
    iFs.MkDir( filePath );
    filePath.Append( KFs );
    iFs.MkDir( filePath );
    filePath.Close( );
    iDBStateHandler = CCHDbStateHandler::NewL( this );
    }

// -----------------------------------------------------------------------------
// CCHFactorySettings::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCHFactorySettings* CCHFactorySettings::NewL( MLiwInterface* aInterface )
    {
    CCHFactorySettings* self = NewLC( aInterface );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CCHFactorySettings::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCHFactorySettings* CCHFactorySettings::NewLC( MLiwInterface* aInterface )
    {
    CCHFactorySettings* self = new( ELeave ) CCHFactorySettings();
    CleanupStack::PushL( self );
    self->ConstructL( aInterface );
    return self;
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CCHFactorySettings::~CCHFactorySettings()
    {
    delete iFileNewList;
    delete iInstallNotifier;
    delete iFileMan;
    delete iParser;
    iFs.Close( );
    iFilePath.Close( );
    delete iDBStateHandler;
    }

// ----------------------------------------------------------------------------
// CCHFactorySettings::UpdateL
// 
// ----------------------------------------------------------------------------
//	
void CCHFactorySettings::UpdateL()
    {
    CP_DEBUG(_L8("CCHFactorySettings::UpdateL" ));
    CheckDrivesL( ); // fill in list with file names from all drives
    AddNewL( ); // if any of them isn't added to db then add
    UnInstallL( ); // if any of files from any drive was removed remove data 
    // from DB	 

    }

// ----------------------------------------------------------------------------
// CCHFactorySettings::AddNewL
// Add new entries after sis intallation.
// ----------------------------------------------------------------------------
//    
void CCHFactorySettings::AddNewL()
    {
    CP_DEBUG(_L8("CCHFactorySettings::AddNewL" ));
    CDir* fileListInstalled= NULL;
    RBuf filePath;
    filePath.CreateL( KMaxPath );
    CleanupClosePushL( filePath );
    filePath.Append( KDriveC );
    filePath.Append( iFilePath );
    filePath.Append( KParsedDir );
    iFs.GetDir( filePath, KEntryAttMaskSupported, ESortByName,
        fileListInstalled );
    CleanupStack::PushL( fileListInstalled );

    for ( TInt i(0); i<iFileNewList->Count( ); i++ )
        {
        TBool parse(ETrue);
        TPtrC fileNewName = 
            (*iFileNewList)[i].Mid( (*iFileNewList)[i].LocateReverse( '\\' ) + 1 );
        TInt count = fileListInstalled->Count( );
        for ( TInt j(0); j< count; j++ )
            {
            TPtrC existingFile = (*fileListInstalled)[j].iName;
            if ( fileNewName.Compare( existingFile ) )
                {
                parse = ETrue;
                }
            else
                {
                parse = EFalse;
                break;
                }
            }
        if ( parse )
            {
            //file wasn't found in afterinstallation dir 
            //so should be copied and entries install  
            TBool fileOpened(ETrue);
            iFs.IsFileOpen( (*iFileNewList)[i], fileOpened );

            if ( !fileOpened )
                {
                TInt error = iParser->RestoreL( (*iFileNewList)[i], EFalse );
                if ( error == KErrNone )
                    {
                    iFileMan->Copy( (*iFileNewList)[i], filePath );
                    }
                }

            }
        }
    CleanupStack::PopAndDestroy( fileListInstalled );
    CleanupStack::PopAndDestroy( &filePath );
    }

// ----------------------------------------------------------------------------
// CCHFactorySettings::UnInstallL
// Removes entries after uninstallation.
// ----------------------------------------------------------------------------
//  
void CCHFactorySettings::UnInstallL()
    {
    CP_DEBUG(_L8("CCHFactorySettings::UnInstallL" ));
    TBool found(EFalse);
    CDir* fileListInstalled= NULL;
    RBuf filePath;
    filePath.CreateL( KMaxPath );
    CleanupClosePushL( filePath );
    filePath.Append( KDriveC );
    filePath.Append( iFilePath );
    filePath.Append( KParsedDir );
    iFs.GetDir( filePath, KEntryAttMaskSupported, ESortByName,
        fileListInstalled );
    CleanupStack::PushL( fileListInstalled );

    for ( TInt i(0); i<fileListInstalled->Count( ); i++ )
        {
        TPtrC fileInstalledName = (*fileListInstalled)[i].iName;
        found = EFalse;
        for ( TInt j(0); j<iFileNewList->Count( ); j++ )
            {
            TPtrC fileNewPath = (*iFileNewList)[j];
            TPtrC fileNewName = 
                (*iFileNewList)[j].Mid( (*iFileNewList)[j].LocateReverse( '\\' ) + 1 );
            if ( fileInstalledName.Compare( fileNewName )==0 )
                {
                if ( !(*fileListInstalled)[i].IsDir( ) )
                    {
                    found = ETrue;
                    break;
                    }
                }
            }
        if ( !found ) //this file should be removed also entries from database 
            {
            filePath.Zero( );
            filePath.Append( KDriveC );
            filePath.Append( iFilePath );
            filePath.Append( KParsedDir );
            filePath.Append( fileInstalledName );

            iParser->RestoreL( filePath, ETrue );
            iFileMan->Delete( filePath );
            }
        }
    CleanupStack::PopAndDestroy( fileListInstalled );
    CleanupStack::PopAndDestroy( &filePath );
    }

// ----------------------------------------------------------------------------
// CCHFactorySettings::CheckDrivesL
// 
// ----------------------------------------------------------------------------
//	
void CCHFactorySettings::CheckDrivesL()
    {
    CP_DEBUG(_L8("CCHFactorySettings::CheckDrivesL" ));
    iFileNewList->Reset( );
    TDriveList driveList;
    TChar driveLetter;
    User::LeaveIfError( iFs.DriveList( driveList ) );
    for ( TInt driveNumber=EDriveA; driveNumber <= EDriveZ; driveNumber++ )
        {
        if ( driveList[driveNumber] )
            {
            User::LeaveIfError( iFs.DriveToChar( driveNumber, driveLetter ) );
            RBuf filePath;
            filePath.CreateL( KMaxPath );
            CleanupClosePushL( filePath );
            filePath.Append( driveLetter );
            filePath.Append( KColen );
            filePath.Append( iFilePath );
            filePath.Append( KDirFSNew );
            CDir* fileList;
            iFs.GetDir( filePath, KEntryAttMaskSupported, ESortByName,
                fileList );
            CleanupStack::PopAndDestroy( &filePath );
            if ( fileList )
                {
                CleanupStack::PushL( fileList );
                for ( TInt i(0); i<fileList->Count( ); i++ )
                    {
                    RBuf fullFileName;
                    fullFileName.CreateL( KMaxPath );
                    CleanupClosePushL( fullFileName );
                    fullFileName.Append( driveLetter );
                    fullFileName.Append( KColen );
                    fullFileName.Append( iFilePath );
                    fullFileName.Append( KDirFSNew ) ;
                    fullFileName.Append( (*fileList)[i].iName );
                    if ( !(*fileList)[i].IsDir( ) )
                        {
                        //check if already exist
                        iFileNewList->AppendL( fullFileName );
                        }
                    CleanupStack::PopAndDestroy( &fullFileName );
                    }
                CleanupStack::PopAndDestroy( fileList );
                }
            }
        }
    }

// end of file