/*
* 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:  Contact sorter
*
*/


// INCLUDE FILES
#include    "cvimpststoragecontactsorter.h"
#include    "mvimpststoragecontact.h"
#include    "tvimpstenums.h"
#include    "cvimpststoragedefs.h"
#include 	"vimpstdebugtrace.h"

// The order of contacts if sorted by status
const TInt KConstOnline  = 1;
const TInt KConstBusy	= 2;
const TInt KConstAway    = 3;
const TInt KConstServiceOut = 4;
const TInt KConstOnPhone = 5;
const TInt KConstInvisible = 6;
const TInt KConstOffline = 7;
const TInt KConstCallForward = 8;
const TInt KConstUnknown = 9;

// local functions 
// sorting algorithms, you can add new one to extend functionality


// Compares alphabetically using MVIMPSTStorageContact::Identification and 
// TDesC::CompareC
TInt CompareAlphabetically( const MVIMPSTStorageContact& aFirst, 
                           const MVIMPSTStorageContact& aSecond )
    {
    return aFirst.Name().CompareC( aSecond.Name(),
                                             KCollationLevel, NULL );
    }


// Group the contact by it's status. 
TInt OrderContact( const MVIMPSTStorageContact& aContact )
    {
     // Contact is not blocked, group by presence status
      switch( aContact.OnlineStatus() )
            {
            case TVIMPSTEnums::EOnline:
                {
                return KConstOnline;  // First group, contact is online
                }
            case TVIMPSTEnums::EDoNotDisturb:
			case TVIMPSTEnums::EBusy:
                {
                return KConstBusy;  // second group, contact is busy/donotdisturb
                }
			case TVIMPSTEnums::EOnPhone:
                {
                return KConstOnPhone;  //fifth group, contact is onphone
                }
			case TVIMPSTEnums::EInvisible:
                {
                return KConstInvisible;  // sixth group, contact is invisible
                }
            case TVIMPSTEnums::EAway:
                {
                return KConstAway;    // third group, contact is away
                }
            case TVIMPSTEnums::EOffline:
                {
                return KConstOffline; // seventh group, contact is offline
                }
			case TVIMPSTEnums::ECallForward:
			    {
			    return KConstCallForward; // eight group, contact state is callforward
			    }
            case TVIMPSTEnums::EServiceOut:
                {
                return KConstServiceOut;  // fourth group, contact is serviceout(has ony pstn or msisdn number)
                }
            default:
                {
                return KConstUnknown; //  unknown status
                }
            }
    }

// Compares by contact status, -1 = aFirst is greater, 1 = aSecond is greater.
TInt CompareByPresence( const MVIMPSTStorageContact& aFirst, 
                        const MVIMPSTStorageContact& aSecond )
    {
    TInt firstGroup( OrderContact( aFirst ) );
    TInt secondGroup( OrderContact( aSecond ) );

    // If both contacts belong to same group, sort alphabetically
    if( firstGroup == secondGroup )
        {
        return CompareAlphabetically( aFirst, aSecond );
        }
    
    // Otherwise return the difference of groups
    return firstGroup - secondGroup;
    }

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

// Two-phased constructor.
CVIMPSTStorageContactSorter* CVIMPSTStorageContactSorter::NewL() 
    {
    CVIMPSTStorageContactSorter* self = new( ELeave ) CVIMPSTStorageContactSorter();
    return self;
    }

// Destructor
CVIMPSTStorageContactSorter::~CVIMPSTStorageContactSorter()
    {
    TRACE( T_LIT("CVIMPSTStorageContactSorter::~CVIMPSTStorageContactSorter") );
    }

// ---------------------------------------------------------
// CVIMPSTStorageContactSorter::Sort( RPointerArray<MVIMPSTStorageContact>& aList )
// Sorts given array.
// ---------------------------------------------------------
//
void CVIMPSTStorageContactSorter::Sort( RPointerArray< MVIMPSTStorageContact >& aList )
    {
    TRACE( T_LIT("CVIMPSTStorageContactSorter::Sort() begin") );
    aList.Sort( iAlgorithm );
    TRACE( T_LIT("CVIMPSTStorageContactSorter::Sort() end") );
    }

// ---------------------------------------------------------
// CVIMPSTStorageContactSorter::Compare( const MVIMPSTStorageContact& aFirst, 
//                                  const MVIMPSTStorageContact& aSecond ) const
// Get function pointer from inside of TLinearOrder and 
// execute the function.
// ---------------------------------------------------------
//
TInt CVIMPSTStorageContactSorter::Compare( const MVIMPSTStorageContact& aFirst, 
                                    const MVIMPSTStorageContact& aSecond ) const
    {
    return iAlgorithm.operator TGeneralLinearOrder()( &aFirst, &aSecond );
    }

// C++ default constructor can NOT contain any code, that
// might leave.
// Default algorithm is alphabetic. It is changed later in ConstructL.
//
CVIMPSTStorageContactSorter::CVIMPSTStorageContactSorter() : 
    iAlgorithm( *CompareByPresence )
    {
    }
    
// ---------------------------------------------------------
// CVIMPSTStorageContactSorter::SetSortAlgorithm()
// Get setting item value and choose algorithm.
// New algorithms can be added to this method.
// ---------------------------------------------------------
//
void CVIMPSTStorageContactSorter::SetSortAlgorithm( 
                            MVIMPSTStorageContact::TSortAlgorithm aAlgorithm )
    {    
    switch( aAlgorithm )
            {
        case MVIMPSTStorageContact::ECompareByPresence: 
            {
            iAlgorithm = 
                  TLinearOrder< MVIMPSTStorageContact > ( *CompareByPresence );
            break;
            }

        case MVIMPSTStorageContact::ECompareAlphabetically: // flowthrough
        default : 
            {
            iAlgorithm = 
                  TLinearOrder< MVIMPSTStorageContact > ( *CompareAlphabetically );
            break;
            }
        }
    }

// ---------------------------------------------------------
// CVIMPSTStorageContactSorter::InsertOrder()
// Get setting item value and choose algorithm.
// New algorithms can be added to this method.
// ---------------------------------------------------------
//    
TLinearOrder< MVIMPSTStorageContact >& CVIMPSTStorageContactSorter::InsertOrder()
    {
    return iAlgorithm;
    }

// End of file