/*
* 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:   The source file for the CClockTimeZoneResolverImpl class.
*
*/

// System includes
#include <tzlocalizer.h>

// User includes
#include "clocktimezoneresolverimpl.h"
#include "clockmcctzmapper.h"
#include "clocktimezoneresolver.h"
#include "clock_debug.h"

// Constants
const TInt KMinute( 60 );     // Seconds
const TInt KZerothRule( 0 );
const TInt KOne( 1 );

// Literals
_LIT( KDefault, "default" );

// ---------------------------------------------------------------------------
// CClockTimeZoneResolverImpl::NewL
// rest of the details are commented in the header
// ---------------------------------------------------------------------------
//
CClockTimeZoneResolverImpl* CClockTimeZoneResolverImpl::NewL()
	{
	__PRINTS( "CClockTimeZoneResolverImpl::NewL - Entry" );
	
	CClockTimeZoneResolverImpl* self = new ( ELeave ) CClockTimeZoneResolverImpl();
	CleanupStack::PushL( self );
	
	self->ConstructL();
	
	CleanupStack::Pop();
	
	__PRINTS( "CClockTimeZoneResolverImpl::NewL - Exit" );
	
	return self;
	}
	
// ---------------------------------------------------------
// CClockTimeZoneResolverImpl::~CClockTimeZoneResolverImpl
// rest of the details are commented in the header
// ---------------------------------------------------------
//
CClockTimeZoneResolverImpl::~CClockTimeZoneResolverImpl()
	{
	__PRINTS( "CClockTimeZoneResolverImpl::~CClockTimeZoneResolverImpl - Entry" );
	
	if( iMccTzIdMapper )
		{
		delete iMccTzIdMapper;
		iMccTzIdMapper = NULL;
		}
		
	iRtz.Close();
	
	iTempZoneIds.ResetAndDestroy();
		
	__PRINTS( "CClockTimeZoneResolverImpl::~CClockTimeZoneResolverImpl - Exit" );
	}
	
// ---------------------------------------------------------
// CClockTimeZoneResolverImpl::CClockTimeZoneResolverImpl
// rest of the details are commented in the header
// ---------------------------------------------------------
//	
CClockTimeZoneResolverImpl::CClockTimeZoneResolverImpl()
	{
	__PRINTS( "CClockTimeZoneResolverImpl::CClockTimeZoneResolverImpl - Entry" );
	
	// No implementation yet
	
	__PRINTS( "CClockTimeZoneResolverImpl::CClockTimeZoneResolverImpl - Exit" );
	}
	
// ---------------------------------------------------------
// CClockTimeZoneResolverImpl::ConstructL
// rest of the details are commented in the header
// ---------------------------------------------------------
//
void CClockTimeZoneResolverImpl::ConstructL()
	{
	__PRINTS( "CClockTimeZoneResolverImpl::ConstructL - Entry" );
	
	iMccTzIdMapper = CClockMCCTzIdMapper::NewL();
	
	User::LeaveIfError( iRtz.Connect() );
	iRtz.SetAutoUpdateBehaviorL( RTz::ETZAutoDSTUpdateOn );
	
	__PRINTS( "CClockTimeZoneResolverImpl::ConstructL - Exit" );
	}
	
// ---------------------------------------------------------
// CClockTimeZoneResolverImpl::GetTimeZoneL
// rest of the details are commented in the header
// ---------------------------------------------------------
//
TInt CClockTimeZoneResolverImpl::GetTimeZoneL( const STimeAttributes& aTimeInfo, 
										  	   const RMobilePhone::TMobilePhoneNetworkCountryCode& aMcc,
										  	   TInt& aTzId )
	{
	__PRINTS( "CClockTimeZoneResolverImpl::GetTimeZoneL - Entry" );
	
	__PRINTS( "CClockTimeZoneResolverImpl::GetTimeZoneL - Exit" );
	
	// Try and find a DST zone Id that has current MCC and this UTC offset. 
    return FindDstZoneIdFromMccAndUtcOffsetL( aTimeInfo, aMcc, aTzId );
	}

