/*

* 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 CClockMCCTzIdMapper class.

*

*/

// System includes

#include <tz.h>

#include <tzdefines.h>

#include <vtzrules.h>

#include <bautils.h>

// User includes

#include "clockmcctzmapper.h"

#include "clock_debug.h"

// Constants

// Literals

_LIT( KMCCResourceFileDir, "\\resource\\mcc\\" );

_LIT( KMCCResourceFileName, "mcc.rsc" );

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

// CClockMCCTzIdMapper::NewL

// rest of the details are commented in the header

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

//

CClockMCCTzIdMapper* CClockMCCTzIdMapper::NewL()

	{

	__PRINTS( "CClockMCCTzIdMapper::NewL - Entry" );

    CClockMCCTzIdMapper* self = CClockMCCTzIdMapper::NewLC();

	CleanupStack::Pop( self );

	__PRINTS( "CClockMCCTzIdMapper::NewL - Exit" );

	return self;

	}

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

// CClockMCCTzIdMapper::NewLC

// rest of the details are commented in the header

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

//

CClockMCCTzIdMapper* CClockMCCTzIdMapper::NewLC()

	{

	__PRINTS( "CClockMCCTzIdMapper::NewLC - Entry" );

	CClockMCCTzIdMapper* self = new ( ELeave ) CClockMCCTzIdMapper();

	CleanupStack::PushL( self );

	self->ConstructL();

	__PRINTS( "CClockMCCTzIdMapper::NewLC - Exit" );

	return self;

	}

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

// CClockMCCTzIdMapper::ConstructL

// rest of the details are commented in the header

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

//

void CClockMCCTzIdMapper::ConstructL()

	{

	__PRINTS( "CClockMCCTzIdMapper::ConstructL - Entry" );

	// Connect to the file server

	User::LeaveIfError( iFs.Connect() );	

    // Get the full filename with drive letter

    TFileName rscFileName; 

    TFindFile fileFinder( iFs );

    // TFindFile applies search order that is from drive Y to A, then Z

    TInt err = fileFinder.FindByDir( KMCCResourceFileName, KMCCResourceFileDir );

    if ( err == KErrNone )

        {

        // Found file.

        rscFileName = fileFinder.File();

        }

    else

        {

        __PRINTS( "Unable to open mcc.rsc. Leaving now!!" );

        // Leave with reason, file not found.

        User::Leave( KErrPathNotFound );

        }

	// Open the resource file.  The resource file will not be localized as it

	// only contains integers, so there is no need to find a language specific

	// resource file name.

	iMCCResourceFile.OpenL( iFs, rscFileName );

	iMCCResourceFile.ConfirmSignatureL();

	// Assign buffer for holding resource

	TInt resourceId = iMCCResourceFile.Offset() + EMCCFirstResource;

	iResourceBuffer = iMCCResourceFile.AllocReadL( resourceId );

	__PRINTS( "CClockMCCTzIdMapper::ConstructL - Exit" );

	}

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

// CClockMCCTzIdMapper::~CClockMCCTzIdMapper

// rest of the details are commented in the header

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

//

CClockMCCTzIdMapper::~CClockMCCTzIdMapper()

	{

	__PRINTS( "CClockMCCTzIdMapper::~CClockMCCTzIdMapper - Entry" );

	// Close the resource file.

	iMCCResourceFile.Close();

	// Free up the resource buffer.

	if( iResourceBuffer )

	    {

	    delete iResourceBuffer;

	    iResourceBuffer = NULL;

	    }

	// Close the file server session.

	iFs.Close();

	__PRINTS( "CClockMCCTzIdMapper::~CClockMCCTzIdMapper - Exit" );

	}

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

// CClockMCCTzIdMapper::UTCOffSetWithoutDSTChangesL

// rest of the details are commented in the header

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

//

