/*

* Copyright (c) 2003 - 2005 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:  Application's document class

*

*/

// INCLUDE FILES

#include    <aknnotewrappers.h>

#include    <StringLoader.h>

#include    <aknview.h>

#include 	<gsplugininterface.h>

#include    <gssipsettingspluginrsc.rsg> //GUI Resource

#include    <escapeutils.h>

#include    "gssipmodel.h"

#include    "gssipappshutter.h"

#include    "gssipprofileutil.h"

#include    "gssippluginlogger.h"

// CONSTANTS

_LIT( KOpenParenthesis, "(" );

_LIT( KClosedParenthesis, ")" );

const TInt KMaxDuplicatePostfixLength = 10;

const TInt KSIPGranularity = 5;

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

// -----------------------------------------------------------------------------

// CGSSIPModel::CGSSIPModel

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CGSSIPModel::CGSSIPModel() 

    {

    __GSLOGSTRING("CGSSIPModel::CGSSIPModel" )

    iQuitAfterSave = EFalse;

    }

// -----------------------------------------------------------------------------

// CGSSIPModel::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CGSSIPModel::ConstructL()

    {

    __GSLOGSTRING("CGSSIPModel::ConstructL" )

    }

// -----------------------------------------------------------------------------

// CGSSIPModel::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CGSSIPModel* CGSSIPModel::NewL()

    {

    __GSLOGSTRING("CGSSIPModel::NewL" )

    CGSSIPModel* self = new( ELeave ) CGSSIPModel();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CGSSIPModel::~CGSSIPModel()

    {

    __GSLOGSTRING("CGSSIPModel::~CGSSIPModel" )

    if ( iProfiles )

        {

        iProfiles->ResetAndDestroy();

        delete iProfiles;

        }

    delete iAppShutter;

    delete iEngine;

    }

// -----------------------------------------------------------------------------

// CGSSIPModel::CreateEngineL

// Creates the application engine

// -----------------------------------------------------------------------------

//

void CGSSIPModel::CreateEngineL( CGSPluginInterface* aAppUi )

    {

    __GSLOGSTRING("CGSSIPModel::CreateEngineL Start" )

    iAppUi = aAppUi;

    // Create AppShutter instance.

    iAppShutter = CGSSIPAppShutter::NewL( iAppUi );   

    iEngine = CSIPManagedProfileRegistry::NewL( *this );    

    ReadArrayFromEngineL();

    __GSLOGSTRING("CGSSIPModel::CreateEngineL End" )

    }

// -----------------------------------------------------------------------------

// CGSSIPModel::EditProfileL

// Copies profile's data to iProfileData

// -----------------------------------------------------------------------------

//

TBool CGSSIPModel::EditProfileL( TInt aIndex )

    {    

    __GSLOGSTRING("CGSSIPModel::EditProfileL " )

    __GSLOGSTRING1("CGSSIPModel::EditProfileL aIndex: %d", aIndex)

    TBool moveToNextView = ETrue;

    CSIPManagedProfile* profile = 

        static_cast<CSIPManagedProfile*>( iProfiles->At( aIndex ) );

    if ( iEngine->IsInUseL( *profile ) )

        {

        HBufC* errorTxt = StringLoader::LoadLC( R_QTN_SIP_ERROR_PROFILE_USED );

        CAknErrorNote* note = new ( ELeave ) CAknErrorNote( ETrue );

        note->ExecuteLD( errorTxt->Des() );

        CleanupStack::PopAndDestroy( errorTxt );        

        moveToNextView = EFalse;

        }

    else

        {

        CopyToProfileDataStructL( aIndex );

        }

    return moveToNextView;

    }

// -----------------------------------------------------------------------------

// CGSSIPModel::CreateAndEditProfileL

// Starts editing a new profile that is based on an existing one

// -----------------------------------------------------------------------------

//

void CGSSIPModel::CreateAndEditProfileL( TInt aCopiedIndex )

    {

    __GSLOGSTRING("CGSSIPModel::CreateAndEditProfileL Start" )

    __GSLOGSTRING1("CGSSIPModel::CreateAndEditProfileL aCopiedIndex: %d", aCopiedIndex)

    if ( aCopiedIndex == KUnknownProfileIndex )

        {

        // Create new profile with default values

        FillDataStructWithDefaultValsL();        

        }

    else

        {

        CopyToProfileDataStructL( aCopiedIndex );

        iProfileData.iID = KUnknownProfileIndex;

        }

    CheckDuplicateNameL( iProfileData.iID, 

        iProfileData.iProviderName , ETrue);   

    __GSLOGSTRING("CGSSIPModel::CreateAndEditProfileL End" )

    }

// -----------------------------------------------------------------------------

// CGSSIPModel::ProfileData

// Returns pointer to profile data structure for modifying it directly

// -----------------------------------------------------------------------------

//

TSIPSettingsData* CGSSIPModel::ProfileData()

    {

    __GSLOGSTRING("CGSSIPModel::ProfileData" )

    return &iProfileData;

    }

// -----------------------------------------------------------------------------

// CGSSIPModel::ProfileData

// Returns pointer to the profile array

// -----------------------------------------------------------------------------

//

CArrayPtr<CSIPManagedProfile>* CGSSIPModel::ProfileArray()

    {

    __GSLOGSTRING("CGSSIPModel::ProfileArray" )

    return iProfiles;

    }

// -----------------------------------------------------------------------------

// CGSSIPModel::SaveProfileL

// Saves profile to persistent storage

// -----------------------------------------------------------------------------

//

TBool CGSSIPModel::SaveProfileL()

    {

    __GSLOGSTRING("CGSSIPModel::SaveProfileL" )

    TBool modifications = ETrue;

    TInt err( KErrNone );

    CheckDuplicateNameL( iProfileData.iID, iProfileData.iProviderName );

    if ( iProfileData.iID == KUnknownProfileIndex )

        {

        // Need to create a new profile

        CSIPManagedProfile* profile = 

        	iEngine->CreateL( iProfileData.iServiceProfile );

        CleanupStack::PushL( profile );

        // Copy attributes to the new profile        

        iNewProfile = profile;

        profile = CopyDataToProfileL();        

        // Save the profile to persistent storage                

        TRAP( err, iEngine->SaveL( *profile ) );

        if ( err )

            {

            // When exit is called and we get error code because of same realm

            // with different username, we sohuld exit without saving.

            // Otherwise this method leaves.

            if ( iQuitAfterSave )

                {

                CleanupStack::PopAndDestroy( profile );

                modifications = EFalse;

                }

            else

                {

                User::Leave( err );

                }

            }

        else

            {

            CleanupStack::Pop( profile );

            }

        }

    else

        {

		// check at first if a profile is locked

    	TBool locked( EFalse );

		err = Profile( iProfileData.iID )->GetParameter( KSIPProfileLocked,

	    		locked );

    	if ( locked )

    		{

    		return EFalse;

    		}

        // We can save the modified changes if any

        if ( CheckForModificationsL() )  

            {

            // Check that the profile is not in use

            CSIPManagedProfile* profile = Profile( iProfileData.iID );

            CSIPManagedProfile* clonedProfile = profile->CloneL();

            CleanupStack::PushL( clonedProfile );

            profile = CopyDataToProfileL();

            TRAP( err, iEngine->SaveL( *profile ) );                        

            if ( err )

                {

                // Copy old profile data back to temporary variable

                // If this leaves, then nope can do; there hasn't been enough

                // memory on the first place to do the operations, so there isn't

                // much we can do execpt prevent further memory loss               

                ReplaceProfileL( iProfileData.iID, clonedProfile );

                // When exit is called and we get error code because of same realm

                // with different username, we sohuld exit without saving.

                // Otherwise this method leaves.

                if ( iQuitAfterSave )

                    {

                    modifications = EFalse;

                    }

                else

                    {

                    User::Leave( err );

                    }    

                }

            CleanupStack::PopAndDestroy( clonedProfile );

            }

        else

            {

            // No modifications, not saving for nothing

            modifications = EFalse;

            }

        }

    return modifications;

    }

// -----------------------------------------------------------------------------

// CGSSIPModel::SetDefaultProfileL

// Sets new default profile

// -----------------------------------------------------------------------------

//

void CGSSIPModel::SetDefaultProfileL( TInt aIndex )

    {

    __GSLOGSTRING("CGSSIPModel::SetDefaultProfileL Start" )

    __GSLOGSTRING1("CGSSIPModel::SetDefaultProfileL aIndex: %d", aIndex)

    TBool bDefault = EFalse ;

    TInt err = 

    	iProfiles->At( aIndex )->GetParameter( KSIPDefaultProfile, bDefault );

    User::LeaveIfError( err );

    if ( !bDefault )

        {

        CSIPManagedProfile* profile = 

            static_cast<CSIPManagedProfile*>( iProfiles->At( aIndex ) );

        if ( iEngine->IsInUseL( *profile ) )

            {

            // Can't change the profile, it is in use

            User::Leave( KErrInUse );

            }        

        // Set the profile to be default and save sum' settings

        err= profile->SetParameter( KSIPDefaultProfile, ETrue );

        User::LeaveIfError( err );

        TRAP( err, iEngine->SaveL( *profile ) );

        // If SaveL() leaves profile and the old default profile might be

        // set as defaults; need to read the whole array again..

        if ( err )

            {

            ReadProfileListFromEngineSafeL();                            

            User::Leave( err );

            }        

        }

    __GSLOGSTRING("CGSSIPModel::SetDefaultProfileL End" )

    }

// -----------------------------------------------------------------------------

// CGSSIPModel::DefaultProfileIndex

// Returns index to the default profile

// -----------------------------------------------------------------------------

//

TInt CGSSIPModel::DefaultProfileIndex()

    {     

    __GSLOGSTRING("CGSSIPModel::DefaultProfileIndex " )

    TInt i( 0 );

    TInt index( KUnknownProfileIndex );

    // "Default values" are not values from default profile; instead they

    // are the values that are defined on UI specification

    // Scans through the array and returns the index of the profile

    for ( i = 0; i < iProfiles->Count() && index == KUnknownProfileIndex; i++ )

        {

        TBool defProfile = EFalse;		

    	TInt err = 

    		iProfiles->At( i )->GetParameter( KSIPDefaultProfile, defProfile );        

        if ( err )

            {

            // No luck if leaves

            defProfile = EFalse;

            }

        if ( defProfile )

            {

            index = i;

            }

        }

    __GSLOGSTRING1("CGSSIPModel::DefaultProfileIndex: %d", index) 

    return index;

    }

// -----------------------------------------------------------------------------

// CGSSIPModel::TypeListL

// Returns an array consisting of the typenames

// -----------------------------------------------------------------------------

//

RArray<TSIPProfileTypeInfo>* CGSSIPModel::TypeListL()

    {  

    __GSLOGSTRING("CGSSIPModel::TypeListL" )

    RArray<TSIPProfileTypeInfo>* typeArray = 

        new (ELeave) RArray<TSIPProfileTypeInfo>;

    TCleanupItem clItem( CloseAndDestroy, &typeArray );

    CleanupStack::PushL( clItem );

    // Get the supported profile types

    iEngine->SupportedProfileTypesL( *typeArray );

    CleanupStack::Pop(); //clItem

    return typeArray;

    }

// -----------------------------------------------------------------------------

// CGSSIPModel::DeleteProfileL

// Deletes a profile from permanent storage

// -----------------------------------------------------------------------------

//

void CGSSIPModel::DeleteProfileL( TInt aIndex )

    {

    __GSLOGSTRING("CGSSIPModel::DeleteProfileL Start" )

    __GSLOGSTRING1("CGSSIPModel::DeleteProfileL aIndex: %d", aIndex) 

    CSIPManagedProfile* profile = iProfiles->At( aIndex );    

    if ( iEngine->IsInUseL( *profile ) )

        {

        User::Leave( KErrInUse );

        }

    iEngine->DestroyL( *profile );

    __GSLOGSTRING("CGSSIPModel::DeleteProfileL End" )

    }

// -----------------------------------------------------------------------------

// CGSSIPModel::QuitAfterSave

// Set "Quit after save" flag

// -----------------------------------------------------------------------------

//

void CGSSIPModel::QuitAfterSave()

    {

    __GSLOGSTRING("CGSSIPModel::QuitAfterSave" )

    iQuitAfterSave = ETrue;

    }

// -----------------------------------------------------------------------------

// CGSSIPModel::ErrorInRegistration

// Checks if there has been error in registration

// -----------------------------------------------------------------------------

//

TBool CGSSIPModel::ErrorInRegistration( TInt aIndex )

    {    

    __GSLOGSTRING("CGSSIPModel::ErrorInRegistration" )

    __GSLOGSTRING1("CGSSIPModel::ErrorInRegistration aIndex: %d", aIndex)

    return ( iEngine->LastRegistrationError( 

        *( iProfiles->At( aIndex ) ) ) != KErrNone );

    }

// -----------------------------------------------------------------------------

// CGSSIPModel::ProfileRegistryEventOccurred

// SIP profile event 

// -----------------------------------------------------------------------------

//

void CGSSIPModel::ProfileRegistryEventOccurred( 

    TUint32 aSIPProfileId, TEvent aEvent )

	{

	__GSLOGSTRING("CGSSIPModel::ProfileRegistryEventOccurred Start" )

    __GSLOGSTRING1("CGSSIPModel::ProfileRegistryEventOccurred aSIPProfileId: %d", aSIPProfileId)  

    __GSLOGSTRING1("CGSSIPModel::ProfileRegistryEventOccurred aEvent: %d", aEvent) 

    switch( aEvent )	

        {

        case EProfileCreated:

			TRAP_IGNORE( ProfileCreatedL( aSIPProfileId ) )

			break;

        case EProfileUpdated:	

            TRAP_IGNORE( ProfileUpdatedL( aSIPProfileId ) )

            break;

        case EProfileRegistered:						

        case EProfileDeregistered:

            ProfileRegistrationStatusChanged( aSIPProfileId );

            break;

        case EProfileDestroyed:

            ProfileDestroyed( aSIPProfileId );

            break;

        default:

            // Do nothing.

            break;

		}

	__GSLOGSTRING("CGSSIPModel::ProfileRegistryEventOccurred End" )

	}

// -----------------------------------------------------------------------------

// CGSSIPModel::ProfileCreatedL

// SIP profile creation event 

// -----------------------------------------------------------------------------

//

void CGSSIPModel::ProfileCreatedL( TUint32 aSIPProfileId )

    {   

    __GSLOGSTRING("CGSSIPModel::ProfileCreatedL Start" )

    __GSLOGSTRING1("CGSSIPModel::ProfileCreatedL aSIPProfileId: %d", aSIPProfileId)

    CSIPManagedProfile* profile = NULL;

    TBool byThisApp = ETrue;

    TUint32 profileId = 0;

    if( iNewProfile )

    	{

    	TInt err = iNewProfile->GetParameter( KSIPProfileId, profileId );

    	if( err )	

    		{

    	    return;

    		}

    	}

    if ( iNewProfile && aSIPProfileId == profileId )

        {

        profile = iNewProfile;

        iNewProfile = NULL;

        }

    else

        {

        // Some other application has created a new profile

        byThisApp = EFalse;

        TRAPD( err, profile = static_cast<CSIPManagedProfile*>( 

                        iEngine->ProfileL( aSIPProfileId ) ) );

        if ( err )

            {

            // Can't fetch the new profile - nothing to do

            return;

            }

        }

    // Inserts the profile to the correct place

    TInt count = iProfiles->Count();

    TInt i( 0 );    

    TBool profileAdded( EFalse );

    TInt err( KErrNone );

    const TDesC8* providerName = NULL;

    err = profile->GetParameter( KSIPProviderName, providerName );

    if( !err )	

    	{

    	const TDesC8* oldProvider = NULL;

    	for ( i = 0; i < count; i++ )

        	{

        	err = iProfiles->At( i )->GetParameter( 

        		KSIPProviderName, oldProvider );

        	//if there is an error it should continue for next . 

        	if ( !err && !profileAdded

        		&& providerName->CompareC( *oldProvider ) < 0 )

            	{

            	TRAP( err, iProfiles->InsertL( i, profile ) );            

            	profileAdded = ETrue;

            	iAddedProfileIndex = i;

	            i = count;