// ---------------------------------------------------------
// CClockTimeZoneResolverImpl::TzIdFromMccL
// rest of the details are commented in the header
// ---------------------------------------------------------
//
void CClockTimeZoneResolverImpl::TzIdFromMccL( const RMobilePhone::TMobilePhoneNetworkCountryCode& aMCC,
									  		   RArray< CTzId >& aTzIdArray,
									  		   const TTimeIntervalMinutes& aStdTimeOffset )
	{
	__PRINTS( "CClockTimeZoneResolverImpl::TzIdFromMccL - Entry" );
	
	iMccTzIdMapper->TzIdFromMccL( aMCC, aTzIdArray, aStdTimeOffset );
	
	__PRINTS( "CClockTimeZoneResolverImpl::TzIdFromMccL - Exit" );
	}

// ---------------------------------------------------------
// CClockTimeZoneResolverImpl::MCCFromTzIdL
// rest of the details are commented in the header
// ---------------------------------------------------------
//
TInt CClockTimeZoneResolverImpl::MCCFromTzIdL( const CTzId& aTzId )
	{
	__PRINTS( "CClockTimeZoneResolverImpl::MCCFromTzIdL - Entry" );
	
	__PRINTS( "CClockTimeZoneResolverImpl::MCCFromTzIdL - Exit" );
	
	return iMccTzIdMapper->MCCFromTzIdL( aTzId );
	}

