/*

* Copyright (c) 2008 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:  

*

*/

#include "creator_calendar.h" 

#include "creator_traces.h"

#include "creator_scriptentry.h"

#if(!defined __SERIES60_30__ && !defined __SERIES60_31__)

#include "creator_contactsetcache.h"

#include "creator_virtualphonebook.h"

#endif

#include <e32base.h>

#include <e32math.h>

#include <calrrule.h> 

#include <calalarm.h>

#if(!defined __SERIES60_30__ && !defined __SERIES60_31__)

#include <MVPbkFieldType.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkStoreContactFieldCollection.h>

#include <MVPbkContactFieldTextData.h>

#include <CVPbkContactManager.h>

#include <MVPbkStoreContact.h>

#include <CVPbkContactStoreUriArray.h>

#include <TVPbkContactStoreUriPtr.h>

#include <VPbkContactStoreUris.h>

#include <MVPbkContactStoreList.h>

#include <MVPbkContactStore.h>

#include <MVPbkContactStoreProperties.h>

#include <VPbkEng.rsg>

#endif

static const TInt KCalendarFieldLength = 128;

CCreatorCalenderAttendee::CCreatorCalenderAttendee() 

    {}

CCreatorCalenderAttendee::~CCreatorCalenderAttendee()

    {

    delete iCommonName;

    delete iEmailAddress;

    }

CCreatorCalenderAttendee* CCreatorCalenderAttendee::NewL()

    {

    CCreatorCalenderAttendee* self = new (ELeave) CCreatorCalenderAttendee;

    return self;

    }

void CCreatorCalenderAttendee::SetCommonNameL(const TDesC& aName)

    {

    delete iCommonName;

    iCommonName = 0;

    iCommonName = HBufC::NewL(aName.Length());

    iCommonName->Des().Copy(aName);

    }

void CCreatorCalenderAttendee::SetEmailAddressL(const TDesC& aEmail)

    {

    delete iEmailAddress;

    iEmailAddress = 0;

    iEmailAddress = HBufC::NewL(aEmail.Length());

    iEmailAddress->Des().Copy(aEmail);

    }

void CCreatorCalenderAttendee::SetRole(CCalAttendee::TCalRole aRole)

    {

    iRole = aRole;

    }

void CCreatorCalenderAttendee::SetStatus(CCalAttendee::TCalStatus aStatus)

    {

    iStatus = aStatus;

    }

const TDesC& CCreatorCalenderAttendee::CommonName() const

    {

    if( iCommonName == 0 )

    	return iDummy;

    return *iCommonName;

    }

const TDesC& CCreatorCalenderAttendee::EmailAddress() const

    {

    if( iEmailAddress == 0 )

    	return iDummy;

    return *iEmailAddress;

    }

CCalAttendee::TCalRole CCreatorCalenderAttendee::Role() const

    {

    return iRole;

    }

CCalAttendee::TCalStatus CCreatorCalenderAttendee::Status() const

    {

    return iStatus;

    }

TBool CCalenderInterimParameters::IsAllowedEntryStatus(CCalEntry::TType aType, CCalEntry::TStatus aStatus)

    {

    if( aType == CCalEntry::ETodo )

        {

        return  aStatus == CCalEntry::ECancelled ||

                aStatus == CCalEntry::ETodoNeedsAction ||

                aStatus == CCalEntry::ETodoCompleted ||

                aStatus == CCalEntry::ETodoInProcess;

        }

    return  aStatus == CCalEntry::ETentative ||

            aStatus == CCalEntry::EConfirmed ||

            aStatus == CCalEntry::ECancelled;

    }

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

CCalenderInterimParameters::CCalenderInterimParameters ( )

    {

    LOGSTRING("Creator: CCalenderInterimParameters::CCalenderInterimParameters");

    iAppointmentLocation = HBufC::New (KCalendarFieldLength );

    iAppointmentReason = HBufC::New (KCalendarFieldLength );

    iEventReason = HBufC::New (KCalendarFieldLength );

    iAnniversaryReason = HBufC::New (KCalendarFieldLength );

    iTodoTask = HBufC::New (KCalendarFieldLength );

    iReminderReason = HBufC::New (KCalendarFieldLength );

    iDescription = HBufC::New (KCalendarFieldLength );

    iSummary = HBufC::New (KCalendarFieldLength );

    iLocation = HBufC::New (KCalendarFieldLength );

    iOrganizerName = HBufC::New (KCalendarFieldLength );

    iOrganizerEmail = HBufC::New (KCalendarFieldLength );

    // set defaults, start date today and end date = today + 1 month

    iRandomModeStartTime.HomeTime ( );

    iRandomModeEndTime = iRandomModeStartTime;

    iRandomModeEndTime += TTimeIntervalMonths (1 );

    iAlarmTime = Time::NullTTime();

    iUseRandomAlarmTime = EFalse;

    iStatus = CCalEntry::ENullStatus;

    }

