/*
* Copyright (c) 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:   Debug tools for Calendar 
*
*/



//debug
#include "calendarui_debug.h"

#include "calendebug.h"

#ifdef _DEBUG

#include <calalarm.h>
#include <calentry.h>
#include <calinstance.h>
#include <calrrule.h>
#include <e32debug.h>
#include <utf.h> 

namespace CalenDebug 
    {
    void LogTimeL(const TDesC& aMsg, const TTime& aTime)
        {
        TBuf<30> tmp;
        if ( aTime == Time::NullTTime() )
            {
            tmp = _L("null time");
            }
        else 
            {
            _LIT(KDtFmt, "%F%H:%T %D.%M.%Y");
            aTime.FormatL( tmp, KDtFmt ); 
            }
        RDebug::Print(aMsg, &tmp);
        }

    void LogRRuleL(const TCalRRule& aRule)
        {
        _LIT(KYearly,  "Yearly");
        _LIT(KMonthly, "Monthly");
        _LIT(KWeekly,  "Weekly");
        _LIT(KDaily,   "Daily");
        _LIT(KInvalid, "Invalid");

        TBuf<20> typeStr;
        switch ( aRule.Type() )
            {
            case TCalRRule::EInvalid:
                typeStr = KInvalid;
                break;
            case TCalRRule::EDaily:
                typeStr = KDaily;
                break;
            case TCalRRule::EWeekly:
                typeStr = KWeekly;
                break;
            case TCalRRule::EMonthly:
                typeStr = KMonthly;
                break;
            case TCalRRule::EYearly:
                typeStr = KYearly;
                break;
            }
        RDebug::RawPrint( typeStr );
        RDebug::Print( _L("Count   %d"), aRule.Count() );
        RDebug::Print( _L("Interv. %d"), aRule.Interval() );

        RDebug::RawPrint( _L("UTC:") );
        LOGTIME(       _L("DtStart %S"), aRule.DtStart().TimeUtcL() );
        LOGTIME(       _L("Until   %S"), aRule.Until().TimeUtcL() );

        RDebug::RawPrint( _L("Local:") );
        LOGTIME(       _L("DtStart %S"), aRule.DtStart().TimeLocalL() );
        LOGTIME(       _L("Until   %S"), aRule.Until().TimeLocalL() );
        }

    void LogGuidL( const TDesC8& aGuid )
        {
        HBufC16* guid = CnvUtfConverter::ConvertToUnicodeFromUtf8L( aGuid );
        CleanupStack::PushL( guid );
        RDebug::Print( _L("Guid:\"%S\""), guid );
        CleanupStack::PopAndDestroy( guid );
        }

    void LogCalTimeL( TCalTime& aCalTime )
        {
        LOGTIME(_L("UTC   %S"), aCalTime.TimeUtcL());
        LOGTIME(_L("Local %S"), aCalTime.TimeLocalL());
        }

    void LogEntryRecurrenceIdL( CCalEntry& aEntry )
        {
        TCalTime recurrenceId;
        TRAPD( err, recurrenceId = aEntry.RecurrenceIdL() );
        if ( err == KErrNone )
            {
            if ( recurrenceId.TimeUtcL() == Time::NullTTime() )
                {
                RDebug::RawPrint( _L("No recurrence id") );
                }
            else
                {
                RDebug::RawPrint( _L("Recurrence id:") );
                LogCalTimeL( recurrenceId );
                }
            }
        else
            {
            RDebug::Print( _L("Recurrence id: reading leaved with %d"), err );
            }
        }

    void LogRecurrenceRangeL( CalCommon::TRecurrenceRange aRange )
        {
        switch ( aRange )
            {
            case CalCommon::EThisOnly:
                RDebug::RawPrint( _L("ThisOnly") );
                break;
            case CalCommon::EThisAndAll:
                RDebug::RawPrint( _L("ThisAndAll") );
                break;
            case CalCommon::EThisAndFuture:
                RDebug::RawPrint( _L("ThisAndFuture") );
                break;
            case CalCommon::EThisAndPrior:
                RDebug::RawPrint( _L("ThisAndPrior") );
                break;
            }
        }

    void LogDatesL( RArray<TCalTime>& aExDateList )
        {

        if ( aExDateList.Count() > 0 )
            {
            RDebug::RawPrint( _L("START                    ***") );
            for (TInt i=0; i < aExDateList.Count(); i++) 
                {
                LogCalTimeL( aExDateList[i] );
                }
            RDebug::RawPrint( _L("END                      ***") );
            }
        }

    void LogEntryDetailsL(CCalEntry& aEntry)
        {
        RDebug::RawPrint( aEntry.SummaryL() );
        RDebug::RawPrint( aEntry.LocationL() );

        LogGuidL( aEntry.UidL() );
        LogEntryRecurrenceIdL( aEntry );
        LogRecurrenceRangeL( aEntry.RecurrenceRangeL() );

        RArray< TCalTime > exceptionDates;
        CleanupClosePushL( exceptionDates );
        aEntry.GetExceptionDatesL( exceptionDates );
        RDebug::Print( _L("Exception dates %d"), exceptionDates.Count() );
        LogDatesL( exceptionDates );
        CleanupStack::PopAndDestroy( & exceptionDates );

        // Guid
        //     HBufC* guid = HBufC16::NewLC(500);
        //     guid->Copy( aEntry.UidL() );
        //     RDebug::Print( *guid );
        //     CleanupStack::PopAndDestroy( guid );

        // Entry Start and end times
        // Note %S modifier is very important!
        // UTC
        RDebug::RawPrint( _L("Entry UTC:" ) );
        LOGTIME(_L("Start %S"), aEntry.StartTimeL().TimeUtcL());
        LOGTIME(_L("End   %S"), aEntry.EndTimeL().TimeUtcL());

        // Local 
        RDebug::RawPrint( _L("Entry Local:" ) );
        LOGTIME(_L("Start %S"), aEntry.StartTimeL().TimeLocalL());
        LOGTIME(_L("End   %S"), aEntry.EndTimeL().TimeLocalL());

        // Alarm 
        CCalAlarm* alarm = aEntry.AlarmL();
        CleanupStack::PushL( alarm );
        if ( alarm )
            {
            RDebug::RawPrint( _L("Has alarm" ) );
            RDebug::Print( _L(" offset: %d"), alarm->TimeOffset().Int() );
            }
        else
            {
            RDebug::RawPrint( _L("No alarm") );
            }
        CleanupStack::PopAndDestroy(alarm);

        // Repeat rule 
        TCalRRule rrule;
        if ( aEntry.GetRRuleL(rrule) )
            {
            RDebug::RawPrint( _L("Has rrule" ) );
            LOGRRULE( rrule );
            }
        else
            {
            RDebug::RawPrint( _L("No rrule" ) );
            }
        }

    void LogInstanceDetailsL(CCalInstance& aInstance)
        {
        // Instance times
        // UTC
        RDebug::RawPrint( _L("Instance UTC:") );
        LOGTIME(_L("time  %S"), aInstance.Time().TimeUtcL());
        LOGTIME(_L("start %S"), aInstance.StartTimeL().TimeUtcL());
        LOGTIME(_L("end   %S"), aInstance.EndTimeL().TimeUtcL());

        // Local 
        RDebug::RawPrint( _L("Instance Local:") );
        LOGTIME(_L("time  %S"), aInstance.Time().TimeLocalL());
        LOGTIME(_L("start %S"), aInstance.StartTimeL().TimeLocalL());
        LOGTIME(_L("end   %S"), aInstance.EndTimeL().TimeLocalL());
        }

    void LogEntryL(CCalEntry& aEntry)
        {
        RDebug::RawPrint( _L("----- ENTRY -----") );
        LogEntryDetailsL( aEntry );
        }

    void LogInstanceL(CCalInstance& aInstance)
        {
        RDebug::RawPrint( _L("----- INSTANCE -----") );
        LogEntryDetailsL( aInstance.Entry() );
        LogInstanceDetailsL( aInstance );
        }
    }

#endif // _DEBUG