/*

* Copyright (c) 2002-2005 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: Implementation for meeting request processor 

*

*/

// INCLUDE FILES

#include "CMRProcessor.h"

#include "MRHelpers.h"

#include "mrdatalog.h"

#include "ICalUILogDef.h"

#include <e32std.h>

#include <calentry.h> 		//CCalEntry (Calendar entry API V2)

#include <caluser.h> 		//caluser and attendee

#include <MsgMailUIDs.h> 	//uid for mail application

#include <cemailaccounts.h>

#include <smtpset.h>

#include <imapset.h>

#include <pop3set.h>

#include <MuiuMsvUiServiceUtilities.h>

#include "MRViewersPanic.h" 			//panic codes

#include "meetingrequestviewers.hrh" 	//common constants

#include "ProcessingStructs.h" 			//scenario structures

#include <SendUiConsts.h> 				//mailbox uids

#include <stringloader.h> 				//loading of string resources

#include <meetingrequestviewersuires.rsg> 	//resource definitions header

#include <CalenInterimUtils2.h>

#include <cmrmailboxutils.h>

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

_LIT( KPanicMsg, "CMRProcessor" );

void Panic( TPanicCode aReason )

    {

    User::Panic( KPanicMsg, aReason );

    }

}  // namespace

// ============================ MEMBER FUNCTIONS ===============================

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

// CMRProcessor::CMRProcessor

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMRProcessor::CMRProcessor(

    CMRMailboxUtils& aMRMailboxUtils,

    CMRUtilsInternal& aMRUtils,

    const MAgnEntryUi::TAgnEntryUiInParams& aParams,

    RPointerArray<CCalEntry>& aEntries )

    : iMRMailboxUtils( aMRMailboxUtils ),

      iMRUtils( aMRUtils ),

      iEntryUiInParams( aParams ),

      iArrayOfEntries( aEntries ),

      iEditMode( MMRModelInterface::EModeNotSet ),

      iOwnerRole( ENotFound )

    {

	// set initial values to scenario data

	iCombinedScenData.iMethod = CCalEntry::EMethodNone;

	iCombinedScenData.iCallingApp = ENotSet;

	iCombinedScenData.iOpenedMailbox = ENotSet;

    iCombinedScenData.iUtilsDBResult = MMRUtilsTombsExt::EUndefined;		    	

    iCombinedScenData.iMethodLevelValidity = ENotSet;

	iCombinedScenData.iEditorMode = ENotSet;

    iCombinedScenData.iMROperation = ENotSet;    

	}

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

// CMRProcessor::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMRProcessor::ConstructL()

    {    

    }

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

// ?classname::NewL

// Two-phased constructor.

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

//

CMRProcessor* CMRProcessor::NewL(

    CMRMailboxUtils& aMRMailboxUtils,

    CMRUtilsInternal& aMRUtils,

    const MAgnEntryUi::TAgnEntryUiInParams& aParams,

    RPointerArray<CCalEntry>& aEntries )

    {

    CMRProcessor* self = new( ELeave ) CMRProcessor( aMRMailboxUtils,

                                                     aMRUtils,

                                                     aParams,

                                                     aEntries );

   CleanupStack::PushL( self );

   self->ConstructL();

   CleanupStack::Pop();

   return self;

   }

// Destructor

CMRProcessor::~CMRProcessor()

    {

    delete iCombinedEntry;

    }

CCalEntry* CMRProcessor::CombinedEntry()

	{

	// Should always be valid when this method is called

    __ASSERT_DEBUG( iCombinedEntry, Panic( ECombinedCalEntryNull ) );	

	return iCombinedEntry;

	}

void CMRProcessor::SetPhoneOwnerL()

    {

	__ASSERT_DEBUG( iArrayOfEntries.Count() > 0, Panic( EEmptyEntryArray ) );

    // set phone owner field of each entry:

    TInt count( iArrayOfEntries.Count() );

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

        {        

        CCalEntry& entry = *( iArrayOfEntries[i] );

        iMRMailboxUtils.SetPhoneOwnerL( entry, iEntryUiInParams.iMailBoxId );

        }

    // set iOwnerRole, use entry at index zero:

	CCalEntry& baseEntry = *( iArrayOfEntries[0] );	

	if ( iMRMailboxUtils.IsOrganizerL( baseEntry ) )

	    {

	    iOwnerRole = EOrganiser;

	    }	    

    else

        {        

	    CCalAttendee* thisAttendee = iMRMailboxUtils.ThisAttendeeL( baseEntry );

    	if ( thisAttendee )

    		{

    		switch ( thisAttendee->RoleL() )

    			{

    			case CCalAttendee::EOptParticipant:

    				{

    				iOwnerRole = EOptionalParticipant;

    				break;

    				}

    			case CCalAttendee::ENonParticipant:

    				{

    				iOwnerRole = ENonRequiredParticipant;

    				break;

    				}

                case CCalAttendee::EReqParticipant: // fall through

    			case CCalAttendee::EChair: // fall through

    			default:

    				{ // Note: chair MUST NOT be interpreted as organizer!

    				  // Req.participant is not correct either but has less

    				  // side effects.

    				iOwnerRole = ERequiredParticipant;

    				break;

    				}

    			}

    		}

        }

    }