CCalenderInterimParameters::~CCalenderInterimParameters ( )

    {

    LOGSTRING("Creator: CCalenderInterimParameters::~CCalenderInterimParameters");

    delete iTodoTask;

    delete iAnniversaryReason;

    delete iEventReason;

    delete iAppointmentReason;

    delete iAppointmentLocation;

    delete iReminderReason;

    delete iDescription;

    delete iSummary;

    delete iLocation;

    delete iOrganizerName;

    delete iOrganizerEmail;

    iAttendees.ResetAndDestroy();

    iAttendees.Close();

    iAttendeeLinkIds.Reset();

    iAttendeeLinkIds.Close();

    }

void CCalenderInterimParameters::ParseL (CCommandParser* parser,

        TParseParams aCase )

    {

    LOGSTRING("Creator: CCalenderInterimParameters::ParseL");

    HBufC* tempBuf= NULL;

    switch (aCase )

        {

        case MCreatorModuleBaseParameters::ECalendarTodo:

            {

            parser->StrParserL (tempBuf, '|' );

            CleanupStack::PushL (tempBuf );

            this->iTodoDueTime = TTime (tempBuf->Des ( ) );

            parser->StrParserL (this->iTodoTask, '|' );

            parser->StrParserL (tempBuf, ';' );

            this->iTodoPriority = 2;

            if (tempBuf->Compare (_L("LOW") ) == 0 )

                this->iTodoPriority = 3;

            else

                if (tempBuf->Compare (_L("HIGH") ) == 0 )

                    this->iTodoPriority = 1;

            CleanupStack::PopAndDestroy (tempBuf );

            }

        case MCreatorModuleBaseParameters::ECalendarMemo:

            {

            parser->StrParserL (tempBuf, '|' );

            this->iStartTime = TTime (tempBuf->Des ( ) );

            parser->StrParserL (tempBuf, '|' );

            this->iEndTime = TTime (tempBuf->Des ( ) );

            parser->StrParserL (this->iDescription, ';' );

            CleanupStack::PopAndDestroy (tempBuf );

            }

        case MCreatorModuleBaseParameters::ECalendarMeeting:

            {

            parser->StrParserL (tempBuf, '|' );

            CleanupStack::PushL (tempBuf );

            this->iStartTime = TTime (tempBuf->Des ( ) );

            parser->StrParserL (tempBuf, '|' );

            this->iEndTime = TTime (tempBuf->Des ( ) );

            parser->StrParserL (this->iLocation, '|' );

            parser->StrParserL (this->iDescription, ';' );

            CleanupStack::PopAndDestroy (tempBuf );

            }

        case MCreatorModuleBaseParameters::ECalendarAnniv:

            {

            parser->StrParserL (tempBuf, '|' );

            CleanupStack::PushL (tempBuf );

            this->iStartTime = TTime (tempBuf->Des ( ) );

            parser->StrParserL (this->iDescription, ';' );

            CleanupStack::PopAndDestroy (tempBuf );

            }

        default:

            {

            //implement 

            }

        }

    }

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

CCreatorInterimCalendar* CCreatorInterimCalendar::NewL (CCreatorEngine* aEngine )

    {

    CCreatorInterimCalendar* self = CCreatorInterimCalendar::NewLC (aEngine );

    CleanupStack::Pop (self );

    return self;

    }

CCreatorInterimCalendar* CCreatorInterimCalendar::NewLC (CCreatorEngine* aEngine )

    {

    CCreatorInterimCalendar* self = new (ELeave) CCreatorInterimCalendar;

    CleanupStack::PushL (self );

    self->ConstructL (aEngine );

    return self;

    }

CCreatorInterimCalendar::CCreatorInterimCalendar ( )

    {

    }

