/*
* Copyright (c) 2002 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:  
*     A helper class for filling the viewer component with data from a
*     calendar item.
*
*/




// INCLUDE FILES
#include "VCalBcDataFiller.h"       // CVCalBcDataFiller
#include "VCalBcPanics.h"           // panic codes

#include <calentry.h>
#include <calalarm.h>
#include <StringLoader.h>           // StringLoader
#include <vcalbc.rsg>               // resouce identifiers
#include <avkon.rsg>                // resouce identifiers
#include <CRichBio.h>               // CRichBio

// CONSTANTS

const TInt KMaxDateTimeTextLength = 100;
const TInt KRepeatIntervalBiWeekly = 2;

//  MEMBER FUNCTIONS

CVCalBcDataFiller::~CVCalBcDataFiller()
    {
    delete iDateFormat;
    delete iTimeFormat;
    delete iSummaryDescr;
    }

void CVCalBcDataFiller::FillViewerWithDataL(
    CRichBio& aViewer,
    CCalEntry& aEntry,
    CCoeEnv& aCoeEnv)
    {
    // An instance is used because otherwise we would have to pass around many
    // arguments.
    CVCalBcDataFiller* filler = CVCalBcDataFiller::NewLC(aEntry, aCoeEnv);
    filler->FillViewerWithDataL(aViewer);
    CleanupStack::PopAndDestroy(filler);
    }

void CVCalBcDataFiller::FillViewerWithDataL(CRichBio& aViewer)
    {
    __ASSERT_DEBUG(&aViewer != NULL, Panic(ENullViewer));

	TTime startTime(Time::NullTTime());
	//we want to trap KErrArgument if time is not set
	TRAP_IGNORE((startTime = iEntry.StartTimeL().TimeLocalL()));
	
	TTime endTime(Time::NullTTime());
	TRAP_IGNORE((endTime = iEntry.EndTimeL().TimeLocalL()));
	
	CCalEntry::TType type( iEntry.EntryTypeL() );
    if (type == CCalEntry::EAnniv)
        {
		AddAnniversarySpecificInfoL(aViewer, startTime);
        }
    else if (type == CCalEntry::EAppt)
        {
		AddMeetingSpecificInfoL(aViewer, startTime, endTime);
        }
    else if (type == CCalEntry::EEvent)
        {
		AddDaynoteSpecificInfoL(aViewer, startTime, endTime);
        }
    else if (type ==CCalEntry::ETodo)
    	{
    	AddVTodoSpecificInfoL(aViewer);
    	}
    else
        {
        // The class CCalenImporter is responsible for checking the Series 60
        // compatibility of the entry. It is used before coming here.
        __ASSERT_ALWAYS(EFalse, Panic(EUnsupportedEntryType));
        return;
        }

    if (type != CCalEntry::ETodo)
    	{
    	AddConfidentialityInfoL(aViewer);
    	}
    
    //the description field is supported by all entry types
	AddDescriptionInfoL( aViewer );
    }

void CVCalBcDataFiller::AddAnniversarySpecificInfoL(
    CRichBio& aViewer,
    const TTime& aStartTime)
    {
    AddItemL(aViewer, R_QTN_SM_CAL_TYPELABEL, R_QTN_SM_CAL_TYPE_ANNIV);
    AddItemL(aViewer, R_QTN_SM_CAL_ANNIVERS_SUBJECT, *iSummaryDescr);
    AddItemAsDateL(aViewer, R_QTN_SM_CAL_ANNIVERS_DATE, aStartTime);
    AddAlarmInfoL(aViewer);
    }

