/*

* 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 <s32mem.h>

#include <s32file.h>

#include <sysutil.h>

#include "senmultiuseridentitymanager.h"

#include "senlogger.h"

#include "SenXmlUtils.h"

namespace

    {

    _LIT8(KUser, "User");

    _LIT8(KUsers, "Users");

    _LIT8(KUserName, "username");

    _LIT8(KPIN, "PIN");

    _LIT8(KActive, "active");

    _LIT8(KTrue, "1");

    _LIT8(KFalse, "0");

    _LIT8(KUsersStart, "<Users>");

    _LIT8(KUsersEnd, "</Users>");

    _LIT8(KUserStartFmt, "<User username=\"%S\" PIN=\"%S\" active=\"%d\">");

    _LIT8(KUserEnd, "</User>");

    const TInt KFLATBUF_SIZE = 128;

    const TInt KActiveValueSize = 1;

    const TInt KStateParsingIdentity = 100;

    }

EXPORT_C CSenMultiUserIdentityManager* CSenMultiUserIdentityManager::NewL(

                                            MSenCoreServiceManager& aManager)

    {

    CSenMultiUserIdentityManager* pNew = NewLC(aManager);

    CleanupStack::Pop();

    return(pNew) ;

    }

EXPORT_C CSenMultiUserIdentityManager* CSenMultiUserIdentityManager::NewLC(

                                            MSenCoreServiceManager& aManager)

    {

    CSenMultiUserIdentityManager* pNew =

                        new (ELeave) CSenMultiUserIdentityManager(aManager);

    CleanupStack::PushL(pNew);

    pNew->ConstructL();

    return pNew;

    }

CSenMultiUserIdentityManager::CSenMultiUserIdentityManager(

                                            MSenCoreServiceManager& aManager)

    : CSenBaseIdentityManager(aManager)

    {

    }

EXPORT_C CSenMultiUserIdentityManager::~CSenMultiUserIdentityManager()

    {

    iUsers.ResetAndDestroy();

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenMultiUserIdentityManager::~CSenMultiUserIdentityManager");        

    }

void CSenMultiUserIdentityManager::ConstructL()

    {

    CSenBaseIdentityManager::ConstructL();

    //db was empty, take default one from Base class(loaded during Base::Contructl)

    if (!iActiveIdentity)

        {

        iActiveIdentity = iIdentity;

        iActiveUser = CSenUser::NewL(KNullDesC8, KNullDesC8, ETrue);    

        iActiveUser->Identites().Append(iActiveIdentity);

        iUsers.Append(iActiveUser);

        }

    else

        {

        //parsing from CSenBaseIdentityManager::ConstructL()

        //  caused, that iActiveIdentity is already set (because has been set by below "StartElement" method).

        //  So, orginal iIdentity should be replaced by iActiveIdentity (used by UpdateTouch functionality)

        delete iIdentity;

        iIdentity = NULL;

        iIdentity = iActiveIdentity;

        };

    }

void CSenMultiUserIdentityManager::StartElementL(

                                          const TDesC8& /*aNsUri*/,

                                          const TDesC8& aLocalName,

                                          const TDesC8& /*aQName*/,

                                          const RAttributeArray& aAttributes

                                          )

    {

    switch (iState)

        {

        case KStateIgnore:

            {

            if (aLocalName == KUser)

                {

                TPtrC8 userName = SenXmlUtils::AttrValue(aAttributes, KUserName);

                TPtrC8 pin = SenXmlUtils::AttrValue(aAttributes, KPIN);

                TPtrC8 active = SenXmlUtils::AttrValue(aAttributes, KActive);

                if (active == KTrue)

                    {

                    iParsedUser = CSenUser::NewL(userName, pin, ETrue);    

                    }

                else

                    {

                    iParsedUser = CSenUser::NewL(userName, pin);

                    }

                if (active == KTrue)

                    {

                    //2nd time active user?? within db

                    __ASSERT_ALWAYS(!iActiveUser, User::Panic(KSenUser, KErrAlreadyExists));

                    iActiveUser = iParsedUser;

                    }

                iUsers.Append(iParsedUser);

                iState = KStateParsingIdentity;

                }

            }

            break;

        case KStateParsingIdentity:

            {

            if (aLocalName ==  KIdentityElementLocalName)

                {

                CSenBaseIdentity* identity = CSenBaseIdentity::NewLC(ipDeviceID->Des());

                identity->SetAttributesL(aAttributes);

                identity->SetReader(*Reader());

                DelegateParsingL(*identity);

                __ASSERT_ALWAYS(iParsedUser, User::Panic(KSenUser, KErrAlreadyExists));

                iParsedUser->Identites().Append(identity);

                //current parsed user is active

                if (iParsedUser == iActiveUser)

                    {

                    iActiveIdentity = identity;

                    }

                CleanupStack::Pop(identity);

                }

            }

            break;

        default:

            break;

        }

    }

