/*
* 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:   ?Description
*
*/




// NCD headers:
// Purchase history contains items
#include <ncdpurchasehistory.h>
// Contains CBase-class headers of the ncd purchase classes.
#include <ncdutils.h>
#include <ncdprovider.h>

#include "iaupdateselfupdaterinitializer.h"
#include "iaupdatenodeimpl.h"
#include "iaupdateselfupdaterinitobserver.h"
#include "iaupdatecontrollerimpl.h"
#include "iaupdateselfupdaterctrl.h"
#include "iaupdaterfilelist.h"
#include "iaupdaterfileinfo.h"
#include "iaupdateridentifier.h"
#include "iaupdatedebug.h"


CIAUpdateSelfUpdaterInitializer* CIAUpdateSelfUpdaterInitializer::NewL(
    CIAUpdateNode& aNode,
    MIAUpdateSelfUpdaterInitObserver& aObserver )
    {
    CIAUpdateSelfUpdaterInitializer* self =
        CIAUpdateSelfUpdaterInitializer::NewLC( aNode, aObserver );
    CleanupStack::Pop( self );
    return self;
    }


CIAUpdateSelfUpdaterInitializer* CIAUpdateSelfUpdaterInitializer::NewLC(
    CIAUpdateNode& aNode,
    MIAUpdateSelfUpdaterInitObserver& aObserver )
    {
    CIAUpdateSelfUpdaterInitializer* self =
        new( ELeave ) CIAUpdateSelfUpdaterInitializer( aNode, aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


CIAUpdateSelfUpdaterInitializer::CIAUpdateSelfUpdaterInitializer( 
    CIAUpdateNode& aNode,
    MIAUpdateSelfUpdaterInitObserver& aObserver )
: CActive( CActive::EPriorityStandard ),
  iNode( aNode ),
  iObserver( aObserver ) 
    {

    }


void CIAUpdateSelfUpdaterInitializer::ConstructL()
    {
    User::LeaveIfError( FileServer().Connect() );
    CActiveScheduler::Add( this );
    }


CIAUpdateSelfUpdaterInitializer::~CIAUpdateSelfUpdaterInitializer()
    {
    Cancel();

    FileServer().Close();

    // Notice, that file list can be also NULL if
    // the ownership has been transferred to else where.
    delete iFileList;
    }
    

void CIAUpdateSelfUpdaterInitializer::StartL()
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterInitializer::Start() begin");
    
    if ( !IsActive()
         && iState == ENotStarted )
        {
        // Start the active loop, which will
        // set the content files into the file list.
        iState = EInitialize;            
        iStatus = KRequestPending;
        SetActive();
        TRequestStatus* ptrStatus = &iStatus;
        User::RequestComplete( ptrStatus, KErrNone );        
        }
    else
        {
        User::Leave( KErrInUse );
        }

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterInitializer::Start() end");
    }


void CIAUpdateSelfUpdaterInitializer::DoCancel()
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterInitializer::DoCancel() begin");
    
    iState = ENotStarted;

    // The ownership has not been transferred yet.
    // So, delete filelist here.    
    delete iFileList;
    iFileList = NULL;
    
    // Also inform observer that the cancellation happened.
    Observer().SelfUpdateInitComplete( KErrCancel );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterInitializer::DoCancel() end");
    }


void CIAUpdateSelfUpdaterInitializer::RunL()
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterInitializer::RunL() begin");
    
    switch( State() )
        {
        case EInitialize:
            // Initialize things for the self update and set file list info.
            // Create the file list here. If an error occurs below, RunError will
            // delete the file list. If everything goes ok, then ownership is
            // transferred to other object.
            iFileList = CIAUpdaterFileList::NewL();
            SetContentFileListL();
            // Inform observer that setup is complete.
            // The ownership of the file list will be transferred here.
            InitCompleteL();
            break;
                
        default:
            // Unknown state.
            // Let RunError handle this.
            User::Leave( KErrArgument );
            break;
        }

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterInitializer::RunL() end");
    }


TInt CIAUpdateSelfUpdaterInitializer::RunError( TInt aError )
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterInitializer::RunError() begin");
    
    iState = ENotStarted;
    
    // Delete file list because error occurred.
    delete iFileList;
    iFileList = NULL;

    // Inform observer about the error.
    Observer().SelfUpdateInitComplete( aError );

    // We do not continue the operation anymore.

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterInitializer::RunError() end");

    return KErrNone;
    }


