/*

* Copyright (c) 2005-2006 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:  Gets the item DRM information

*

*/

// INCLUDE FILES

#include <coemain.h>

#include <StringLoader.h>

#include <DRMHelper.h>

#include <DRMRights.h>

#include <AknUtils.h>

#include <FileManagerDebug.h>

#include <drmuihandling.h>

#include "CFileManagerFullOmaDrmInfo.h"

// CONSTANTS

_LIT( KSeparator, "\t" );

#ifndef RD_DRM_COMMON_INTERFACE_FOR_OMA_AND_WMDRM

_LIT( KDateFormat1, "%1" );

_LIT( KDateFormat2, "%2" );

_LIT( KDateFormat3, "%3" );

_LIT( KTimeFormatBefore, " %-B %J:%T" );

_LIT( KTimeFormatAfter, " %J:%T %+B" );

_LIT( KEmptyChar, " " );

const TInt KDateStringLen = 20;

const TUint KSecondSeparator = 1;

const TUint KThirdSeparator = 2;

const TInt KPlayRights = 0;

const TInt KDisplayRights = 1;

const TInt KExecuteRights = 2;

const TInt KPrintRights = 3;

#endif // RD_DRM_COMMON_INTERFACE_FOR_OMA_AND_WMDRM

// ============================ LOCAL FUNCTIONS ================================

// -----------------------------------------------------------------------------

// AppendLabelAndDataToArrayL

// -----------------------------------------------------------------------------

static void AppendLabelAndDataToArrayL( CDesCArray& aArray,

                                 const TDesC& aLabel,

                                 const TDesC& aData )

    {

    HBufC* dataStr = HBufC::NewLC( aLabel.Length() +

                                   KSeparator().Length() +

                                   aData.Length() );

    TPtr dataPtr( dataStr->Des() );

    dataPtr.Append( aLabel );

    dataPtr.Append( KSeparator );

    dataPtr.Append( aData );

    AknTextUtils::LanguageSpecificNumberConversion( dataPtr );

    aArray.AppendL( dataPtr );

    CleanupStack::PopAndDestroy( dataStr );

    }

#ifndef RD_DRM_COMMON_INTERFACE_FOR_OMA_AND_WMDRM

// -----------------------------------------------------------------------------

// ResetAndDestroy

// -----------------------------------------------------------------------------

static void ResetAndDestroy( TAny* aPtr )

    {

    RPointerArray< CDRMHelperRightsConstraints >* array =

        static_cast< RPointerArray<CDRMHelperRightsConstraints>* >( aPtr );

    array->ResetAndDestroy();

    array->Close();

    }

// -----------------------------------------------------------------------------

// IsFutureRights

// -----------------------------------------------------------------------------

static TBool IsFutureRights(

        RPointerArray<CDRMRightsConstraints>& aRightsArray )

    {

    TBool ret( EFalse );

    const TInt count( aRightsArray.Count() );

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

        {

        CDRMRightsConstraints* rights = aRightsArray[i];

        TUint32 expiration( 0 );

        TUint32 constType( 0 );

        TInt topPriorityValue( CDRMRights::EInvalidRights );

        if( rights )

            {

            TInt currentPriorityValue( rights->GetConstraintInfo( expiration, constType ) );

            if( currentPriorityValue > topPriorityValue )

                {

                // priority is higher than previous rigths

                topPriorityValue = currentPriorityValue;

                if( CDRMRights::EFutureRights == expiration )

                    {

                    ret = ETrue;

                    }

                else

                    {

                    // no future rights

                    ret = EFalse;

                    }

                }

            }

        }

    return ret;

    }

// -----------------------------------------------------------------------------

// DateTimeStringLC

// -----------------------------------------------------------------------------

static HBufC* DateTimeStringLC( const TTime& aTime )

    {

    TBuf<KDateStringLen> dateStr;

    TBuf<KDateStringLen> timeStr;

    TBuf<KDateStringLen> dateStrFormat;

    // Localized date separator form

    TLocale local;

    dateStrFormat.Append( KDateFormat1 );

    dateStrFormat.Append( local.DateSeparator( KSecondSeparator ) );

    dateStrFormat.Append( KDateFormat2 );

    dateStrFormat.Append( local.DateSeparator( KThirdSeparator ) );

    dateStrFormat.Append( KDateFormat3 );

    aTime.FormatL( dateStr, dateStrFormat );

    if ( local.AmPmSymbolPosition() == ELocaleBefore )

        {

        aTime.FormatL( timeStr, KTimeFormatBefore );

        }

    else

        {

        aTime.FormatL( timeStr, KTimeFormatAfter );

        }

    HBufC* buf = HBufC::NewLC( dateStr.Length() +

                               KEmptyChar().Length() +

                               timeStr.Length() );

    TPtr ptrBuffer( buf->Des() );

    ptrBuffer.Append( dateStr );

    ptrBuffer.Append( KEmptyChar );

    ptrBuffer.Append( timeStr );

    return buf;

    }

