/*
* Copyright (c) 2007-2009 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:  MR user utility class implementation
*
*/


#include "emailtrace.h"
#include "cesmrcaluserutil.h"
//<cmail>
#include "esmrdef.h"
//</cmail>
#include <calentry.h>
#include <caluser.h>

namespace { // codescanner::namespace

// Definition for 0
const TInt KZero = 0;

// Definition for number of hours within day
const TInt KHoursInDay = 24;

} // namespace

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

// ---------------------------------------------------------------------------
// CESMRCalUserUtil::CESMRCalUserUtil
// ---------------------------------------------------------------------------
//
inline CESMRCalUserUtil::CESMRCalUserUtil(
        CCalEntry& aEntry )
:   iEntry( aEntry )
    {
    FUNC_LOG;
    //do nothing
    }

// ---------------------------------------------------------------------------
// CESMRCalUserUtil::~CESMRCalUserUtil
// ---------------------------------------------------------------------------
//
EXPORT_C CESMRCalUserUtil::~CESMRCalUserUtil()
    {
    FUNC_LOG;
    //do nothing
    }

// ---------------------------------------------------------------------------
// CESMRCalUserUtil::NewL
// ---------------------------------------------------------------------------
//
EXPORT_C CESMRCalUserUtil* CESMRCalUserUtil::NewL(
             CCalEntry& aEntry )
     {
    FUNC_LOG;
     CESMRCalUserUtil* self = NewLC( aEntry );
     CleanupStack::Pop( self );
     return self;
     }

// ---------------------------------------------------------------------------
// CESMRCalUserUtil::NewLC
// ---------------------------------------------------------------------------
//
EXPORT_C CESMRCalUserUtil* CESMRCalUserUtil::NewLC(
             CCalEntry& aEntry )
     {
    FUNC_LOG;
     CESMRCalUserUtil* self = new (ELeave) CESMRCalUserUtil( aEntry );
     CleanupStack::PushL( self );
     self->ConstructL();
     return self;
     }

// ---------------------------------------------------------------------------
// CESMRCalUserUtil::ConstructL
// ---------------------------------------------------------------------------
//
void CESMRCalUserUtil::ConstructL()
    {
    FUNC_LOG;
    //do nothing
    }

// ---------------------------------------------------------------------------
// CESMRCalUserUtil::GetAttendeesL
// ---------------------------------------------------------------------------
//
EXPORT_C void CESMRCalUserUtil::GetAttendeesL(
        RArray<CCalAttendee*>& aAttendeeArray,
        TUint aFilterFlags ) const
    {
    FUNC_LOG;

    aAttendeeArray.Reset();
    RPointerArray<CCalAttendee>& attendees = iEntry.AttendeesL();

    TBool includeRequired( EESMRRoleRequiredAttendee & aFilterFlags);
    TBool includeOptional( EESMRRoleOptionalAttendee & aFilterFlags);

    TInt attendeeCount( attendees.Count() );
    for (TInt i(0); i < attendeeCount; ++i )
        {
        CCalAttendee* attendee = attendees[i];
        CCalAttendee::TCalRole role(
                 attendee->RoleL() );

        TPtrC cn( attendee->CommonName() );
        TPtrC ad( attendee->Address() );

        if ( includeRequired &&
             CCalAttendee::EReqParticipant == role )
            {
            aAttendeeArray.Append(attendee);
            }
        else if ( includeRequired &&
                  CCalAttendee::EChair == role )
            {
            aAttendeeArray.Append(attendee);
            }
        else if ( includeOptional &&
                  CCalAttendee::EOptParticipant == role )
            {
            aAttendeeArray.Append(attendee);
            }
        }

    }

// ---------------------------------------------------------------------------
// CESMRCalUserUtil::PhoneOwnerAttendeeRoleL
// ---------------------------------------------------------------------------
//
EXPORT_C TESMRRole CESMRCalUserUtil::PhoneOwnerRoleL() const
    {
    FUNC_LOG;
    
    TESMRRole role = EESMRRoleUndef;
    CCalUser* phoneOwner = iEntry.PhoneOwnerL();
    RPointerArray<CCalAttendee>& attendees = iEntry.AttendeesL();

    if ( phoneOwner )
        {
        CCalUser* organizer = iEntry.OrganizerL();

        if( phoneOwner && phoneOwner == organizer )
            {
            role = EESMRRoleOrganizer;
            }
        else
            {
            CCalAttendee* thisAttendee = NULL;
            TInt attendeeCount( attendees.Count() );
            for ( TInt i(0); (i < attendeeCount) && !thisAttendee; ++i )
                {
                if ( phoneOwner && phoneOwner == attendees[i] )
                    {
                    thisAttendee = attendees[i];
                    }
                }

            if ( thisAttendee )
                {
                switch( thisAttendee->RoleL() )
                    {
                    case CCalAttendee::EChair://fallthrough
                    case CCalAttendee::EReqParticipant:
                        {
                        role = EESMRRoleRequiredAttendee;
                        }
                        break;
                    case CCalAttendee::EOptParticipant:
                        {
                        role = EESMRRoleOptionalAttendee;
                        }
                        break;
                    case CCalAttendee::ENonParticipant:
                        {
                        role = EESMRRoleNonParticipant;
                        }
                        break;
                    default:
                        {
                        role = EESMRRoleUndef;
                        }
                        break;
                    }
                }
            }
        }
    
    return role;
    }

// ---------------------------------------------------------------------------
// CESMRCalUserUtil::IsAlldayEventL
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CESMRCalUserUtil::IsAlldayEventL() const
    {
    FUNC_LOG;
    
    TBool allDayEvent(EFalse);

    TCalTime startTime = iEntry.StartTimeL();
    TCalTime stopTime  = iEntry.EndTimeL();

    TTimeIntervalHours hoursBetweenStartAndEnd;
    stopTime.TimeLocalL().HoursFrom(
            startTime.TimeLocalL(),
            hoursBetweenStartAndEnd );

    TCalTime::TTimeMode mode = startTime.TimeMode();

    TInt hoursBetweenStartAndEndAsInt(  hoursBetweenStartAndEnd.Int() );
    TInt alldayDivident(  hoursBetweenStartAndEndAsInt % KHoursInDay );

    TDateTime startTimeLocal = startTime.TimeLocalL().DateTime();
    TDateTime stopTimeLocal =  stopTime.TimeLocalL().DateTime();
    
    if ( hoursBetweenStartAndEndAsInt && KZero == alldayDivident )
        {
        if ( startTimeLocal.Hour() == stopTimeLocal.Hour() &&
             startTimeLocal.Minute() == stopTimeLocal.Minute() &&
             startTimeLocal.Second() == stopTimeLocal.Second() )
            {
            allDayEvent = ETrue;
            }
        }
    
    return allDayEvent;
    }

// EOF