const CIAUpdateSelfUpdaterInitializer::TUpdaterState& CIAUpdateSelfUpdaterInitializer::State() const
    {
    return iState;
    }


CIAUpdateNode& CIAUpdateSelfUpdaterInitializer::Node()
    {
    return iNode;
    }


MIAUpdateSelfUpdaterInitObserver& CIAUpdateSelfUpdaterInitializer::Observer()
    {
    return iObserver;
    }


RFs& CIAUpdateSelfUpdaterInitializer::FileServer()
    {
    return iFs;
    }


void CIAUpdateSelfUpdaterInitializer::SetContentFileListL()
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterInitializer::SetContentFileListL() begin");
    
    // The file list will have one common name for all the files if the content
    // is given as a bundle.
    iFileList->SetBundleNameL( Node().Name() );
    iFileList->SetHidden( Node().Hidden() );
    CIAUpdaterIdentifier& identifier( iFileList->Identifier() );
    identifier.SetIdL( Node().MetaId() );
    identifier.SetNamespaceL( Node().MetaNamespace() );
    identifier.SetUid( Node().Uid() );

    MNcdProvider& provider =
        Node().Controller().ProviderL();

    MNcdPurchaseHistory* history( provider.PurchaseHistoryL() );
    CleanupReleasePushL( *history );

    // Create filter. So, we will get
    // all the purchase history items.
    CNcdPurchaseHistoryFilter* filter =
        CNcdPurchaseHistoryFilter::NewLC();

    // Add family uid to the filter
    RArray< TUid > uids;
    CleanupClosePushL( uids );
    uids.AppendL( Node().Controller().FamilyUid() );
    filter->SetClientUids( uids.Array() );
    CleanupStack::PopAndDestroy( &uids );

    // Add other filter values.
    // We only want content information for this node.
    filter->SetNamespaceL( Node().MetaNamespace() );
    filter->SetEntityIdL(  Node().MetaId() );
    
    // Get the ids. So, we can next get all the corresponding
    // details.
    RArray< TUint > ids =
        history->PurchaseIdsL( *filter );
    CleanupStack::PopAndDestroy( filter );
    CleanupClosePushL( ids );
    
    if ( ids.Count() > 0 )
        {
        IAUPDATE_TRACE("[IAUPDATE] Ids found.");
    
        // If there are any details, then the latest should be the first
        // one in the array. So, use that.
        CNcdPurchaseDetails* details( 
            history->PurchaseDetailsL( ids[ 0 ] , EFalse ) );        

        if ( details )
            {
            IAUPDATE_TRACE("[IAUPDATE] Details found.");
        
            // We got the newest details. Get its file information.
            CleanupStack::PushL( details );

            const MDesCArray& files = details->DownloadedFiles();        
            TInt count( files.MdcaCount() );
            IAUPDATE_TRACE_1("[IAUPDATE] Files count: %d", count);    
            for( TInt i = 0; i < count; ++i )
                {
                CIAUpdaterFileInfo* info( CIAUpdaterFileInfo::NewLC() );
                info->SetFilePathL( files.MdcaPoint( i ) );
                iFileList->AddFileInfoL( info );
                CleanupStack::Pop( info );
                info = NULL;                    
                IAUPDATE_TRACE("[IAUPDATE] Info added to file list.");
                }
            
            CleanupStack::PopAndDestroy( details );
            details = NULL;
            }
        }

    CleanupStack::PopAndDestroy( &ids );
    CleanupStack::PopAndDestroy( history );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterInitializer::SetContentFileListL() end");
    }


void CIAUpdateSelfUpdaterInitializer::InitCompleteL()
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterInitializer::InitComplete() begin");

    // Everything has been done.
    // Set the state.
    iState = ENotStarted;

    if ( iFileList->FileInfos().Count() > 0 )
        {
        IAUPDATE_TRACE("[IAUPDATE] Add filelist into the controller list.");
        // Insert the file list for the use.
        // If this leaves, then let RunError handle the error situation.
        // It will also inform observer.
        Node().Controller().SelfUpdaterCtrl().AddFileListL( iFileList );
        // Ownership was transferred.
        iFileList = NULL;
        Observer().SelfUpdateInitComplete( KErrNone );
        }
    else
        {
        IAUPDATE_TRACE("[IAUPDATE] No files found. Error?");
        // No files to install. Think this as an error.
        // And, do not start the self updater because there is no need for that.
        // Let RunError handle the error situation.
        User::Leave( KErrNotFound );
        }

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterInitializer::InitComplete() end");
    }