/*

* Copyright (c) 2010 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 "engine.h"

#include "enginewrapper.h"

#include "creator_calendar.h" 

#include "creator_traces.h"

#include "creator_scriptentry.h"

#include <e32base.h>

#include <e32math.h>

#include <calrrule.h> 

#include <calalarm.h>

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;

    }

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

void CCreatorInterimCalendar::QueryDialogClosedL(TBool aPositiveAction, TInt aUserData)

    {

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

    if( aPositiveAction == EFalse && aUserData != ECreatorCalendarAddDefaultAlarm )

        {

        iEngine->ShutDownEnginesL();

        return;

        }

    const TDesC* showText = &KSavingText;

    TBool finished(EFalse);

    TBool retval(ETrue);

    switch(aUserData)

        {

        case ECreatorCalendarDelete:

            iEntriesToBeCreated = 1;

            showText = &KDeletingText;

            finished = ETrue;

            break;

        case ECreatorCalendarStart:

            if( iCommand == ECmdCreateCalendarEntryEvents || iCommand == ECmdCreateCalendarEntryAppointments )

                {

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

                retval = iEngine->GetEngineWrapper()->EntriesQueryDialog(&iNumberRepeatingEntries, KRepeatingNum, ETrue, this, ECreatorCalendarGetWeeklyEntries);

                }

            else

                {

                _LIT(KStartPeriodDate, "Start date of creation period");// \n dd/mm/yyyy

                retval = iEngine->GetEngineWrapper()->TimeQueryDialog(&iRandomModeStartTime, KStartPeriodDate, this, ECreatorCalendarGetStartDate); // ask start date

                }

            break;

        case ECreatorCalendarGetWeeklyEntries:

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

            retval = iEngine->GetEngineWrapper()->EntriesQueryDialog(&iNumberOfAttendees, KAttendeesNum, ETrue, this, ECreatorCalendarGetAttendies);

            break;

        case ECreatorCalendarGetAttendies:

            {

            // ask start date

            _LIT(KStartPeriodDate, "Start date of creation period");

            retval = iEngine->GetEngineWrapper()->TimeQueryDialog(&iRandomModeStartTime, KStartPeriodDate, this, ECreatorCalendarGetStartDate ); 

            }

            break;

        case ECreatorCalendarGetStartDate:

            {

            _LIT(KEndPeriodDate, "End date of creation period\n dd/mm/yyyy");

            iEngine->GetEngineWrapper()->TimeQueryDialog (&iRandomModeEndTime, KEndPeriodDate, this, ECreatorCalendarGetEndDate ); // ask end date

            }

            break;

        case ECreatorCalendarGetEndDate:

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

                {

                iEngine->GetEngineWrapper()->ShowNote(_L("End date must be after start date") );

                retval = EFalse;

                }

            else 

                {

                retval = iEngine->GetEngineWrapper()->YesNoQueryDialog(_L("Add default alarm?"), this, ECreatorCalendarAddDefaultAlarm);

                }

           break;

        case ECreatorCalendarAddDefaultAlarm:

            iSetAlarm = aPositiveAction;

            finished = ETrue;

            break;

        default:

            //some error

            retval = EFalse;

            break;

        }

    if( retval == EFalse )

        {

        iEngine->ShutDownEnginesL();

        }

    else if( finished )

        {

        // add this command to command array

        iEngine->AppendToCommandArrayL(iCommand, NULL, iEntriesToBeCreated);

        // started exucuting commands

        iEngine->ExecuteFirstCommandL( *showText );

        }

    }

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

TBool CCreatorInterimCalendar::AskDataFromUserL( TInt aCommand )

    {

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

    CCreatorModuleBase::AskDataFromUserL( aCommand );//ignore retval

    if( aCommand == ECmdDeleteCalendarEntries )

        {

        return iEngine->GetEngineWrapper()->YesNoQueryDialog(_L("Delete all calendar entries?"), this, ECreatorCalendarDelete );

        }

    if( aCommand == ECmdDeleteCreatorCalendarEntries )

        {

        return iEngine->GetEngineWrapper()->YesNoQueryDialog(_L("Delete all calendar entries created with Creator?"), this, ECreatorCalendarDelete ); 

        }

    // display queries

    return iEngine->GetEngineWrapper()->EntriesQueryDialog(&iEntriesToBeCreated, _L("How many entries to create?"), EFalse, this, ECreatorCalendarStart ); // ask number of entries to create

    }

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

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);

        }