void CVCalBcDataFiller::AddMeetingSpecificInfoL(
    CRichBio& aViewer,
    const TTime& aStartTime,
    const TTime& aEndTime)
    {
    AddItemL(aViewer, R_QTN_SM_CAL_TYPELABEL, R_QTN_SM_CAL_TYPE_MEETING);
    AddItemL(aViewer, R_QTN_SM_CAL_MEETING_SUBJECT, *iSummaryDescr);
    if (iEntry.LocationL().Length() > 0)
        {
        AddItemL(aViewer, R_QTN_SM_CAL_MEETING_LOCATION, iEntry.LocationL());
        }
    AddItemAsDateL(aViewer, R_QTN_SM_CAL_STARTDATE, aStartTime);
    AddItemAsTimeL(aViewer, R_QTN_SM_CAL_MEETING_START_TIME, aStartTime);
    AddItemAsDateL(aViewer, R_QTN_SM_CAL_ENDDATE, aEndTime);
    AddItemAsTimeL(aViewer, R_QTN_SM_CAL_MEETING_END_TIME, aEndTime);
    AddAlarmInfoL(aViewer);
    AddRepeatInfoL(aViewer);
    }

void CVCalBcDataFiller::AddDaynoteSpecificInfoL(
    CRichBio& aViewer,
    const TTime& aStartTime,
    const TTime& aEndTime)
    {
    AddItemL(aViewer, R_QTN_SM_CAL_TYPELABEL, R_QTN_SM_CAL_TYPE_DAYNOTE);
    AddItemL(aViewer, R_QTN_SM_CAL_DAY_NOTE_SUBJECT, *iSummaryDescr);
    
    TInt duration = aEndTime.DaysFrom(aStartTime).Int();
    
    if(duration > 0)
    	duration--;    
    TTimeIntervalDays offset(duration);
    
    TTime endTime(aStartTime);
    endTime += offset;
    AddItemAsDateL(aViewer, R_QTN_SM_CAL_STARTDATE, aStartTime);
    AddItemAsDateL(aViewer, R_QTN_SM_CAL_ENDDATE, endTime);
    AddRepeatInfoL(aViewer);
    }

void CVCalBcDataFiller::AddVTodoSpecificInfoL(CRichBio& aViewer)
	{
	AddVTodoTypeInfoL(aViewer);
	AddVTodoSubjectInfoL(aViewer);
	AddVTodoDueDateInfoL(aViewer);
	AddVTodoAlarmInfoL(aViewer);
	AddVTodoPriorityInfoL(aViewer);
	}

void CVCalBcDataFiller::AddAlarmInfoL(
    CRichBio& aViewer)
    {
    CCalAlarm* alarm = iEntry.AlarmL();
    if ( alarm )
        {
        CleanupStack::PushL( alarm );
   		TTime alarmTime(iEntry.StartTimeL().TimeLocalL());

        alarmTime -= alarm->TimeOffset();
        AddItemAsTimeL(aViewer, R_QTN_SM_CAL_EVENT_ALARM_TIME, alarmTime );
        AddItemAsDateL(aViewer, R_QTN_SM_CAL_EVENT_ALARM_DATE, alarmTime );
        CleanupStack::PopAndDestroy( alarm );
        }
    }


void CVCalBcDataFiller::AddRepeatInfoL(CRichBio& aViewer)
    {
    TCalRRule repeatRule;//( TCalRRule::EInvalid );
    if( !iEntry.GetRRuleL (repeatRule) )
        {
        return;
        }
    TInt valueRes = RepeatIndexValueTextRes( repeatRule );
    if( valueRes )
        {
        AddItemL(aViewer, R_QTN_SM_CAL_MEETING_REPEAT, valueRes);
        TTime endtime = repeatRule.Until().TimeLocalL();
        AddItemAsDateL( aViewer, R_QTN_SM_CAL_MEETING_REPEAT_UNTIL, endtime );
        }
    }