void CCreatorInterimCalendar::ConstructL (CCreatorEngine* aEngine )

    {

    LOGSTRING("Creator: CCreatorInterimCalendar::ConstructL");

    iEngine = aEngine;

    // set defaults, start date today and end date = today + 1 month

    iRandomModeStartTime.HomeTime ( );

    iRandomModeEndTime = iRandomModeStartTime;

    iRandomModeEndTime += TTimeIntervalMonths (1 );

    iCalSession = CCalSession::NewL ( );

    // Create and open a calendar file

    const TDesC& fileName = iCalSession->DefaultFileNameL ( );//default filename is: "C:Calendar"

    TRAPD(err, iCalSession->CreateCalFileL(fileName))

    ;

    // ignore KErrAlreadyExists leave code

    if (err != KErrAlreadyExists )

        {

        User::LeaveIfError (err );

        }

    // Open the calendar file

    iCalSession->OpenL (fileName );

    iCalEntryView = CCalEntryView::NewL (*iCalSession, *this );

    iNumberRepeatingEntries = 0;

    iNumberOfAttendees = 0; //iEngine->RandomNumber(2, 15);

    iSetAlarm = EFalse;

    iWaiter = CAsyncWaiter::NewL();

    }

CCreatorInterimCalendar::~CCreatorInterimCalendar ( )

    {

    LOGSTRING("Creator: CCreatorInterimCalendar::~CCreatorInterimCalendar");

    if ( iEngine && iEntryIds.Count() )

        {

        TRAP_IGNORE( iEngine->WriteEntryIdsToStoreL( iEntryIds, KUidDictionaryUidCalendar ) );

        }

    iEntryIds.Reset();

    iEntryIds.Close();

    if (iParameters )

        {

        delete iParameters;

        }

    if (iCalEntryView )

        {

        delete iCalEntryView;

        }

    if (iCalSession )

        {

        delete iCalSession;

        }

    delete iSoundFileArray;

    delete iWaiter;

    delete iTmpCN;

    delete iTmpEmail;

#if(!defined __SERIES60_30__ && !defined __SERIES60_31__)

    delete iExistingContacts;

    delete iTempContact;

    delete iContactManager;

#endif

    }

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

TBool CCreatorInterimCalendar::AskDataFromUserL (TInt aCommand,

        TInt& aNumberOfEntries )

    {

    LOGSTRING("Creator: CCreatorInterimCalendar::AskDataFromUserL");

    if( aCommand == ECmdDeleteCalendarEntries )

        {

        return iEngine->YesNoQueryDialogL(_L("Delete all calendar entries?") );

        }

    if( aCommand == ECmdDeleteCreatorCalendarEntries )

        {

        return iEngine->YesNoQueryDialogL(_L("Delete all calendar entries created with Creator?") ); 

        }

    // display queries

    if (iEngine->EntriesQueryDialogL (aNumberOfEntries, _L("How many entries to create?") ) ) // ask number of entries to create

        {

        if( aCommand == ECmdCreateCalendarEntryEvents ||

            aCommand == ECmdCreateCalendarEntryAppointments)

            {

            _LIT(KRepeatingNum, "How many repeating (weekly) entries");

            if( !iEngine->EntriesQueryDialogL(iNumberRepeatingEntries, KRepeatingNum, ETrue))

                {

                return EFalse;

                }

            _LIT(KAttendeesNum, "How many attendees to create");

            if( !iEngine->EntriesQueryDialogL(iNumberOfAttendees, KAttendeesNum, ETrue))

                {

                return EFalse;

                }

            }

        if (iEngine->TimeQueryDialogL (iRandomModeStartTime, R_START_DATE_QUERY ) ) // ask start date

            {

            if (iEngine->TimeQueryDialogL (iRandomModeEndTime, R_END_DATE_QUERY ) ) // ask end date

                {

                if (iRandomModeStartTime > iRandomModeEndTime ) // check end date is ok

                    {

                    CAknInformationNote* note = new (ELeave) CAknInformationNote;

                    note->ExecuteLD (_L("End date must be after start date") );

                    return EFalse;

                    }

                else 

                    {

                    if( iEngine->YesNoQueryDialogL(_L("Add default alarm?")))

                        {

                        iSetAlarm = ETrue;

                        }                   

                    }                    

                    return ETrue;

                }

            else

                return EFalse;

            }

        else

            return EFalse;

        }

    else

        return EFalse;

    }

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