// ---------------------------------------------------------
// CClockTimeZoneResolverImpl::FindDstZoneIdFromMccAndUtcOffsetL
// rest of the details are commented in the header
// ---------------------------------------------------------
//
TInt CClockTimeZoneResolverImpl::FindDstZoneIdFromMccAndUtcOffsetL( const STimeAttributes& aTimeInfo, 
																	const RMobilePhone::TMobilePhoneNetworkCountryCode& aMcc,
										  							TInt& aTzId )
	{
	__PRINTS( "CClockTimeZoneResolverImpl::FindDstZoneIdFromMccAndUtcOffsetL - Entry" );
	
	// Check if MCC is not available, in which case aMcc will be sent as 9999. 
	// Try to narrow down to the timezone ID using the offset that we have got in aTimeInfo.
	const TBuf< 4 > invalidMCC( KInvalidMCC );
	
	if( invalidMCC == aMcc &&  aTimeInfo.iTimeZoneOffset != TTimeIntervalMinutes( KErrNotFound ) )
		{
		__PRINTS( "CClockTimeZoneResolverImpl::FindDstZoneIdFromMccAndUtcOffsetL - Exit" );
		
		// Try to find if we can narrow down to a timezone ID with just the offset.
		return GetTimeZoneIdWithOffsetL( aTimeInfo.iTimeZoneOffset, aTzId );
		}
	
	// Check if we can find any zones for the given MCC even though we dont have a valid
	// timezone offset. If so, set the timezone in case of countries with single zone.
	if( aTimeInfo.iTimeZoneOffset == TTimeIntervalMinutes( KErrNotFound ) )
		{		
		__PRINTS( "CClockTimeZoneResolverImpl::FindDstZoneIdFromMccAndUtcOffsetL - Exit" );
		
		return GetTimeZoneIdWithMccL( aMcc, aTimeInfo.iTimeZoneOffset, aTzId );
		}

    // Calculate timezone offset.
    TTimeIntervalSeconds tzOffsetSec(0);
    
    if( KErrNotFound != aTimeInfo.iTimeZoneOffset.Int() )
    	{
    	tzOffsetSec=(aTimeInfo.iTimeZoneOffset.Int() * KMinute );
    	}
    
    // Calculate dst offset.
    TTimeIntervalSeconds dstOffsetSec(0);
    
    if( KErrNotFound != aTimeInfo.iDstOffset.Int() )
    	{
    	dstOffsetSec=( aTimeInfo.iDstOffset.Int() * KMinute );
    	}
    
    // Time sent by nw is UTC
    TTime nwUtcTime( aTimeInfo.iUtcDateTime );

    // Calculate local time => UTC time + timzone offset + DST offset
    TTime nwLocalTime( nwUtcTime + tzOffsetSec + dstOffsetSec );
	

	// Create array we we store all localized zones
    CTzLocalizedTimeZoneArray* locTimeZones = CTzLocalizedTimeZoneArray::NewL();
    CleanupStack::PushL( locTimeZones );
    
    // Create array of CTzID to store all unlocalized zones
    RArray<CTzId> tzArray;
    CleanupClosePushL(tzArray);

    // Get the unlocalized zones based on the utc offset and mcc we have.
    GetAllUnLocalizedZonesL( aMcc, aTimeInfo.iTimeZoneOffset, tzArray );
    
    // Make sure old stuff is deleted.
    iTempZoneIds.ResetAndDestroy();

    // Try to find a truly matching zone.
    FindMatchingUnLocalizedZoneL( tzArray, iTempZoneIds,nwLocalTime, nwUtcTime );
       
    CleanupStack::PopAndDestroy(1, &tzArray);   
    
    if( KErrNone == iTempZoneIds.Count() )
    	{
    	// Get the localized zones based on the utc offset and mcc we have
    	GetLocalizedZonesL( aMcc, aTimeInfo.iTimeZoneOffset, *locTimeZones );

    	// If we have no localised zones and network supports DST, we have done everything right, 
    	// OR if UTC offset is invalid and we have a multizone country, we can do nothing.
    
    	TInt returnVal( GetCorrectZone( *locTimeZones, aTimeInfo.iTimeZoneOffset, aTimeInfo.iDstOffset, aTzId ) );
    		
    	if( KErrNotFound == aTzId || KErrNone == returnVal )
    		{
    		__PRINTS( "CClockTimeZoneResolverImpl::FindDstZoneIdFromMccAndUtcOffsetL - Exit" );
		
    		return returnVal;
    		}
    		    	
    	// Make sure old stuff is deleted.
    	iTempZoneIds.ResetAndDestroy();

    	// Try to find a truly matching zone.
    	FindMatchingLocalisedZoneL( *locTimeZones, iTempZoneIds, nwLocalTime, nwUtcTime );

    	// nitz improvement for spreading UTC offset start/

    	// If no matches found and DST indication is not supported by the NW,
    	// we need to subtract one DST offset amount from the UTC offset
    	// and see if that gives us any zones. 
    	// This is for cases when operators dont send the DST section of a nitz
    	// even when it is included in the utc offset.

    	if ( KErrNone == iTempZoneIds.Count() && ( KErrNotFound == aTimeInfo.iDstOffset.Int() ) ) 
    		{
    		TTimeIntervalMinutes tempUtcOffset( 0 );
    		RArray< CTzId > aTzIdArray;
    		CleanupClosePushL( aTzIdArray );

    		// Convert the TMobilePhoneNetworkCountryCode to a TInt
    		TInt mcc;
    		TLex lex( aMcc );
    		User::LeaveIfError( lex.Val( mcc ) );

    		// Get the DST zones within this country code
    		iMccTzIdMapper->DoGetTzIdFromMCCL( mcc, aTzIdArray );

    		CTzLocalizedTimeZoneArray* spreadLocTimeZones = CTzLocalizedTimeZoneArray::NewL();
    		CleanupStack::PushL( spreadLocTimeZones );
    		TInt32 dstOffsetInt = 0;
    		TInt32 tmpUtcOffset = 0;
    		TInt32 dstOffsetOld = -1;

    		for( TInt i( 0 ) ; i < aTzIdArray.Count(); i++ )
    			{
    			// Get the StdOffset and DstOffset values for every time zone.
    			// Use each new value of StdOffset to find matching LocalTimeZones
    			GetStdOffSetAndDstOffSetL( dstOffsetInt, tmpUtcOffset, aTzIdArray[ i ] );
    			if( dstOffsetOld != dstOffsetInt )
    				{
    				dstOffsetOld = dstOffsetInt;
    				}
    			else
    				{
    				continue;
    				}

    			tmpUtcOffset = aTimeInfo.iTimeZoneOffset.Int() - dstOffsetInt;
    			GetLocalizedZonesL( aMcc, tmpUtcOffset, *spreadLocTimeZones );
    			FindMatchingLocalisedZoneL( *spreadLocTimeZones, iTempZoneIds, nwLocalTime, nwUtcTime );  
    			}

    		CleanupStack::PopAndDestroy( spreadLocTimeZones );
    		CleanupStack::PopAndDestroy( &aTzIdArray );
    		}    
    	// nitz improvement for spreading UTC offset end
    	}
      
   
    TInt returnValue ( GetMatchingZonesL( locTimeZones, aTzId ) );
    
    if ( KErrNone == returnValue )
    {
    __PRINTS( "CClockTimeZoneResolverImpl::FindDstZoneIdFromMccAndUtcOffsetL - Exit" );
    
    return returnValue;
    }

    // If there are more than one matching unlocalized cities and zero localized cities
    // set to any one of the unlocalized cities.
    __PRINTS( "CClockTimeZoneResolverImpl::FindDstZoneIdFromMccAndUtcOffsetL - Exit" );
    
    return ProcessMatchingZones( *locTimeZones, aTzId );
    }
    