// -----------------------------------------------------------------------------

// DateTimeL

// -----------------------------------------------------------------------------

static void DateTimeL( CDesCArray& aArray,

                const TTime& aTime,

                TInt aResourceId,

                const TDesC& aType )

    {

    HBufC* label = StringLoader::LoadLC( aResourceId, aType );

    HBufC* dateTime = DateTimeStringLC( aTime );

    AppendLabelAndDataToArrayL( aArray, *label, *dateTime );

    CleanupStack::PopAndDestroy( dateTime );

    CleanupStack::PopAndDestroy( label );

    }

// -----------------------------------------------------------------------------

// FillCounterInfoL

// -----------------------------------------------------------------------------

static void FillCounterInfoL( CDesCArray& aArray,

                       CDRMHelperRightsConstraints& aRights,

                       const TDesC& aType )

    {

    TUint32 count( 0 );

    TUint32 timedCount( 0 );

    TUint32 ignore1( 0 );

    TUint32 ignore2( 0 );

    TTimeIntervalSeconds ignore3( 0 );

    TInt err( KErrNone );

    TRAPD( errCount, aRights.GetCountersL( count, ignore1 ) );

    TRAPD( errTimedCount, aRights.GetTimedCountL( timedCount, ignore2,

        ignore3 ) );

    if ( errCount == KErrNone && errTimedCount == KErrNone )

        {

        // Both counts present, use minimum

        count = Min( count, timedCount );

        err = KErrNone;

        }

    else if ( errCount == KErrNone )

        {

        // Use count

        err = KErrNone;

        }

    else if ( errTimedCount == KErrNone )

        {

        // Use timed count

        count = timedCount;

        err = KErrNone;

        }

    else

        {

        // Neither regular nor timed count constraint

        // present, return error

        err = KErrNotFound;

        }

    if ( err == KErrNone )

        {

        // "Times left (%U)"

        HBufC* label =

                StringLoader::LoadLC( R_QTN_DRM_MGR_DET_UTL_X, aType );

        HBufC* data = NULL;

        if ( count == 1 )

            {

            // "1 count"

            data = StringLoader::LoadLC( R_QTN_DRM_MGR_DET_1_COUNT );

            }

        else

            {

            // "%N counts"

            data = StringLoader::LoadLC( R_QTN_DRM_MGR_DET_N_COUNTS, count );

            }

        AppendLabelAndDataToArrayL( aArray, *label, *data );

        CleanupStack::PopAndDestroy( data );

        CleanupStack::PopAndDestroy( label );

        }

    }

// -----------------------------------------------------------------------------

// SplitTime

// -----------------------------------------------------------------------------

//

static void SplitTime( const TTimeIntervalSeconds& aInterval,

        TInt& aIntYrs, TInt& aIntMon, TInt& aIntDay,

        TInt& aIntHrs, TInt& aIntMin, TInt& aIntSec )

    {

    const TInt KSecsInMin( 60 );

    const TInt KSecsInHour( KSecsInMin * 60 );

    const TInt KSecsInDay( KSecsInHour * 24 );

    // includes leap year day

    const TInt KLastMonthIndex = 11;

    const TInt KMaxDaysInMonths[] = {

            31,  62,  92, 123, 153, 184,

            215, 245, 276, 306, 337, 366 };

    // calculate full days

    TInt temp( aInterval.Int() / KSecsInDay );

    // calculate full years, calculate without leap year for user to get the 

    // longest time possible

    aIntYrs = temp / ( KMaxDaysInMonths[KLastMonthIndex] - 1 );

    // calc remainder days

    temp = temp % ( KMaxDaysInMonths[KLastMonthIndex] - 1 );

    aIntMon = 0;

    TInt i( 0 );

    if ( temp >= KMaxDaysInMonths[0] )

        {

        for ( i = 0; i < KLastMonthIndex; i++ )

            {

            // found correct amount of months

            if ( temp >= KMaxDaysInMonths[i] && temp < KMaxDaysInMonths[i+1] )

                {

                // i now contains amount of full months (+1 because of table index)

                aIntMon = i + 1;

                break;

                }

            }

        }

    // calc remainder days = allSecs - secsInFullYears - secsInFullMonts

    if( temp >= KMaxDaysInMonths[i] )

        {

        aIntDay = temp - KMaxDaysInMonths[i];

        }

    else

        {

        aIntDay = temp;

        }

    // calculate remainder secs

    temp = aInterval.Int() % KSecsInDay;

    aIntHrs = temp / KSecsInHour;

    // calculate remainder secs

    temp = temp % KSecsInHour;

    aIntMin = temp / KSecsInMin;

    // calculate remainder secs

    aIntSec = temp % KSecsInMin;

    }