TInt CCreatorInterimCalendar::CreateAppointmentEntryL (

        CCreatorModuleBaseParameters *aParameters )

    {

    LOGSTRING("Creator: CCreatorInterimCalendar::CreateAppointmentEntryL");

    delete iParameters;

    iParameters = 0;

    CCalenderInterimParameters* parameters = (CCalenderInterimParameters*)aParameters;   

    if( !parameters )

        {

        iParameters = new(ELeave) CCalenderInterimParameters;

        parameters = iParameters;  

        parameters->iRandomModeStartTime = iRandomModeStartTime;

        parameters->iRandomModeEndTime = iRandomModeEndTime;    

        // difference between start and end times

        TTimeIntervalMinutes differenceInMinutes;

        parameters->iRandomModeEndTime.MinutesFrom (

                parameters->iRandomModeStartTime, differenceInMinutes );

        // start time (= something between the period start and end date)        

        parameters->iStartTime = parameters->iRandomModeStartTime;

        parameters->iStartTime

                += TTimeIntervalMinutes (iEngine->RandomNumber (differenceInMinutes.Int ( ) ) );   

        // set end time (= start time + some random time)    

        parameters->iEndTime = parameters->iStartTime;    

        parameters->iEndTime

                += TTimeIntervalMinutes (iEngine->RandomNumber (5, 500 ) );

        // strings        

        parameters->iLocation->Des ( )

                = iEngine->RandomString (CCreatorEngine::EMeetingPlace );

        parameters->iDescription->Des ( )

                = iEngine->RandomString (CCreatorEngine::EMeetingReason );

        parameters->iSummary->Des()

                        = parameters->iDescription->Des();

        parameters->iNumberRepeatingEntries = iNumberRepeatingEntries;

        parameters->iNumberOfAttendees = iNumberOfAttendees;

        }

    TInt err = KErrNone;

    HBufC8* guid = HBufC8::NewLC (255 );

    TPtr8 uidP=guid->Des ( );

    GenerateRandomId (uidP );

    CCalEntry* entry = CCalEntry::NewL (CCalEntry::EAppt, guid,

            CCalEntry::EMethodAdd, 0 );

    CleanupStack::PushL (entry );

    //Using same text as description and summary	

    entry->SetDescriptionL (parameters->iDescription->Des ( ) );

    entry->SetSummaryL (parameters->iSummary->Des ( ) );

    entry->SetLocationL (parameters->iLocation->Des ( ) );

    TCalTime startTime;

    TCalTime endTime;

    // Set the start and end times using time values local to the current system time zone

    TInt month = (TInt) parameters->iStartTime.DateTime().Month();

    TInt date = parameters->iStartTime.DateTime().Day();

    startTime.SetTimeLocalL (parameters->iStartTime );

    endTime.SetTimeLocalL (parameters->iEndTime );

    entry->SetStartAndEndTimeL (startTime, endTime );       

    if( parameters->IsAllowedEntryStatus(CCalEntry::EAppt, parameters->iStatus))

        {

        LOGSTRING2("Creator: CCreatorInterimCalendar::CreateAppointmentEntryL setting entry status: %d", parameters->iStatus);

        entry->SetStatusL(parameters->iStatus);

        }

    // Repeating times:

    AddRepeatingRuleL(startTime, *entry, parameters);

    SetOrganizerL(*entry, parameters);

    // Alarm:    

    if( iSetAlarm || parameters->iUseRandomAlarmTime )

        {        

        SetRandomAlarmL(*entry);

        }

    else

        {

        SetAlarmL(*entry, parameters);

        }

    // Add attendees:

    AddAttendeesL(*entry, parameters);

    RPointerArray<CCalEntry> array;

    CleanupClosePushL (array );

    array.AppendL (entry );

    TInt success(0);

    //If StoreL() leaves, 'success' contains the number of entries that were stored before it failed

    iCalEntryView->StoreL (array, success );

    // id has been generated, store it for being able to delete

    // entries created only with Creator

    iEntryIds.Append( entry->LocalUidL() );

    //One item should be added at time

    if (success != 1 )

        {

        err = 1;

        }

    CleanupStack::PopAndDestroy (&array );

    CleanupStack::PopAndDestroy (entry );

    CleanupStack::Pop (guid );//guid has been destroyed by entry, which has ownership to guid