TInt CClockMCCTzIdMapper::UTCOffSetWithoutDSTChangesL( RTz& aTz, const CTzId& aTzId ) const

	{

	TInt timeOffset( KErrNotFound );

	TTime universalTime;

	universalTime.UniversalTime();

	// Get the current rules for the timezone rules

	CTzRules* currentRules = aTz.GetTimeZoneRulesL( aTzId, universalTime, universalTime, ETzUtcTimeReference );

	if( currentRules )

	    {

	    timeOffset = currentRules->InitialStdTimeOffset();

	    delete currentRules;

	    }

	return timeOffset;

	}

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

// CClockMCCTzIdMapper::TzIdFromMccL

// rest of the details are commented in the header

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

//

void CClockMCCTzIdMapper::TzIdFromMccL( const RMobilePhone::TMobilePhoneNetworkCountryCode& aMCC,

								        RArray< CTzId >& aTzIdArray,

								        const TTimeIntervalMinutes& aStdTimeOffset )

	{

	__PRINTS( "CClockMCCTzIdMapper::TzIdFromMccL - Entry" );

	// Convert the TMobilePhoneNetworkCountryCode to a TInt.

	TInt currentMcc;

	TLex lexUtil( aMCC );

	User::LeaveIfError( lexUtil.Val( currentMcc ) );

	__PRINT( "MCC: %d", currentMcc );

	// Get all the DST zones that match mcc

	DoGetTzIdFromMCCL( currentMcc, aTzIdArray );

	// Limit the returned entries to those with a specific StdTimeOffset

	TInt offset = aStdTimeOffset.Int();

	if( offset != -1 )

		{

		// Connect to Tz

		RTz tzHandle;

		CleanupClosePushL( tzHandle );

		User::LeaveIfError( tzHandle.Connect() );

		TInt currentZoneOffset;

		TInt count = aTzIdArray.Count();

		// Loop through the array in reverse order, removing all entries

		// with non matching standard time offsets.

		for( TInt index( count - 1 ); index >= KErrNone; --index )

			{

			currentZoneOffset = UTCOffSetWithoutDSTChangesL( tzHandle, aTzIdArray[ index ] );

			if( currentZoneOffset != offset )

				{

				aTzIdArray.Remove( index );

				}

			}

		// Cleanup.

		CleanupStack::PopAndDestroy( &tzHandle );

		}

	__PRINTS( "CClockMCCTzIdMapper::TzIdFromMccL - Exit" );

	}

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

// CClockMCCTzIdMapper::TzIdFromOffsetL

// rest of the details are commented in the header

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

//

void CClockMCCTzIdMapper::TzIdFromOffsetL( const TTimeIntervalMinutes& aStdTimeOffset, RArray< CTzId >& aTzIdArray )

	{

	__PRINTS( "CClockMCCTzIdMapper::TzIdFromOffsetL - Entry" );

	// Reset the position in the resource buffer

	iResourceReader.SetBuffer( iResourceBuffer );

	// First TInt is the number of array items

	TInt numberOfItems( iResourceReader.ReadInt16() );

	// Loop through the resource array reading the TzId

	for( TInt index( KErrNone ); index < numberOfItems; ++index )

		{

		TInt timeZoneId( iResourceReader.ReadInt16() );

		TInt mobileCC( iResourceReader.ReadInt16() );

		CTzId* timeZone = CTzId::NewL( timeZoneId );

		CleanupStack::PushL( timeZone );

		aTzIdArray.AppendL( *timeZone );

		CleanupStack::PopAndDestroy( timeZone );

		timeZone = NULL;

		}

	// Limit the returned entries to those with a specific StdTimeOffset

	TInt timeOffset( aStdTimeOffset.Int() );

	// Connect to Tz

	RTz tzHandle;

	CleanupClosePushL( tzHandle );

	User::LeaveIfError( tzHandle.Connect() );

	TInt currentZoneOffset;

	TInt idCount( aTzIdArray.Count() );

	// Loop through the array in reverse order, removing all entries

	// with non matching standard time offsets.

	for( TInt index( idCount - 1 ); index >= KErrNone; --index )

		{

		currentZoneOffset = UTCOffSetWithoutDSTChangesL( tzHandle, aTzIdArray[ index ] );

		if( currentZoneOffset != timeOffset )

			{

			aTzIdArray.Remove( index );

			}

		}

	CleanupStack::PopAndDestroy( &tzHandle );

	// This is a check to see if the timezone array has multiple entries with same timezone ID.

	// This happens because many countries have multiple MCCs for a single timezone ID.

	// For ex: India has MCCs 404 and 405 for the same timezone ID 1624 and offset GMT+5:30.

	TInt zoneCount( aTzIdArray.Count() );

	if( 1 < zoneCount )

		{

		CTzId& prevTzId = aTzIdArray[ KErrNone ];

		for( TInt zoneIndex( zoneCount - 1 ); zoneIndex > KErrNone; --zoneIndex )

			{

			CTzId& curTzId = aTzIdArray[ zoneIndex ];

			if( prevTzId != curTzId )

				{

				// There are multiple timezones. So skip.

				break;

				}

			else

				{

				// Keep removing duplicate zone IDs.

				aTzIdArray.Remove( zoneIndex );

				}

			}

		}

	__PRINTS( "CClockMCCTzIdMapper::TzIdFromOffsetL - Exit" );

	}

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

