/*

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