// ---------------------------------------------------------
// CClockTimeZoneResolverImpl::GetLocalizedZonesL
// rest of the details are commented in the header
// ---------------------------------------------------------
//
void CClockTimeZoneResolverImpl::GetLocalizedZonesL( const RMobilePhone::TMobilePhoneNetworkCountryCode& aMcc,
                                            		 const TTimeIntervalMinutes& aTimezoneOffset,                                            
                                            		 CTzLocalizedTimeZoneArray& aTzLocalisedArray )
    {
    __PRINTS( "CClockTimeZoneResolverImpl::GetLocalizedZonesL - Entry" );
    
    RArray< CTzId > tzArray;
    CleanupClosePushL( tzArray );
  
    // Get the DST zones within this country code
    iMccTzIdMapper->TzIdFromMccL( aMcc, tzArray, aTimezoneOffset );
        
    // If there is no DST zones for this MCC in our database, we can do nothing.
    if( tzArray.Count() == 0 ) 
		{
	    CleanupStack::PopAndDestroy( &tzArray );
	    
	    __PRINTS( "CClockTimeZoneResolverImpl::GetLocalizedZonesL - Exit" );
	    
        return;
		}

    CTzLocalizedTimeZone* timezone( NULL );
    
    // Create the localizer component
    CTzLocalizer* localizer = CTzLocalizer::NewL(); 
    CleanupStack::PushL( localizer );
    
    // Loop through the returned DST zone Ids picking the ones that have 
    // a corresponding localized timezone
    for( TInt index = 0 ; index < tzArray.Count() ; index++) 		
		{
        TRAPD( error, timezone = localizer->GetLocalizedTimeZoneL( tzArray[ index ].TimeZoneNumericID() ) );
        if( !error )
            {
            if( timezone ) 
                {
                aTzLocalisedArray.AppendL( timezone );
                }			
            }
		}
    
    CleanupStack::PopAndDestroy( 2, &tzArray );
    
    __PRINTS( "CClockTimeZoneResolverImpl::GetLocalizedZonesL - Exit" );
    }