// -----------------------------------------------------------------------------

// AddSinglePartOfTimeL

// -----------------------------------------------------------------------------

//

static void AddSinglePartOfTimeL( TInt aNumOfElements,

        TInt aResourceIdSingle,

        TInt aResourceIdOneFinal, 

        TInt aResourceIdTwoFour,

        TInt aResourceIdFiveZero, 

        CDesCArrayFlat* aStrings )

    {

    const TInt KDigitFive = 5;

    const TInt KDigitNine = 9;

    const TInt KDigitTen = 10;

    const TInt KDigitEleven = 11;

    const TInt KDigitFourTeen = 14;

    const TInt KDigitHundred = 100;

    HBufC* stringHolder = NULL;

    TInt finalOneDigit( aNumOfElements % KDigitTen );

    TInt finalTwoDigits( aNumOfElements % KDigitHundred );

    if ( aNumOfElements == 1 )

        {

        stringHolder = StringLoader::LoadLC( aResourceIdSingle );

        }

    else if ( finalOneDigit == 1 && finalTwoDigits != KDigitEleven )

        {

        stringHolder = StringLoader::LoadLC( aResourceIdOneFinal, 

            aNumOfElements );

        }

    else if ( finalOneDigit == 0 || 

             ( finalOneDigit >= KDigitFive && finalOneDigit <= KDigitNine ) ||

             ( finalTwoDigits >= KDigitEleven && finalTwoDigits <= KDigitFourTeen ) )

        {

        stringHolder = StringLoader::LoadLC( aResourceIdFiveZero,

            aNumOfElements );

        }

    else

        {

        stringHolder = StringLoader::LoadLC( aResourceIdTwoFour,

            aNumOfElements );

        }

    if ( aStrings )

        {

        aStrings->AppendL( *stringHolder );

        }

    CleanupStack::PopAndDestroy ( stringHolder );

    }

// -----------------------------------------------------------------------------

// AddPartsOfTimeLC

// -----------------------------------------------------------------------------

//

