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




#include <ncdpurchasedetails.h>
#include <ncdprovider.h>
#include <ncdnode.h>
#include <ncdnodeinstall.h>
#include <ncdnodedownload.h>

#include "iaupdatehistoryitemimpl.h"
#include "iaupdatecontentoperationmanager.h"


CIAUpdateHistoryItem* CIAUpdateHistoryItem::NewL( MNcdPurchaseDetails* aDetails,
                                                  MNcdProvider& aProvider )
    {
    CIAUpdateHistoryItem* self = 
        CIAUpdateHistoryItem::NewLC( aDetails, aProvider );
    CleanupStack::Pop( self );
    return self;
    }


CIAUpdateHistoryItem* CIAUpdateHistoryItem::NewLC( MNcdPurchaseDetails* aDetails,
                                                   MNcdProvider& aProvider )
    {    
    CIAUpdateHistoryItem* self = 
        new( ELeave ) CIAUpdateHistoryItem( aProvider );
    CleanupStack::PushL( self );
    self->ConstructL( aDetails );
    return self;
    }


CIAUpdateHistoryItem::CIAUpdateHistoryItem( MNcdProvider& aProvider )
: CBase(),
  iProvider( aProvider )
    {
    
    }
 
    
void CIAUpdateHistoryItem::ConstructL( MNcdPurchaseDetails* aDetails )
    {
    if ( !aDetails )
        {
        User::Leave( KErrArgument );
        }

    // The details is set here instead of in the constructor, because now
    // the details object ownership can be safely taken. If the ownership would be
    // transferred in constructor, a memory leak could happen if new( ELeave )
    // function leaves.
    iDetails = aDetails;    
    }
 
    
CIAUpdateHistoryItem::~CIAUpdateHistoryItem()
    {
    delete iDetails;
    }


MNcdPurchaseDetails& CIAUpdateHistoryItem::Details() const
    {
    return *iDetails;
    }


MNcdProvider& CIAUpdateHistoryItem::Provider() const
    {
    return iProvider;
    }


const TDesC& CIAUpdateHistoryItem::Name() const
    {
    return Details().ItemName();
    }
    
const TDesC& CIAUpdateHistoryItem::Version() const
    {
    return Details().Version();
    }

TTime CIAUpdateHistoryItem::LastOperationTime() const
    {
    return Details().LastOperationTime();
    }


TInt CIAUpdateHistoryItem::LastOperationErrorCode() const
    {
    // Make sure that error code does not contain possible
    // base error code value.
    return 
        CIAUpdateContentOperationManager::CheckErrorCode( 
            Details().LastOperationErrorCode() );
    }


CIAUpdateHistoryItem::TIAHistoryItemState CIAUpdateHistoryItem::StateL() const
    {
    // Set the preliminary state for the node.
    // Purchase state is the initial state of the purchase details.
    TIAHistoryItemState state( EPurchased );

    // Notice, when node content has been installed, its purchase details state
    // will remain as EStateInstalled even if the content is uninstalled.
    // Also notice, that an error may occur during an operation or an error code 
    // may be set by NCD API user because operations have been cancelled. 
    // Thus, purchase details can not be used here for all the cases because 
    // in some situations the update item content may have been uninstalled 
    // and after that the operation can be cancelled. After that, purhcase details 
    // still give EStateInstalled, but the error code may be set by NCD API user. So, 
    // use purchase details for error code but use the node interfaces to get the 
    // correct state information.
    

    // First check if the node is a service pack because then we need to 
    // handle it differently.
    CIAUpdateContentOperationManager::TContentOperationType operationType(
        CIAUpdateContentOperationManager::ServicePackOperationType( Details() ) );
    if ( operationType != CIAUpdateContentOperationManager::ENoContentOperation )
        {
        // Because we come here, it means that the node is a service pack.
        // Now check what was the latest operation.
        switch ( operationType )
            {
            case CIAUpdateContentOperationManager::EPurchaseOperation:
                state = EPurchased;
                break;

            case CIAUpdateContentOperationManager::EDownloadOperation:
                if ( LastOperationErrorCode() == KErrNone )
                    {
                    // Because error code describe success in operation.
                    state = EDownloaded;                    
                    }
                else
                    {
                    // Error code says that download has not been success.
                    // So, only purchase operation has been fully done.
                    state = EPurchased;
                    }
                break;

            case CIAUpdateContentOperationManager::EInstallOperation:
                if ( LastOperationErrorCode() == KErrNone )
                    {
                    // Because error code describe success in operation.
                    state = EInstalled;                    
                    }
                else
                    {
                    // Error code says that install has not been success.
                    // So, only download operation has been fully done.
                    state = EDownloaded;
                    }
                break;
            
            default:
                User::Leave( KErrNotSupported );
                break;
            }

        return state;
        }


    // Get the node from the provider. The node can be gotten by using the
    // purchase details.
    MNcdNode* node( Provider().NodeL( Details() ) );
    if ( !node )
        {
        // Node should always be found if its purchase details can be found
        // from the purchase history.
        User::Leave( KErrNotFound );
        }
    CleanupReleasePushL( *node );
    
    // First check if the node has already been installed and it is still installed.
    MNcdNodeInstall* install( node->QueryInterfaceLC<MNcdNodeInstall>() );
    if ( install )
        {
        if ( install->IsInstalledL() )
            {
            // Content has already been installed.
            // So, the whole process has been completed.
            // Notice, downloaded files are removed or
            // moved after installation.
            state = EInstalled;                
            }
        CleanupStack::PopAndDestroy( install );
        install = NULL;
        }

    if ( state != EInstalled )
        {
        if ( LastOperationErrorCode() == KErrNone
             && Details().State() == MNcdPurchaseDetails::EStateInstalled )
            {
            // This check is required for the cases where the node has been installed,
            // but it has been uninstalled after that.
            // If error code is KErrNone and purchase details value is EStateInstalled,
            // then the last operation has been an install-operation that was success.
            // Because the content is not in the phone anymore, it must have been 
            // uninstalled. Anyways, the last history information should show
            // installed state.
            state = EInstalled;
            }
        else
            {
            // Node was not installed. So, check if it has been downloaded and it is
            // ready for installing.
            MNcdNodeDownload* download( node->QueryInterfaceLC<MNcdNodeDownload>() );
            if ( download )
                {
                if ( download->IsDownloadedL() )
                    {
                    // Content has not been installed yet, but it has been
                    // downloaded and it is available.
                    state = EDownloaded;
                    }
                CleanupStack::PopAndDestroy( download );
                download = NULL; 
                }            
            }
        }
        
    CleanupStack::PopAndDestroy( node );
    node = NULL;
        
    return state;
    }