/*
* 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:   CIAUpdateHistory
*
*/



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


#include "iaupdatehistoryimpl.h"
#include "iaupdatehistoryitemimpl.h"
#include "iaupdatenodefactory.h"



CIAUpdateHistory* CIAUpdateHistory::NewL( const TUid& aFamilyUid,
                                          MNcdProvider& aProvider )
    {
    CIAUpdateHistory* self = 
        CIAUpdateHistory::NewLC( aFamilyUid, aProvider );
    CleanupStack::Pop( self );
    return self;
    }


CIAUpdateHistory* CIAUpdateHistory::NewLC( const TUid& aFamilyUid,
                                           MNcdProvider& aProvider )
    {
    CIAUpdateHistory* self = 
        new( ELeave ) CIAUpdateHistory( aFamilyUid, aProvider );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


CIAUpdateHistory::CIAUpdateHistory( const TUid& aFamilyUid,
                                    MNcdProvider& aProvider )
: CBase(),
  iFamilyUid( aFamilyUid ),
  iProvider( aProvider )
    {
    
    }
    
void CIAUpdateHistory::ConstructL()
    {
    // Get the purchase history from the provider.
    // Leave if it can not be gotten.
    iHistory = Provider().PurchaseHistoryL();
    
    // The items from the NCD Engine purchase history 
    // are not fetched here.
    // Instead the user of this class has to call RefreshL to 
    // get and to update the list.
    }


CIAUpdateHistory::~CIAUpdateHistory()
    {
    iItems.ResetAndDestroy();
    History().Release();
    }


const RPointerArray< MIAUpdateHistoryItem >& CIAUpdateHistory::Items() const
    {
    return iItems;
    }


void CIAUpdateHistory::RefreshL()
    {
    iItems.ResetAndDestroy();

    // 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( FamilyUid() );
    filter->SetClientUids( uids.Array() );
    CleanupStack::PopAndDestroy( &uids );
    
    // Get the ids. So, we can next get all the corresponding
    // details.
    RArray< TUint > ids =
        History().PurchaseIdsL( *filter );
    CleanupStack::PopAndDestroy( filter );
    CleanupClosePushL( ids );
    
    // Get all the details and add corresponding history items 
    // into the array.
    // Notice, that pruneSelfUpdates is not required anymore for
    // the current version of IAD but it is here just in case
    // purchase history contains old information and this kind
    // of checking is needed for them. pruneSelfUpdates flag 
    // informs if other self update items in the list should 
    // be skipped because IAD has already been inserted in the 
    // list.
    TBool pruneSelfUpdates( EFalse );
    for ( TInt i = 0; i < ids.Count(); ++i )
        {
        // We do not want to load icons. So, use EFalse.
        // Ownership is transferred here.
        CNcdPurchaseDetails* details(
            History().PurchaseDetailsL( ids[ i ], EFalse ) );

        
        // Purchase history detail contains the UID information.
        // So, use it here.
        TUid itemUid(
            TUid::Uid( 
                details->AttributeInt32( 
                  MNcdPurchaseDetails::EPurchaseAttributeContentUid ) ) );
       
        if ( IAUpdateNodeFactory::IsSelfUpdate( itemUid )
             || IAUpdateNodeFactory::IsUpdater( itemUid ) 
             || AcceptItem( *details ) )
            {
            if ( !pruneSelfUpdates )
                {
                // If pruning is not on, then all the items are accepted.
                // This takes the ownership of details.
                InsertItemL( details );                       

                if ( IAUpdateNodeFactory::IsIad( itemUid ) )
                    {
                    // IAD was found, but because pruning was not on yet,
                    // set it on.
                    pruneSelfUpdates = ETrue;
                    }
                }
            else if ( !IAUpdateNodeFactory::IsSelfUpdate( itemUid )
                      && !IAUpdateNodeFactory::IsUpdater( itemUid ) )
                {
                // If pruning is on, then accept only items that are not
                // self update related. This takes the ownership of details.
                InsertItemL( details );
                }
            else
                {
                // Item was not inserted to the array. So, delete it.
                delete details;
                details = NULL;
                }            
            }
        else
            {
            // Item was not accepted into the history.
            // So, just skip it.
            delete details;
            details = NULL;
            }
        }
    
    CleanupStack::PopAndDestroy( &ids );
    }


MNcdProvider& CIAUpdateHistory::Provider()
    {
    return iProvider;
    }

    
MNcdPurchaseHistory& CIAUpdateHistory::History()
    {
    return *iHistory;
    }


const TUid& CIAUpdateHistory::FamilyUid() const
    {
    return iFamilyUid;    
    }

  
void CIAUpdateHistory::InsertItemL( MNcdPurchaseDetails* aDetails )
    {
    if ( !aDetails )
        {
        // Nothing to do with NULL object.
        return;
        }

    CleanupStack::PushL( aDetails );
    CIAUpdateHistoryItem* item( 
        CIAUpdateHistoryItem::NewL( aDetails, Provider() ) );
    CleanupStack::Pop( aDetails );
    CleanupStack::PushL( item );
    
    if ( iItems.Count() == 0 )
        {
        // Array is empty. 
        // So, just append new item.
        iItems.AppendL( item );
        CleanupStack::Pop( item );
        return;
        }

    // Check if there exists an older version of the item
    // in the array.
    for ( TInt i = 0; i < iItems.Count(); ++i )
        {
        // Casting here is safe thing to do because this function
        // is the only one that creates the array items and the items
        // are created as CIAUpdateHistoryItem objects.
        CIAUpdateHistoryItem* arrayItem(
            static_cast< CIAUpdateHistoryItem* >( iItems[ i ] ) );
            
        // Get the purchase detail object from the arrayItem.
        // So, we can check the detail identifications.
        const MNcdPurchaseDetails& arrayItemDetails( arrayItem->Details() );

        if ( aDetails->EntityId() == arrayItemDetails.EntityId()
             && aDetails->Namespace() == arrayItemDetails.Namespace()
             && aDetails->ClientUid() == arrayItemDetails.ClientUid() )
            {
            // We have two same items. So, compare their operation times.
            if ( aDetails->LastOperationTime() 
                 > arrayItemDetails.LastOperationTime() )
                {
                // The array item was older for the same purhcase detail.
                // So, remove the old version.
                delete iItems[ i ];
                iItems[ i ] = NULL;
                iItems.Remove( i );
                
                // Continue to the phase were the current item will be
                // inserted to the correct place in the array.
                break;
                }
            else
                {
                // Let the array item be in the array because its newer.
                // Just delete the unnecessary new one.
                CleanupStack::PopAndDestroy( item );

                // Nothing to do here anymore.
                return;
                }
            }
        }

    // Insert the item into a correct place in the array.
    for ( TInt i = 0; i < iItems.Count(); ++i )
        {
        MIAUpdateHistoryItem* arrayItem( iItems[ i ] );

        TTime itemTime( item->LastOperationTime() );
        TDateTime itemDateTime( itemTime.DateTime() );
        TTime arrayItemTime( arrayItem->LastOperationTime() );
        TDateTime arrayItemDateTime( arrayItemTime.DateTime() );
        
        // The right place to insert the item is
        // 1.1. Item in the array is from previous day than this item.
        // 1.2. Items are from the same day. 
        //      Item in the array is not error item, but this item is.
        //      (Error items first)
        // 1.3. Items are from the same day.
        //      If item in array and this are same type, but the time of
        //      this item is later. (Latest ones first)
        
        TBool arrayItemPreviousDay( 
            itemDateTime.Day() > arrayItemDateTime.Day()
                && itemDateTime.Month() == arrayItemDateTime.Month()
                && itemDateTime.Year() == arrayItemDateTime.Year()
            || itemDateTime.Month() > arrayItemDateTime.Month()
                && itemDateTime.Year() == arrayItemDateTime.Year()
            || itemDateTime.Year() > arrayItemDateTime.Year() );

        TBool itemsSameDay( 
            itemDateTime.Day() == arrayItemDateTime.Day()
            && itemDateTime.Month() == arrayItemDateTime.Month()
            && itemDateTime.Year() == arrayItemDateTime.Year() );        
        
        TBool itemSuccessfullyInstalled( 
            item->LastOperationErrorCode() == KErrNone
            && item->StateL() == MIAUpdateHistoryItem::EInstalled );

        TBool arrayItemSuccessfullyInstalled( 
            arrayItem->LastOperationErrorCode() == KErrNone
            && arrayItem->StateL() == MIAUpdateHistoryItem::EInstalled );
        
        if ( arrayItemPreviousDay
             || itemsSameDay
                && ( arrayItemSuccessfullyInstalled 
                        && !itemSuccessfullyInstalled
                     || itemSuccessfullyInstalled == arrayItemSuccessfullyInstalled
                        && itemTime > arrayItemTime ) )
            {
            iItems.InsertL( item, i );
            CleanupStack::Pop( item );       
            return;            
            }
        }

    // If we came here, then the item should be appended to the end
    // of the array, because it was not inserted above.        
    iItems.AppendL( item );
    CleanupStack::Pop( item );
    }


TBool CIAUpdateHistory::AcceptItem( const CNcdPurchaseDetails& aItem ) const
    {
    TBool accept( ETrue );

    const TDesC& mime( 
        aItem.AttributeString( 
            MNcdPurchaseDetails::EPurchaseAttributeContentMimeType ) );

    if ( IAUpdateNodeFactory::IsFwUpdate( mime )
         || IAUpdateNodeFactory::IsHidden( mime ) )
        {
        // Do not accept firmwares into the history.
        // Do not accept hidden items into the history.
        accept = EFalse;
        }

    return accept;
    }