void CSenMultiUserIdentityManager::EndElementL(

    const TDesC8& /*aNsUri*/,

    const TDesC8& aLocalName,

    const TDesC8& /*aQName*/)

    {

    switch (iState)

        {

        case KStateIgnore:

            {

            if (aLocalName ==  KUsers)//end parsing

                {

                if (iUsers.Count() == 1)

                    {

                    CSenUser* user = iUsers[0];

                    iActiveUser = user;

                    iActiveIdentity = iActiveUser->Identites()[0];

                    }

                }

            break;

            }

        case KStateParsingIdentity:

            {

            if (aLocalName ==  KUser)

                {

                iState = KStateIgnore;    

                }

            }

            break;

        }

    }

MSenIdentity& CSenMultiUserIdentityManager::IdentityL()

    {

    return (MSenIdentity&)*iActiveIdentity;

    }

TInt CSenMultiUserIdentityManager::UserNameL(HBufC8*& aUserName)

    {

    delete aUserName;

    aUserName = NULL;

    aUserName = iActiveUser->UserName().AllocL();

    return KErrNone;

    }

TInt CSenMultiUserIdentityManager::WriteConfigurationToL( const TDesC& aFile )

    {

    // First, collect everything into MEMORY

    CBufFlat *pBuf = CBufFlat::NewL(KFLATBUF_SIZE);

    CleanupStack::PushL(pBuf);

    RBufWriteStream bufWs(*pBuf);

    CleanupClosePushL(bufWs);

    bufWs.WriteL(KUsersStart);

//############# main loop #########

    TInt count = iUsers.Count();

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

        {

        RBuf8 userTag;

        CSenUser* user = iUsers[i];

        userTag.CreateL(KUserStartFmt().Length() + 

                     user->PIN().Length() + 

                     user->UserName().Length() + 

                     KActiveValueSize //1

                     );

        if (user->Active())

            {

            userTag.Format(KUserStartFmt, &(user->UserName()),  &(user->PIN()), KTrue); 

            }

        else

            {

            userTag.Format(KUserStartFmt, &(user->UserName()),  &(user->PIN()), KFalse);

            }

        bufWs.WriteL(userTag);

        TInt count2 = iUsers[i]->Identites().Count();

        for (TInt j=0; j<count2; j++)

            {

            CSenBaseIdentity* identity = iUsers[i]->Identites()[j];

            identity->WriteAsXMLToL(bufWs);

            }

        bufWs.WriteL(KUserEnd);

        userTag.Close();

        }

//#############

    bufWs.WriteL(KUsersEnd);

    TPtrC8 p8 = pBuf->Ptr(0);

    CleanupStack::PopAndDestroy(1); // bufWs

    // Everything in MEMORY ok, prepare to write into file

    RFs fss;

    User::LeaveIfError(fss.Connect());

    CleanupClosePushL(fss);

    RFileWriteStream fileOutStream;

    CleanupClosePushL(fileOutStream);

    if(!SysUtil::FFSSpaceBelowCriticalLevelL(&fss, p8.Length()) )

        {

        // note, this will zero-length the file(!)

        // it is better to require that 2xfilesize is available and not to

        // dangerously zero the old file and find out

        // that there is no space left..

        //Data caging 2 implementation

#if defined( EKA2 ) || defined( RD_SECURE_PRIV_DATA )

        TBuf<KMaxPath> file;

        fss.CreatePrivatePath(EDriveC);

        fss.PrivatePath(file);

        file.Append(aFile);

        fileOutStream.Replace(fss, file, EFileWrite);

#else

        fileOutStream.Replace(fss, aFile, EFileWrite);

#endif

        // finally write the UTF-8 into the file. 

        fileOutStream.WriteL(p8);

        }

    CleanupStack::PopAndDestroy(3);

    return KErrNone;

    }

// End of file