// ---------------------------------------------------------
// CClockTimeZoneResolverImpl::FindMatchingLocalisedZoneL
// rest of the details are commented in the header
// ---------------------------------------------------------
//
void CClockTimeZoneResolverImpl::FindMatchingLocalisedZoneL( CTzLocalizedTimeZoneArray& aLocTimeZones, 
                                           	            	 RPointerArray< CTzId >& aZoneIdArray, 
                                                        	 TTime& aNwLocalTime, 
                                                        	 TTime& aNwUtcTime )
    {
    __PRINTS( "CClockTimeZoneResolverImpl::FindMatchingLocalisedZoneL - Entry" );
    
    CTzConverter* tempCTzConv = CTzConverter::NewL( iRtz );
    CleanupStack::PushL( tempCTzConv );
 
    // Try to find a matching time from the list of localised timezones
    for( TInt index = 0 ; index < aLocTimeZones.Count() ; index++ )
        {            
        CTzId* tempTzId = CTzId::NewL( aLocTimeZones.At( index ).TimeZoneId() );
        CleanupStack::PushL( tempTzId );
        
        TTime tempTime = aNwUtcTime;            
        User::LeaveIfError( tempCTzConv->ConvertToLocalTime( tempTime,*tempTzId ) );
        if( tempTime == aNwLocalTime )
            {            
            aZoneIdArray.AppendL( tempTzId );
            CleanupStack::Pop( tempTzId );
            }
        else
            {
            CleanupStack::PopAndDestroy( tempTzId );
            }           
        }
    
    CleanupStack::PopAndDestroy( tempCTzConv );
    
    __PRINTS( "CClockTimeZoneResolverImpl::FindMatchingLocalisedZoneL - Exit" );
    }
    
// ---------------------------------------------------------
// CClockTimeZoneResolverImpl::GetAllUnLocalizedZonesL
// rest of the details are commented in the header
// ---------------------------------------------------------
//
void CClockTimeZoneResolverImpl::GetAllUnLocalizedZonesL( const RMobilePhone::TMobilePhoneNetworkCountryCode& aMcc,
                                            			  const TTimeIntervalMinutes& aTimezoneOffset,                                                                                        
                                           				  RArray< CTzId >& aTzUnLocalizedArray )
    {      
    __PRINTS( "CClockTimeZoneResolverImpl::GetAllUnLocalizedZonesL - Entry" );
        
    // Get the DST zones within this country code
    iMccTzIdMapper->TzIdFromMccL( aMcc,aTzUnLocalizedArray,aTimezoneOffset);
    
    __PRINTS( "CClockTimeZoneResolverImpl::GetAllUnLocalizedZonesL - Exit" );
    }

// ---------------------------------------------------------
// CClockTimeZoneResolverImpl::FindMatchingUnLocalizedZoneL
// rest of the details are commented in the header
// ---------------------------------------------------------
//
void CClockTimeZoneResolverImpl::FindMatchingUnLocalizedZoneL( RArray< CTzId >& aUnLocalizedTzArray, 
                                           					   RPointerArray< CTzId >& aZoneIdArray, 
                                           					   TTime& aNwLocalTime, 
                                           					   TTime& aNwUtcTime)
    {
	__PRINTS( "CClockTimeZoneResolverImpl::FindMatchingUnLocalizedZoneL - Entry" );

	CTzConverter* tempCTzConv = CTzConverter::NewL(iRtz);
	CleanupStack::PushL(tempCTzConv);

	// Try to find a matching time from the list of timezones
	for (TInt index( 0 ); index < aUnLocalizedTzArray.Count(); index++)
		{                    

		CTzId* tempTzId = CTzId::NewL( aUnLocalizedTzArray[ index ].TimeZoneNumericID() );
		CleanupStack::PushL( tempTzId );
		TTime tempTime = aNwUtcTime;   

		//Convert the zone time of the city to local time in microseconds                  
		User::LeaveIfError( tempCTzConv->ConvertToLocalTime(tempTime,*tempTzId) );

		//If the networklocal time and unlocalised city time from TZ rules 
		//are same, add it to list
		if( tempTime == aNwLocalTime )
			{            
			aZoneIdArray.AppendL( tempTzId );
			CleanupStack::Pop( tempTzId );
			}
		else
			{
			CleanupStack::PopAndDestroy( tempTzId );
			}           
		}

	CleanupStack::PopAndDestroy( tempCTzConv );
    
    __PRINTS( "CClockTimeZoneResolverImpl::FindMatchingUnLocalizedZoneL - Exit" );
	}