CMRProcessor::TOwnerRole CMRProcessor::OwnerRole()

    {

    return iOwnerRole;

    }

MMRUtilsTombsExt::TMRUtilsDbResult CMRProcessor::ProcessingDbResult()

    {

    return iCombinedScenData.iUtilsDBResult;

    }

TInt CMRProcessor::ProcessingResultOp()

    {

    return iCombinedScenData.iMROperation;

    }

MMRModelInterface::TEditingMode CMRProcessor::EditingMode() const

    {

    return iEditMode;

    }

void CMRProcessor::SetEditingModeL( MMRModelInterface::TEditingMode aEditMode )

    {

    __ASSERT_DEBUG( iEditMode == MMRModelInterface::EModeNotSet,

                    Panic( EEditModeResetAttempt ) );    

    iEditMode = aEditMode;

    if ( aEditMode == MMRModelInterface::EEditMeeting )

        { // if we switch to edit meeting mode the combined entry must be re-set

        CCalEntry* entry = iArrayOfEntries[0];

        ResetCombinedEntryL( *entry, TCalTime() );                

		iCombinedEntry->CopyFromL( *entry );		

		iCombinedEntry->SetMethodL( entry->MethodL() );        

        }

    // no need to do anything if aEditMode == EEditInstance since that is the

    // default when launching the MR Viewer with incoming entry array.

    }

// TODO: CMRUtils::CheckEntryCondL doesn't, and shouldn't (because of e.g.

// calendar sync), notice problems with out-of-date entry (meeting occurred in past),

// but in processor we should identify that situation. Possibly add a new processing

// struct data field, and possibly a new TMROperation code also?

// TODO: somewhere we must set outparams: saved, meeting/instance deleted,

// but is processor a good place for it.     

// TODO: when handling processing leave, we must take care that iCombinedEntry

// is set to point to some entry, or to ensure that there doesn't become an access

// violation because someone is trying to access it.

void CMRProcessor::ProcessEntriesL()

	{

	if ( iArrayOfEntries.Count() < 1 )

	    {

	    User::Leave( KErrArgument );

	    }	    

    CCalEntry* entry = iArrayOfEntries[0];

    // Sets phone owner in entries and in iOwnerRole, this must be done at

    // early stage, before trying to read organizer or attendee fields

    SetPhoneOwnerL();

	// set common values to scenario data

	iCombinedScenData.iMethod = entry->MethodL();

	iCombinedScenData.iCallingApp = CallingApp();

	iCombinedScenData.iOpenedMailbox = OpenedMailboxL( *entry );

	iCombinedScenData.iEditorMode = EditorMode();

    if ( iCombinedScenData.iEditorMode == MAgnEntryUi::EViewEntry )

        { // in other cases editing mode will be decided later, but 

          // in EViewEntry case we know it already now

        SetEditingModeL( MMRModelInterface::EViewOnly );

        }

    TRAPD( err,

        {        

        if ( entry->MethodL() == CCalEntry::EMethodReply )

            {

            ProcessResponseArrayL();

            }        

        else 

            {        

            if ( iEntryUiInParams.iCallingApp.iUid == KUidCalendarApplication )

                {

                ProcessRequestInCalendarL();

                }

            else

                {

                ProcessRequestOrCancelArrayL();

                }

            }        

        } );

    if ( err != KErrNone )

        {

        ProcessErrorL();

        }            

	}

/**

* In case of calendar we show in start-up:

* a) parent entry if meeting non-repeating

* b) existing child entry if received as input

* c) newly created child if repeating meeting but child doesn't exist

* User may later on choose "edit series" mode if meeting is repeating.

*/