TInt CVCalBcDataFiller::RepeatIndexValueTextRes(TCalRRule aRepeatRule ) const
    {
    TInt res = 0;

    switch( aRepeatRule.Type() )
        {
        case TCalRRule::EInvalid:
            {
            // No repeat value
            break;
            }
        case TCalRRule::EDaily:
            {
            res = R_QTN_SM_CAL_MEETING_RPT_DAILY;
            break;
            }
        case TCalRRule::EWeekly:
            {
            if( aRepeatRule.Interval() == KRepeatIntervalBiWeekly )
                {
                res = R_QTN_SM_CAL_MEETING_RPT_BIWEEKLY;
                }
            else
                {
                res = R_QTN_SM_CAL_MEETING_RPT_WEEKLY;
                }
            break;
            }
        case TCalRRule::EMonthly:
            {
            res = R_QTN_SM_CAL_MEETING_RPT_MONTHLY;
            break;
            }
        case TCalRRule::EYearly:
            {
            res = R_QTN_SM_CAL_MEETING_RPT_YEARLY;
            break;
            }
        default:
            {
            // Unexpected repeat index value
            __ASSERT_DEBUG(res, Panic(EVCalBCPanicUndefinedRepeatIndex));
            res = R_QTN_SM_CAL_RPT_OTHER;
            break;
            }
        }
    return res;
    }


void CVCalBcDataFiller::AddConfidentialityInfoL(CRichBio& aViewer)
    {
    CCalEntry::TReplicationStatus status = iEntry.ReplicationStatusL();
//    TAgnReplicationData::TStatus status = replicationData.Status();
    TInt valueRes = 0;
    if (status == CCalEntry::EOpen)
        {
        valueRes = R_QTN_SM_CAL_SYNC_PUBLIC;
        }
    else if (status == CCalEntry::EPrivate)
        {
        valueRes = R_QTN_SM_CAL_SYNC_PRIVATE;
        }
    else if (status == CCalEntry::ERestricted)
        {
        valueRes = R_QTN_SM_CAL_SYNC_NO_SYNC;
        }
    __ASSERT_DEBUG(valueRes, Panic(EInvalidConfid));
    AddItemL(aViewer, R_QTN_SM_CAL_SYNCHRONISATION, valueRes);
    }


void CVCalBcDataFiller::AddDescriptionInfoL(CRichBio& aViewer)
    {
	const TDesC& descData = iEntry.DescriptionL();
	if ( descData.Length() != 0 )
		{
	    AddItemL(aViewer, R_QTN_SM_CAL_MEETING_DESCRIPTION, descData);
		}
    }


HBufC* CVCalBcDataFiller::TextContentsFromEntryL(CCalEntry& aEntry)
    {
    HBufC* text = aEntry.SummaryL().AllocL();
    /*TPtr textPtr(text->Des());
    // Copy the text from richtext to descriptor:
    aEntry.RichTextL()->Extract(textPtr, 0,
        aEntry.RichTextL()->DocumentLength());
    CleanupStack::Pop(text);*/
    return text;
    }

void CVCalBcDataFiller::AddItemL(CRichBio& aViewer, TInt aLabelRes,
    const TDesC& aValue)
    {
    // Empty fields are not shown.
    if (aValue.Length())
        {
        aViewer.AddItemL(*StringLoader::LoadLC(aLabelRes, &iCoeEnv), aValue);
        CleanupStack::PopAndDestroy(); // (label text)
        }
    }

void CVCalBcDataFiller::AddItemL(CRichBio& aViewer, TInt aLabelRes,
    TInt aValueRes)
    {
    aViewer.AddItemL(
        *StringLoader::LoadLC(aLabelRes, &iCoeEnv),
        *StringLoader::LoadLC(aValueRes, &iCoeEnv));
    CleanupStack::PopAndDestroy(2); // (label and value text)
    }

void CVCalBcDataFiller::AddItemAsDateL(CRichBio& aViewer,
    TInt aLabelRes,
    const TTime& aTime)
    {
    if(aTime != Time::NullTTime())
    	{
    	TBuf<KMaxDateTimeTextLength> tmpString;
    	aTime.FormatL(tmpString, *iDateFormat);
    	AddItemL(aViewer, aLabelRes, tmpString);
    	}
    }