// ---------------------------------------------------------
// CClockTimeZoneResolverImpl::GetStdOffSetAndDstOffSetL
// rest of the details are commented in the header
// ---------------------------------------------------------
//
void CClockTimeZoneResolverImpl::GetStdOffSetAndDstOffSetL( TInt32& aDstOffset,
													   		TInt32& aStdOffset,
													   		const CTzId& aTzId )
    {
	__PRINTS( "CClockTimeZoneResolverImpl::GetStdOffSetAndDstOffSetL - Entry" );   
	
	// Local time
    TTime homeTime;
    homeTime.HomeTime();    
    
    TDateTime dateTime;
    dateTime = homeTime.DateTime();
    
	// Get the CTzRules for the current year and for the given time zone id.
    CTzRules* tzRules = iRtz.GetTimeZoneRulesL( aTzId, 
    										    dateTime.Year(), 
    										    dateTime.Year(), 
    										    ETzWallTimeReference );
	CleanupStack::PushL( tzRules );
    
	// Get the Actualised rules for the same year. These are the DST rules from which we get the iNewOffset.
    CVTzActualisedRules *vActualisedRules = CVTzActualisedRules::NewL(
													homeTime.DateTime().Year(), 
													homeTime.DateTime().Year() );
	CleanupStack::PushL( vActualisedRules );
	tzRules->GetActualisedRulesL( *vActualisedRules );
	
	// The initial offset or the standard offset (w/o DST)
	TInt32 initialTimeZoneOffset = tzRules->InitialStdTimeOffset();
	
	// The number of actualised rules
	TInt ruleCount = vActualisedRules->Count();
	
	for( TInt ruleIndex( KZerothRule ); ruleIndex < ruleCount; ruleIndex++ )
		{
		const TVTzActualisedRule& tVTzactRule = ( *vActualisedRules )[ ruleIndex ];
		
		// If the standard offset and the new offset do not match then we have a dst offset.
		// Technically if a timezone has DST then it can have a max of two offsets. One is the standard which doesn't show the 
		// DST usage, and the other is the DST offset which is standard offset + the amount of DST
		if( initialTimeZoneOffset != tVTzactRule.iNewOffset )
			{
			aDstOffset = tVTzactRule.iNewOffset - initialTimeZoneOffset;
			aStdOffset = initialTimeZoneOffset;
			CleanupStack::PopAndDestroy( vActualisedRules );
			CleanupStack::PopAndDestroy( tzRules );
			
			__PRINTS( "CClockTimeZoneResolverImpl::GetStdOffSetAndDstOffSetL - Exit" );
	
			return;
			}
		}
	__PRINTS( "CClockTimeZoneResolverImpl::GetStdOffSetAndDstOffSetL - Exit" );	

    CleanupStack::PopAndDestroy( vActualisedRules );
	CleanupStack::PopAndDestroy( tzRules );
	}

// ---------------------------------------------------------------------------
// CClockTimeZoneResolverImpl::GetTimeZoneIdWithOffsetL
// rest of the details commented in the header
// ---------------------------------------------------------------------------
//
TInt CClockTimeZoneResolverImpl::GetTimeZoneIdWithOffsetL( const TTimeIntervalMinutes& aTzOffset, TInt& aTzId )
	{
	__PRINTS( "CClockTimeZoneResolverImpl::GetTimeZoneIdWithOffsetL() - Entry" );
	
	TInt retVal( KErrNotFound );
	
	RArray< CTzId > tzIdArray;
	CleanupClosePushL( tzIdArray );
	
	iMccTzIdMapper->TzIdFromOffsetL( aTzOffset, tzIdArray );
	
	if( KOne < tzIdArray.Count() )	
		{
		// For a multizone country without NITZ, it is not possible to 
		// calculate the TZ.
		aTzId = KErrNotFound;					
		}
	else if( KOne == tzIdArray.Count() )
		{
		// For a single zone country, without NITZ, set the default TZ
		aTzId = tzIdArray[ KErrNone ].TimeZoneNumericID();		 	
		retVal = KErrNone;
		}
	
	CleanupStack::PopAndDestroy();
	
	__PRINTS( "CClockTimeZoneResolverImpl::GetTimeZoneIdWithOffsetL() - Exit" );
	
	return retVal;
	}
    