void CMRProcessor::ProcessRequestInCalendarL()

    {

	if ( iArrayOfEntries.Count() != 1 )

	    {

	    // From calendar we support only receiving single entry at a time

	    User::Leave( KErrArgument );

	    }

    CCalEntry* entry = iArrayOfEntries[0];

    iCombinedScenData.iMROperation =

        MatchScenarioToDataL( iCombinedScenData, *entry );

    if ( iCombinedScenData.iMROperation <= ENullOp )

        {

        User::Leave( KErrArgument );

        }    

    if ( MREntryConsultant::IsRepeatingMeetingL( *entry ) )

        {

        // reset combined entry, it will be a child representing the instance

        ResetCombinedEntryL( *entry, iEntryUiInParams.iInstanceDate );

        if ( MREntryConsultant::IsModifyingEntryL( *entry ) )

            { // entry exists for the instance, use that

    		iCombinedEntry->CopyFromL( *entry );		

    		iCombinedEntry->SetMethodL( entry->MethodL() );

            }

        else

            { // create a fully populated child representing the instance

            SetInstanceStartAndEndL( *iCombinedEntry,

                                     *entry, 

                                     iEntryUiInParams.iInstanceDate );                      

            CCalenInterimUtils2::PopulateChildFromParentL( *iCombinedEntry,

                                                           *entry );

            }

        }

    else

        { // non-repeating meeting -> view/edit entire meeting

        // reset combined entry, it will be a parent

        ResetCombinedEntryL( *entry, TCalTime() );                

		iCombinedEntry->CopyFromL( *entry );		

		iCombinedEntry->SetMethodL( entry->MethodL() );

		// in case of non-repeating meeting the editing mode is always

		// EEditMeeting and user doesn't have a possibility to change it

		SetEditingModeL( MMRModelInterface::EEditMeeting );     

        }    

    }

void CMRProcessor::ProcessResponseArrayL()

	{

// TODO: we must check that entry isn't out of date or cancelled,

// should we do that in HandleResponseStatusL or where? It would be

// better to do it before calling TryCreateModForResponseL() to avoid

// unnecessary mod entry in	db.

	// 1. Handle entry at index 0 ,it may be response to a parent or a child

	CCalEntry& response = *( iArrayOfEntries[0] );

	// when checking against db entry, respond should look like a valid update:

	iCombinedScenData.iUtilsDBResult = iMRUtils.CheckEntryCondL( response );

	// ...but if attendee has responded to an instance of a meeting, then

	// corresponding modifying entry doesn't necessarily exist -> create it:

	if ( iCombinedScenData.iUtilsDBResult == MMRUtilsTombsExt::ECheckedValidNew )

	    {	    

	    CreateModForResponseL( response, iCombinedScenData );

	    }

	// check response validity on method level and set status to request, if ok:

	CCalEntry* request = HandleResponseStatusL( response, iCombinedScenData );

	if ( request )

	    {

	    CleanupStack::PushL( request );

    	// match to scenario, entry to be updated is request, not response

        MatchScenarioAndSaveIfNeededL( *request, iCombinedScenData );

	    }

    else

        {

        // if request not found saving won't occur, we still perform matching

        // to get scenario completed, we give response as a parameter but it

        // won't be used in this case

        MatchScenarioAndSaveIfNeededL( response, iCombinedScenData );

        }

    // 2. Go through additional entries, they don't affect combined entry

    //    and related functionality

    TScenarioData tmpScenario( iCombinedScenData );

	TInt count( iArrayOfEntries.Count() );

	for ( TInt i( 1 ); i < count; ++i )

		{

		CCalEntry& tmpResponse = *( iArrayOfEntries[i] );

		tmpScenario.iUtilsDBResult = iMRUtils.CheckEntryCondL( tmpResponse );

	    if ( tmpScenario.iUtilsDBResult == MMRUtilsTombsExt::ECheckedValidNew )

	        {	    

	        CreateModForResponseL( response, tmpScenario );

	        }		

		CCalEntry* tmpRequest = HandleResponseStatusL( response, tmpScenario );

		if ( tmpRequest )

		    { // for additional entries we only match scenario if request exists,

		      // otherwise it is unnecessary

		    CleanupStack::PushL( tmpRequest );

		    MatchScenarioAndSaveIfNeededL( *tmpRequest, tmpScenario );

		    CleanupStack::PopAndDestroy( tmpRequest );

		    }

		}

    // 3. Set combined entry == first response possibly mixed with request

    ResetCombinedEntryL( response, response.RecurrenceIdL() );

    iCombinedEntry->CopyFromL( response );

    iCombinedEntry->SetMethodL( CCalEntry::EMethodReply );

	if ( iCombinedScenData.iMROperation == EUpdateStatusToCalendar )

		{

    	// TODO: set response summary with status information    	

    	iCombinedEntry->SetLocationL( request->LocationL() );

    	iCombinedEntry->SetStartAndEndTimeL( request->StartTimeL(),

    	                                     request->EndTimeL() );

        // Response won't necessarily contain RRule/RDate information, but

        // that isn't shown to the user either -> not needed in iCombinedEntry.

		}

    else

        {

        User::Leave( KErrArgument );

        }

    if ( request )

        {

        CleanupStack::PopAndDestroy( request );

        }

	}