// CClockMCCTzIdMapper::DoGetTzIdFromMCCL

// rest of the details are commented in the header

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

//

void CClockMCCTzIdMapper::DoGetTzIdFromMCCL( TInt aMcc, RArray< CTzId >& aTzIdArray )

	{

	__PRINTS( "CClockMCCTzIdMapper::DoGetTzIdFromMCCL - Entry" );

	__PRINT( "MCC:%d", aMcc );

	// Reset the position in the resource buffer.

	iResourceReader.SetBuffer( iResourceBuffer );

	// First TInt is the number of array items.

	TInt numberOfItems( iResourceReader.ReadInt16() );

	TInt timeZoneId;

	TInt mobileCC;

	CTzId* matchingDSTZone( NULL );

	// Loop through the resource array reading the TzId / MCC pairs.

	for( TInt index( KErrNone ); index < numberOfItems; ++index )

		{

		timeZoneId = iResourceReader.ReadInt16();

		mobileCC = iResourceReader.ReadInt16();

		// Found a match - create a new CTzId and append to the TzId array.

		if( mobileCC == aMcc )

			{

			matchingDSTZone = CTzId::NewL( timeZoneId );

			CleanupStack::PushL( matchingDSTZone );

			aTzIdArray.AppendL( *matchingDSTZone );

			CleanupStack::PopAndDestroy( matchingDSTZone );

			matchingDSTZone = NULL;

			}

		}

	__PRINTS( "CClockMCCTzIdMapper::DoGetTzIdFromMCCL - Exit" );

	}

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

// CClockMCCTzIdMapper::MCCFromTzIdL

// rest of the details are commented in the header

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

//

TInt CClockMCCTzIdMapper::MCCFromTzIdL( const CTzId& aTzId )

	{

	__PRINTS( "CClockMCCTzIdMapper::MCCFromTzIdL - Entry" );

	// Reset the position in the resource buffer

	iResourceReader.SetBuffer( iResourceBuffer );

	// First TInt is the number of array items

	TInt numberOfItems( iResourceReader.ReadInt16() );

	TInt timeZoneId;

	TInt mobileCC;

	// Loop through the resource array reading the TzId / MCC pairs

	for( TInt index( KErrNone ); index < numberOfItems; ++index )

		{

		timeZoneId = iResourceReader.ReadInt16();

		mobileCC = iResourceReader.ReadInt16();

		// Found a match return the mcc

		if( timeZoneId == aTzId.TimeZoneNumericID() )

			{

			__PRINT( "Found a match, MCC - %d", mobileCC );

			return mobileCC;

			}

		}

	__PRINTS( "CClockMCCTzIdMapper::MCCFromTzIdL - Exit" );

	return KErrNotFound;

	}

// End of file