// ---------------------------------------------------------------------------
// CClockTimeZoneResolverImpl::GetTimeZoneIdWithMccL
// rest of the details commented in the header
// ---------------------------------------------------------------------------
//
TInt CClockTimeZoneResolverImpl::GetTimeZoneIdWithMccL( const RMobilePhone::TMobilePhoneNetworkCountryCode& aMcc,
                                                   const TTimeIntervalMinutes& aTzOffset,
                                                   TInt& aTzId )
    {
    __PRINTS( "CClockTimeZoneResolverImpl::GetTimeZoneIdWithMccL() - Entry" );
    
    TInt retVal( KErrNotFound );
    
    RArray< CTzId > tzIdArray;
    CleanupClosePushL( tzIdArray );
            
    // Use the MCC to get all unlocalised zones.
    iMccTzIdMapper->TzIdFromMccL( aMcc, tzIdArray, aTzOffset );
    
    if( KOne < tzIdArray.Count() ) 
        {
        // For a multizone country without NITZ, it is not possible to 
        // calculate the TZ.
        aTzId = KErrNotFound;                 
        }
    else if( KOne == tzIdArray.Count() )
        {
        // For a single zone country, without NITZ, set the default TZ
        aTzId = tzIdArray[ KErrNone ].TimeZoneNumericID();         
        retVal = KErrNone;
        }
    
    CleanupStack::PopAndDestroy();
    
    __PRINTS( "CClockTimeZoneResolverImpl::GetTimeZoneIdWithMccL() - Exit" );
    
    return retVal;
    }

// ---------------------------------------------------------------------------
// CClockTimeZoneResolverImpl::ProcessMatchingZonesL
// rest of the details commented in the header
// ---------------------------------------------------------------------------
//
TInt CClockTimeZoneResolverImpl::ProcessMatchingZones( CTzLocalizedTimeZoneArray& aLocTimeZones, TInt& aTzId )
    {
    __PRINTS( "CClockTimeZoneResolverImpl::ProcessMatchingZonesL() - Entry" );
    
    if( ( KOne < iTempZoneIds.Count() ) && ( KErrNone == aLocTimeZones.Count() ) )
        {
        aTzId = iTempZoneIds[ FALSE ]->TimeZoneNumericID();
        iTempZoneIds.ResetAndDestroy();
        CleanupStack::PopAndDestroy( &aLocTimeZones );

        __PRINT( "aTzId: %d", aTzId );
        __PRINTS( "CClockTimeZoneResolverImpl::ProcessMatchingZonesL() - Exit" );

        return KErrNone;
        }

    iTempZoneIds.ResetAndDestroy();

    // If we don't have any localized zones at this point, we can do nothing
    if( KErrNone == aLocTimeZones.Count() )
        {        
        aTzId = KErrNotFound;
        CleanupStack::PopAndDestroy( &aLocTimeZones );

        __PRINT( "aTzId: %d", aTzId );
        __PRINTS( "CClockTimeZoneResolverImpl::ProcessMatchingZonesL() - Exit" );

        return KErrNotFound;
        }

    // If we have more than one localized zone at this point, we need to find the default one.
    TInt matchIndex( FALSE );
    for( TInt index( FALSE ); index < aLocTimeZones.Count(); index++ )
        {
        if( FALSE == aLocTimeZones.At( index ).StandardName().Compare( KDefault ) )
            {
            matchIndex = index;
            break; // We will take the first one we find.
            }
        }

    // This is the DST zone we are in.            
    aTzId = aLocTimeZones.At( matchIndex ).TimeZoneId();

    CleanupStack::PopAndDestroy( &aLocTimeZones );

    __PRINT( "aTzId: %d", aTzId );

    __PRINTS( "CClockTimeZoneResolverImpl::ProcessMatchingZonesL() - Exit" );

    return KErrNone;
    }
 
    