static HBufC* AddPartsOfTimeLC( TInt aIntYrs, TInt aIntMon, TInt aIntDay, 

                         TInt aIntHrs, TInt aIntMin, TInt aIntSec )

    {

    // Only the two most meaningful data will be showed

    TInt numOfData( 0 );

    const TInt KMaxDataItems = 2;

    CDesCArrayFlat* strings = new ( ELeave ) CDesCArrayFlat( KMaxDataItems );

    CleanupStack::PushL( strings );

    if ( aIntYrs > 0 )

        {

        AddSinglePartOfTimeL( aIntYrs, 

            R_QTN_DRM_NBR_OF_YEARS_ONE,

            R_QTN_DRM_NBR_OF_YEARS_ONE_FINAL,

            R_QTN_DRM_NBR_OF_YEARS_TWO_FOUR,

            R_QTN_DRM_NBR_OF_YEARS_FIVE_ZERO,

            strings );

        numOfData++;

        }

    if ( aIntMon > 0 )

        {

        //  Second type not provided because 11 is the maximum

        AddSinglePartOfTimeL( aIntMon, 

            R_QTN_DRM_NBR_OF_MONTHS_ONE,

            0,       

            R_QTN_DRM_NBR_OF_MONTHS_TWO_FOUR, 

            R_QTN_DRM_NBR_OF_MONTHS_FIVE_ZERO, 

            strings );

        numOfData++;

        }

    // Only if years or months were missing

    if ( aIntDay > 0 && numOfData < KMaxDataItems )

        {

        AddSinglePartOfTimeL( aIntDay, 

            R_QTN_DRM_NBR_OF_DAYS_ONE,

            R_QTN_DRM_NBR_OF_DAYS_ONE_FINAL,

            R_QTN_DRM_NBR_OF_DAYS_TWO_FOUR, 

            R_QTN_DRM_NBR_OF_DAYS_FIVE_ZERO, 

            strings );

        numOfData++;

        }

    if ( aIntHrs > 0 && numOfData < KMaxDataItems )

        {

        AddSinglePartOfTimeL( aIntHrs, 

            R_QTN_DRM_NBR_OF_HOURS_ONE, 

            R_QTN_DRM_NBR_OF_HOURS_ONE_FINAL,

            R_QTN_DRM_NBR_OF_HOURS_TWO_FOUR, 

            R_QTN_DRM_NBR_OF_HOURS_FIVE_ZERO, 

            strings );

        numOfData++;

        }

    if ( aIntMin > 0 && numOfData < KMaxDataItems )

        {

        AddSinglePartOfTimeL( aIntMin, 

            R_QTN_DRM_NBR_OF_MINS_ONE,

            R_QTN_DRM_NBR_OF_MINS_ONE_FINAL,

            R_QTN_DRM_NBR_OF_MINS_TWO_FOUR, 

            R_QTN_DRM_NBR_OF_MINS_FIVE_ZERO, 

            strings );

        numOfData++;

        }

    // If interval is 0, then it shows "0 seconds" anyway

    if ( ( aIntSec > 0 && numOfData < KMaxDataItems ) || numOfData == 0 )

        {

        AddSinglePartOfTimeL( aIntSec, 

            R_QTN_DRM_NBR_OF_SECS_ONE, 

            R_QTN_DRM_NBR_OF_SECS_ONE_FINAL,

            R_QTN_DRM_NBR_OF_SECS_TWO_FOUR, 

            R_QTN_DRM_NBR_OF_SECS_FIVE_ZERO, 

            strings );

        numOfData++;

        }

    HBufC* stringHolder = NULL;

    if ( numOfData == 1 )

        {

        stringHolder = StringLoader::LoadL( R_QTN_DRM_MGR_DET_INTER,

            strings->MdcaPoint(0) );

        }

    else

        {

        stringHolder = StringLoader::LoadL( R_QTN_DRM_MGR_DET_INTER_TWO,

            *strings );

        }

    CleanupStack::PopAndDestroy( strings );

    CleanupStack::PushL( stringHolder );

    return stringHolder;

    }

// -----------------------------------------------------------------------------

// FillUsageTimeLeftInfoL

// -----------------------------------------------------------------------------

static void FillUsageTimeLeftInfoL( CDesCArray& aArray,

                             const TTimeIntervalSeconds& aInterval,

                             const TDesC& aType,

                             TBool aIsAccumulatedTime )

    {

    TInt years( 0 );

    TInt months( 0 );

    TInt days( 0 );

    TInt hours( 0 );

    TInt minutes( 0 );

    TInt seconds( 0 );

    HBufC* label = NULL;

    HBufC* data = NULL;

    if ( aIsAccumulatedTime )

        {

        // "Usage time left"

        label = StringLoader::LoadLC( R_QTN_DRM_MGR_DET_ACCUM_TIME_LEFT  );

        }

    else

        {

        // "Time left (%U)"

        label = StringLoader::LoadLC( R_QTN_DRM_MGR_DET_UDL_X, aType );

        }

    SplitTime( aInterval, years, months, days, hours, minutes, seconds );

    data = AddPartsOfTimeLC( years, months, days, hours, minutes, seconds );

    AppendLabelAndDataToArrayL( aArray, *label, *data );

    CleanupStack::PopAndDestroy( data );

    CleanupStack::PopAndDestroy( label );

    }

// -----------------------------------------------------------------------------

// FillIntervalInfoL

// -----------------------------------------------------------------------------

static void FillIntervalInfoL( CDesCArray& aArray,

                        CDRMHelperRightsConstraints& aRights,

                        const TDesC& aType )

    {

    TTimeIntervalSeconds intervalSeconds( 0 );

    TRAPD( err, aRights.GetIntervalL( intervalSeconds ) );

    if ( err != KErrNotFound && err != KErrNone )

        {

        User::Leave( err );

        }

    if ( err == KErrNone )

        {

        TTime intervalStartTime( 0 );

        TRAP( err, aRights.GetIntervalStartL( intervalStartTime ) );