void CVCalBcDataFiller::AddItemAsTimeL(CRichBio& aViewer,
    TInt aLabelRes,
    const TTime& aTime)
    {
    if(aTime != Time::NullTTime())
    	{
    	TBuf<KMaxDateTimeTextLength> tmpString;
    	aTime.FormatL(tmpString, *iTimeFormat);
    	AddItemL(aViewer, aLabelRes, tmpString);
    	}
    }

CVCalBcDataFiller* CVCalBcDataFiller::NewLC(CCalEntry& aEntry, CCoeEnv& aCoeEnv)
    {
    __ASSERT_DEBUG(&aEntry != NULL, Panic(ENullEntryGivenToFiller));
    CVCalBcDataFiller* self = new (ELeave)CVCalBcDataFiller(aEntry, aCoeEnv);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

CVCalBcDataFiller::CVCalBcDataFiller(CCalEntry& aEntry, CCoeEnv& aCoeEnv)
    : iCoeEnv(aCoeEnv), iEntry(aEntry)
    {
    }

void CVCalBcDataFiller::ConstructL()
    {
    iDateFormat = StringLoader::LoadL(R_QTN_DATE_USUAL_WITH_ZERO, &iCoeEnv);
    iTimeFormat = StringLoader::LoadL(R_QTN_TIME_USUAL, &iCoeEnv);
    //Get the text field contents. It is needed for all four types of entry.
    iSummaryDescr = TextContentsFromEntryL(iEntry);
    }

void CVCalBcDataFiller::AddVTodoTypeInfoL(CRichBio& aViewer)
	{
	AddItemL(aViewer, R_QTN_SM_CAL_TYPELABEL, R_QTN_SM_CAL_TYPE_TODO);
	}

void CVCalBcDataFiller::AddVTodoSubjectInfoL(CRichBio& aViewer)
	{
    AddItemL(aViewer, R_QTN_SM_TODO_SUBJECT, *iSummaryDescr);
	}

void CVCalBcDataFiller::AddVTodoDueDateInfoL(CRichBio& aViewer)
	{
	TTime dueDate(Time::NullTTime());
	TRAP_IGNORE((dueDate = iEntry.EndTimeL().TimeLocalL()));
	AddItemAsDateL(aViewer, R_QTN_SM_TODO_DUE_DATE, dueDate);
	}

void CVCalBcDataFiller::AddVTodoAlarmInfoL(CRichBio& aViewer)
	{
	CCalAlarm* alarm = iEntry.AlarmL();

	if( alarm )
		{
		CleanupStack::PushL(alarm);
		TTime alarmTime(iEntry.EndTimeL().TimeLocalL());

        alarmTime -= alarm->TimeOffset();
        AddItemAsTimeL(aViewer, R_QTN_SM_CAL_EVENT_ALARM_TIME, alarmTime );
        AddItemAsDateL(aViewer, R_QTN_SM_CAL_EVENT_ALARM_DATE, alarmTime );
        CleanupStack::PopAndDestroy(alarm);
		}


	}

void CVCalBcDataFiller::AddVTodoPriorityInfoL(CRichBio& aViewer)
	{
    TUint todoPriority = iEntry.PriorityL();

    TInt priorityString( 0 );

    if (todoPriority == 1 )
    	{
    	priorityString = R_QTN_SM_TODO_PRIORITY_HIGH;
    	}
    else if (todoPriority == 2)
    	{
    	priorityString = R_QTN_SM_TODO_PRIORITY_NORMAL;
    	}
    else if (todoPriority == 3)
    	{
    	priorityString = R_QTN_SM_TODO_PRIORITY_LOW;
    	}

    if( todoPriority >= 1 && todoPriority <= 3 )
    	AddItemL(aViewer, R_QTN_SM_TODO_PRIORITY, priorityString);

	}

// end of file