// ---------------------------------------------------------------------------
// CClockTimeZoneResolverImpl::GetCorrectZone
// rest of the details commented in the header
// ---------------------------------------------------------------------------
// 
  TInt CClockTimeZoneResolverImpl::GetCorrectZone( CTzLocalizedTimeZoneArray& aLocTimeZones, 
                       						  const TTimeIntervalMinutes& aTimeZoneOffset,
                       						  const TTimeIntervalMinutes& aDstOffset,
                       						  TInt& aTzId )
	{
	__PRINTS( "CClockTimeZoneResolverImpl::GetCorrectZone - Entry" );
     
	TInt returnVal( KErrNotFound );
	
   	// If we have no localised zones and network supports DST, we have done everything right, 
	// OR if UTC offset is invalid and we have a multizone country, we can do nothing.
	if( ( KErrNone == aLocTimeZones.Count() && KErrNotFound != aDstOffset.Int() ) ||
		( KOne < aLocTimeZones.Count() && KErrNotFound == aTimeZoneOffset.Int() ) )
		{
		aTzId = KErrNotFound;
		
		CleanupStack::PopAndDestroy( &aLocTimeZones );
		}    
	// Only one zone and DST indication supported by network. This is the dream case.
	else if( KOne == aLocTimeZones.Count() && KErrNotFound != aDstOffset.Int() )
		{
		// This is the easiest case, get the zone id and return correct zone
		aTzId = aLocTimeZones.At( FALSE ).TimeZoneId();
		returnVal = KErrNone;
		
		CleanupStack::PopAndDestroy( &aLocTimeZones );
		}

	
    __PRINTS( "CClockTimeZoneResolverImpl::GetCorrectZone - Exit" );
    
   	return returnVal;
   	}
   	
   	
// ---------------------------------------------------------------------------
// CClockTimeZoneResolverImpl::GetMatchingZonesL
// rest of the details commented in the header
// ---------------------------------------------------------------------------
//
TInt CClockTimeZoneResolverImpl::GetMatchingZonesL( CTzLocalizedTimeZoneArray* aLocTimeZones, TInt& aTzId )
	{
    // If we have only one matching zone, pick that up.
    if( KOne == iTempZoneIds.Count() )
        {
        aTzId = iTempZoneIds[ FALSE ]->TimeZoneNumericID();
        
        iTempZoneIds.ResetAndDestroy();
        CleanupStack::PopAndDestroy( aLocTimeZones );
        
       	__PRINT( "aTzId: %d", aTzId);
        
        __PRINTS( "CClockTimeZoneResolverImpl::GetMatchingZonesL - Exit" );
        
        return KErrNone;
        }        

    // If we have more zones, we will process them further.
    else if( KOne < iTempZoneIds.Count() )
        {
        
        for( TInt index( NULL ); index < aLocTimeZones->Count(); index++ )
        	{
        	aLocTimeZones->Remove( index );
        	}
        
        CTzLocalizedTimeZone* timezone( NULL );
        CTzLocalizer* localizer = CTzLocalizer::NewL();
        CleanupStack::PushL( localizer );

		// Get the localized timezones for each zone that matches.
        for( TInt zoneIndex( FALSE ); zoneIndex < iTempZoneIds.Count(); zoneIndex++ )
           {
            TRAPD( errVal,
            	timezone = localizer->GetLocalizedTimeZoneL( iTempZoneIds[ zoneIndex ]->TimeZoneNumericID() ) );
            if( KErrNone == errVal && timezone )
                {
                aLocTimeZones->AppendL( timezone );
                }                
            }
        CleanupStack::PopAndDestroy( localizer );
        } 
        
    __PRINTS( "CClockTimeZoneResolverImpl::GetMatchingZonesL - Exit" );
        
    return KErrNotFound;
	}
	
// End of file