/*
* 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: A class that provides logon and logoff functionality.
*
*/


#include <unifiedkeystore.h>
#include <mctauthobject.h>

#include "logonservices.h"
#include "pkidefs.h"
#include "pkiserviceassert.h"
#include "pkiserviceconstants.h"

CLogonServices* CLogonServices::NewL(CUnifiedKeyStore& aUnifiedKeyStore)
    {
    CLogonServices* self = new (ELeave) CLogonServices(aUnifiedKeyStore);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    
    return self;
    }


CLogonServices::CLogonServices(CUnifiedKeyStore& aUnifiedKeyStore)
:CActive(EPriorityStandard), iUnifiedKeyStore(aUnifiedKeyStore)
    {
    CActiveScheduler::Add(this);
    }


void CLogonServices::ConstructL()
    {
    }


CLogonServices::~CLogonServices()
    {
    Cancel();
    }


void CLogonServices::Logon(TRequestStatus& aClientStatus)
    {
    PKISERVICE_ASSERT(iState == ELogonServiceIdle);    
    iState = ELogonServiceListingKeys;
    
    iClientStatus = &aClientStatus;
    *iClientStatus = KRequestPending;
    
    if (iAuthenticationObject == NULL)
        {        
        //First find the User key store
        TInt keyStoreCount = iUnifiedKeyStore.KeyStoreManagerCount(); 
        TInt i = 0;
        for (i = 0; i < keyStoreCount; ++i)
            {
            MCTKeyStoreManager& keyStore = iUnifiedKeyStore.KeyStoreManager(i);        
            if (keyStore.Token().TokenType().Type().iUid == STORETYPE_USER_KEY_ID)        
                {
                iUserKeyStore = &keyStore;
                TCTKeyAttributeFilter filter;
                iUserKeyStore->List(iKeysList, filter, iStatus);
                SetActive();
                break;
                }
            }

        if (i == keyStoreCount)
            {
            iStatus = KRequestPending;
            SetActive();
            
            TRequestStatus* ownStatus = &iStatus;
            User::RequestComplete(ownStatus, KPKIErrNotSupported);
            }               
        }
    else
        {
        //Logon already done
        iState = ELogonServiceAlreadyLoggedIn;
        
        iStatus = KRequestPending;
        SetActive();
        
        TRequestStatus* ownStatus = &iStatus;
        User::RequestComplete(ownStatus, KErrNone);        
        }
    }


void CLogonServices::Logoff(TRequestStatus& aClientStatus)
    {
    PKISERVICE_ASSERT(iState == ELogonServiceIdle);    
    iState = ELogonServiceClosingAuthentication;
    
    iClientStatus = &aClientStatus;
    *iClientStatus = KRequestPending;
    
    if (iAuthenticationObject != NULL)
        {
        iAuthenticationObject->Close(iStatus);
        SetActive();
        }
    else    
        {
        iStatus = KRequestPending;
        SetActive();
        
        TRequestStatus* ownStatus = &iStatus;
        User::RequestComplete(ownStatus, KErrNone);
        }    
    }
    

void CLogonServices::SetAuthenticationObject(MCTAuthenticationObject* aAuthenticationObject)
    {
    if (iAuthenticationObject == NULL)
        {
        iAuthenticationObject = aAuthenticationObject;
        }
    }


void CLogonServices::ChangePassword(TRequestStatus& aClientStatus)
    {
    PKISERVICE_ASSERT(iState == ELogonServiceIdle);    
    PKISERVICE_ASSERT(LogonCompleted()); 
    
    iState = ELogonServiceChangingPassword;
    iClientStatus = &aClientStatus;
    *iClientStatus = KRequestPending;
    
    iAuthenticationObject->ChangeReferenceData(iStatus);
    SetActive();           
    }
    

void CLogonServices::RunL()
    {
    if (iStatus.Int() == KErrNone)
        {
        switch(iState)
            {
            case ELogonServiceAlreadyLoggedIn:
                iState = ELogonServiceIdle;
                User::RequestComplete(iClientStatus, KErrNone);                
                break;
            case ELogonServiceListingKeys:
                iState = ELogonServiceIdle;
                if (iKeysList.Count() > 0)
                    {
                    iState = ELogonServiceOpeningAuthentication;  
                    
                    CCTKeyInfo* keyInfo = iKeysList[0];
                    iAuthenticationObject = keyInfo->Protector();
                    iAuthenticationObject->Open(iStatus);
                    SetActive();                    
                    }
                else
                    {
                    Cleanup();
                    User::RequestComplete(iClientStatus, KPKIErrKeyStoreEmpty);                
                    }
                break;
            case ELogonServiceOpeningAuthentication:
                iState = ELogonServiceIdle;                
                Cleanup();
                User::RequestComplete(iClientStatus, KErrNone);                                
                break;
            case ELogonServiceClosingAuthentication:                                
                iState = ELogonServiceIdle; 
                iAuthenticationObject = NULL;
                User::RequestComplete(iClientStatus, KErrNone);                
                break;
            case ELogonServiceChangingPassword:
                iState = ELogonServiceIdle; 
                User::RequestComplete(iClientStatus, KErrNone);
                break;                
            default:
                PKISERVICE_INVARIANT();
                break;                
            }
        
        }
    else
        {
        Cleanup();
        iState = ELogonServiceIdle;
        User::RequestComplete(iClientStatus, iStatus.Int());
        }
    }


void CLogonServices::DoCancel()
    {
    switch(iState)
        {
        case ELogonServiceListingKeys:
            iUserKeyStore->CancelList();
            break;
        case ELogonServiceOpeningAuthentication:
            iAuthenticationObject->CancelOpen();
            iAuthenticationObject = NULL;
            break;
        case ELogonServiceClosingAuthentication:            
            if (iAuthenticationObject != NULL)
                {
                iAuthenticationObject->CancelClose();
                iAuthenticationObject = NULL;
                }
            //else do nothing                
            break;
        case ELogonServiceChangingPassword:
            iAuthenticationObject->CancelChangeReferenceData();
            break;
        default:
            PKISERVICE_INVARIANT();
            break;                
        }
        
    Cleanup();
    iState = ELogonServiceIdle;          
    User::RequestComplete(iClientStatus, KErrCancel);     
    }


void CLogonServices::Cleanup()
    {   
    iKeysList.Close();
    }
    
    
TBool CLogonServices::LogonCompleted() const
    {
    if (iState == ELogonServiceIdle && 
        iAuthenticationObject != NULL)
        {
        return ETrue;
        }
    else
        {
        return EFalse;
        }
    }