/**

* This method assumes that response has been verified to be valid.

*/

void CMRProcessor::CreateModForResponseL(

    const CCalEntry& aResponse,

    TScenarioData& aScenarioData ) const

    {

    // fetch parent:

    CCalEntry* request = iMRUtils.FetchEntryL( aResponse.UidL(),

                                               TCalTime() );

    CleanupStack::PushL( request );

    // create modifying entry:

    HBufC8* modUid = request->UidL().AllocLC();

	CCalEntry* mod = CCalEntry::NewL( CCalEntry::EAppt,

                                      modUid,

                                      CCalEntry::EMethodRequest,

                                      request->SequenceNumberL(),

                                      aResponse.RecurrenceIdL(),

                                      CalCommon::EThisOnly );

    CleanupStack::Pop( modUid ); // ownership transferred

    CleanupStack::PushL( mod );

    // In this case response shouldn't really have any RRules or RDates,

    // and the recurrence id should specify the instance which attendee

    // responded to. Therefore create modifying entry representing that

    // instance.

    SetInstanceStartAndEndL( *mod, *request, aResponse.RecurrenceIdL() );

    // Populate modifying entry fields, especially it is important that

    // also entire attendee list gets copied, since this modifying entry

    // will be exceptioned in the parent

    CCalenInterimUtils2::PopulateChildFromParentL( *mod, *request );

    // Modifying entry must have the same DTSTAMP as originating entry,

    // since in this case they were sent as one request

    mod->SetDTStampL( request->DTStampL() );        

    // Set modifying request as sent!

    // TODO: this will be done differently when Symbian supports other fields

    // to indicate sending status

    mod->SetStatusL( CCalEntry::EConfirmed );

    MMRUtilsTombsExt::TMRUtilsDbResult res = iMRUtils.StoreL( *mod, EFalse );

    if ( res != MMRUtilsTombsExt::EStoredUpdate )

        { // store should succeed if response was for a valid instance

        User::Leave( KErrGeneral );

        }

    CleanupStack::PopAndDestroy( 2 ); // mod, request

    // now there exists a modifying entry and response is

    // an update to it:

    aScenarioData.iUtilsDBResult = MMRUtilsTombsExt::ECheckedValidUpdate;

    }

CCalEntry* CMRProcessor::HandleResponseStatusL(

    const CCalEntry& aResponse,

    TScenarioData& aScenarioData ) const

    {

    aScenarioData.iMethodLevelValidity = EInvalid;

    if ( aResponse.AttendeesL().Count() != 1 )

        { // response MUST have exactly one attendee, the respondent

        User::Leave( KErrArgument );

        }

	CCalAttendee& respondent = *( aResponse.AttendeesL()[0] );	

    CCalEntry* request = iMRUtils.FetchEntryL( aResponse.UidL(),

                                               aResponse.RecurrenceIdL() );

    if ( request  )

        {

        CleanupStack::PushL( request );        	

    	TBool changed( EFalse );

    	CCalAttendee* dbAttendee =

    	    RespondentInRequestL( aResponse, *request, changed );

    	if ( dbAttendee && changed )

    		{

    		dbAttendee->SetStatusL( respondent.StatusL() );

    		aScenarioData.iMethodLevelValidity = EValidNeedsSave;

    		}

        else if ( dbAttendee && !changed )

            {

            aScenarioData.iMethodLevelValidity = EValidNoNeedSave;

            }

        CleanupStack::Pop( request );

        }

    return request; // may be NULL

    }

/**

* We always show the first entry, if it is a child user will see that

* child and responses affect that (and other children in the array)

* If the first entry is a parent responses affect also children in the array.

*

* Also in case of cancellation entry is stored to db instead of just updating

* the status, this means that e.g. description may be changed, but we

* consider that is the desired behavior.

*/

void CMRProcessor::ProcessRequestOrCancelArrayL()

	{

	// 1. Handle entry at index 0 ,it may be a parent or a child	

	CCalEntry& entry = *( iArrayOfEntries[0] );

	iCombinedScenData.iUtilsDBResult = iMRUtils.CheckEntryCondL( entry );

    MatchScenarioAndSaveIfNeededL( entry, iCombinedScenData );

    // 2. Go through additional entries, they don't affect combined entry

    //    and related functionality

    TScenarioData tmpScenario( iCombinedScenData );

	TInt count( iArrayOfEntries.Count() );

	for ( TInt i( 1 ); i < count; ++i )

		{

		CCalEntry& tmpEntry = *( iArrayOfEntries[i] );