/*

* 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:    

*

*/

// INCLUDES

#include <SyncMLTransportProperties.h>

#include <collate.h>

#include "iaupdatefwsyncutil.h"

#include "iaupdatefwdebug.h"

#include "iaupdatefwconst.h"

/*****************************************************************************

 * class TUtil

 *****************************************************************************/

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

// Panic

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

//

 void TUtil::Panic(TInt aReason)

    {

	_LIT(KPanicCategory,"IAUpdateFWSyncUtil");

	User::Panic( KPanicCategory, aReason ); 

    }

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

// StrCopy

// String copy with lenght check.

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

//

 void TUtil::StrCopy( TDes8& aTarget, const TDesC& aSource )

    {

    aTarget.Copy( aSource.Left(aTarget.MaxLength() ) );

    }

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

// StrCopy

// String copy with lenght check.

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

//

 void TUtil::StrCopy( TDes& aTarget, const TDesC8& aSource )

    {

	aTarget.Copy( aSource.Left(aTarget.MaxLength() ) );

    }

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

// StrCopy

// String copy with lenght check.

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

//

 void TUtil::StrCopy( TDes& aTarget, const TDesC& aSource )

    {

	aTarget.Copy( aSource.Left( aTarget.MaxLength() ) );

    }

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

// StrAppend

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

//

void TUtil::StrAppend( TDes& aTarget, const TDesC& aSource )

    {

    if ( aSource.Length() == 0 )

    	{

    	return;

    	}

    TInt free = aTarget.MaxLength() - aTarget.Length();

	if ( aSource.Length() <= free )

		{

		aTarget.Append( aSource );

		}

    }

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

// StrInsert

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

//

  void TUtil::StrInsert( TDes& aTarget, const TDesC& aSource )

    {

	TInt free = aTarget.MaxLength() - aTarget.Length();

	if (aSource.Length() <= free)

		{

		aTarget.Insert(0, aSource);

		}

    }

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

// StrToInt

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

//

TInt TUtil::StrToInt( const TDesC& aText, TInt& aNum )

	{

    TLex lex( aText );

    TInt err = lex.Val( aNum ); 

	return err;

	}

//

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

// IsEmpty

// Function returns ETrue if string only contains white space

// or has no characters.

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

//

TBool TUtil::IsEmpty( const TDesC& aText )

	{

	TInt len = aText.Length();

	for ( TInt index=0; index < len; index++ )

		{

		TChar character = aText[index];

		if ( !character.IsSpace() )

			{

			return EFalse;

			}

		}

	return ETrue;

	}

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

// SyncTimeLC

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

//

HBufC* TUtil::SyncTimeLC( TTime aLastSync )

	{

	FLOG( "[OMADM] TUtil::SyncTimeLC" );

	TTime homeTime = ConvertUniversalToHomeTime( aLastSync );

	HBufC* hBuf = HBufC::NewLC( KBufSize255 );

	TPtr ptr = hBuf->Des();

	if ( IsToday( homeTime ) )

		{

		FLOG( "[OMADM] TUtil::SyncTimeLC time" );

		TBuf<KBufSize> timeFormat;

		TUtil::StrCopy( timeFormat, *buf );

		CleanupStack::PopAndDestroy( buf );

		FLOG( "[OMADM] TUtil::SyncTimeLC time done" );

		}

	else

		{

		FLOG( "[OMADM] TUtil::SyncTimeLC date" );

		TBuf<KBufSize> dateFormat;

        TUtil::StrCopy( dateFormat, *buf );

        CleanupStack::PopAndDestroy( buf );

		FLOG( "[OMADM] TUtil::SyncTimeLC date done" );

		}

    FLOG( "[OMADM] TUtil::SyncTimeLC Done" );

	return hBuf;

	}

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

// ConvertUniversalToHomeTime

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

//

TTime TUtil::ConvertUniversalToHomeTime( const TTime& aUniversalTime )

    {

    TTime time( aUniversalTime );   // time stores UTC time.

    TLocale locale;

    TTimeIntervalSeconds universalTimeOffset( locale.UniversalTimeOffset() );

    // Add locale's universal time offset to universal time.

    time += universalTimeOffset;    // time stores Local Time.

    // If home daylight saving in effect, add one hour offset.

    if ( locale.QueryHomeHasDaylightSavingOn() )

        {

        TTimeIntervalHours daylightSaving(1);

        time += daylightSaving;

        }

    return time;

    }

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

// IsToDay

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

//

TBool TUtil::IsToday(TTime aTime)

	{

	FLOG( "[OMADM] TUtil::IsToday" );

	TTime now;

	now.HomeTime();

	TInt day1 = now.DayNoInYear();

	TInt day2 = aTime.DayNoInYear();

	TTimeIntervalDays daysBetween = now.DaysFrom( aTime );

	if ( day1 != day2 )

		{

		FLOG( "[OMADM] TUtil::IsToday False 1" );

		return EFalse;

		}

	if ( daysBetween.Int() > 0 )

		{

		FLOG( "[OMADM] TUtil::IsToday False 2" );

		return EFalse;

		}

    FLOG( "[OMADM] TUtil::IsToday True" );

	return ETrue; 

	}

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

// TUtil::GetDateTextL

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

//

	{

	TTime homeTime = ConvertUniversalToHomeTime( aDateTime );

	}

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

// TUtil::GetTimeTextL

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

//

	{

	TTime homeTime = ConvertUniversalToHomeTime( aDateTime );

	}

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

// TUtil::GetDateTimeTextL

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

//

void TUtil::GetDateTimeTextL( TDes& aText, TTime aDateTime )

	{

	TDateTime dt = aDateTime.DateTime();

	aText.Format(_L("%02d.%02d.%04d %02d:%02d:%02d"), dt.Day()+1,

	                                                  dt.Month()+1,

	                                                  dt.Year(),

	                                                  dt.Hour(),

	                                                  dt.Minute(),

	                                                  dt.Second() );

	}

/*****************************************************************************

 * class TURIParser

 *****************************************************************************/

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

// Constructor

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

//

TURIParser::TURIParser( const TDesC& aStr ) : iOriginalStr( aStr )

    {

    SkipHttp();

    }

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

// GetUriWithoutPort

// URI format: "http://serveraddress/documentname/"

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

//

void TURIParser::GetUriWithoutPort( TDes& aText )

	{

	aText = KNullDesC;

	TPtrC http = ParseHttp();

	TPtrC address = ParseAddress();

	TPtrC document = ParseDocument();

	TUtil::StrAppend( aText, http );

	TUtil::StrAppend( aText, address );

	if (document.Length() > 0)

		{

		TUtil::StrAppend( aText, KSlash );

		TUtil::StrAppend( aText, document );

		}

	else if ( iSlash )

		{

		TUtil::StrAppend( aText, KSlash );

		}

	}

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

// GetURI

// URI format: "http://serveraddress:port/documentname/"

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

//

void TURIParser::GetUri( TDes& aText, const TInt aPort )

	{

	aText = KNullDesC;

	TPtrC http = ParseHttp();

	TPtrC address = ParseAddress();

	TPtrC document = ParseDocument();

	TUtil::StrAppend( aText, http );

	TUtil::StrAppend( aText, address );

	TBuf<KBufSize32> buf;

	buf.Num( aPort );

	TUtil::StrAppend( aText, KColon );

	TUtil::StrAppend( aText, buf );

	if ( document.Length() > 0 )

		{

		TUtil::StrAppend( aText, KSlash );

		TUtil::StrAppend( aText, document );

		}

	else if ( iSlash )

		{

		TUtil::StrAppend( aText, KSlash );

		}

	}

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

// Port

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

//

TInt TURIParser::Port()

	{

	TInt port = KErrNotFound;

	TInt err = ParsePort( port );

	if ( err != KErrNone )

		{

		return KErrNotFound;

		}

	return port;

	}

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

// DefaultPort

// 

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

//

TInt TURIParser::DefaultPort()

	{

	TInt pos = iOriginalStr.FindF( KHttpsHeader );

	if ( pos != KErrNotFound )

		{

		return KDefaultHttpsPort;

		}

	return KDefaultHttpPort;

	}

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

// SkipHttp

// Set pointer to the end of "http://".

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

//

void TURIParser::SkipHttp()

	{

    TInt start = KErrNotFound;

    TInt end   = KErrNotFound;

    TStr str(iOriginalStr);

    GetHttpPos( start, end );

    if ( start != KErrNotFound )

    	{

    	iPtr.Set( str.Right( end + 1 ) );

    	}

    else

    	{

    	iPtr.Set( str.Right(0) );

    	}

	}

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

// ParseHttp

// 

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

//

TPtrC TURIParser::ParseHttp()

	{

    TInt start = KErrNotFound;

    TInt end   = KErrNotFound;

    GetHttpPos(start, end);

    if (start == KErrNotFound)

    	{

    	return TPtrC();

    	}

   	TStr str(iOriginalStr);

    return str.SubStr(start, end);

	}

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

// GetHttpPos 

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

//

void TURIParser::GetHttpPos( TInt& aStartPos, TInt& aEndPos )

	{

	aEndPos = KErrNotFound;

	aStartPos = iOriginalStr.FindF( KHttpHeader );

	if ( aStartPos != KErrNotFound )

		{

		aEndPos = aStartPos + KHttpHeader().Length() - 1;

		return;

		}

	aStartPos = iOriginalStr.FindF( KHttpsHeader );

	if ( aStartPos != KErrNotFound )

		{

		aEndPos = aStartPos + KHttpsHeader().Length() - 1;

		return;

		}

	}

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

// ParseAddress

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

TPtrC TURIParser::ParseAddress()

	{

	const TChar KSlash('/');

	const TChar KColon(':');

	TStr str( iPtr );

    TInt firstSlash = str.Find( 0, KSlash );

	TInt firstcolon = str.Find( 0, KColon );

	TBool portFound = EFalse;

	iSlash = EFalse;

	if ( firstSlash != KErrNotFound ) 

	    {

		 iSlash = ETrue;

	    }

	if (firstcolon != KErrNotFound)

		{

		if ( firstSlash == KErrNotFound )

			{

			portFound = ETrue;

			}

		else if ( firstcolon < firstSlash )

			{

			portFound = ETrue;

			}

		}

	if ( portFound )

		{

		// address is text before first colon

		return str.Left( firstcolon - 1 );

		}

	else if (firstSlash != KErrNotFound)

		{

		// address is text before first slash

		return str.Left( firstSlash - 1 );

		}

	else

		{

		// address is all text

		return str.Right( 0 );

		}

	}

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

// ParseDocument

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

TPtrC TURIParser::ParseDocument()

	{

	const TChar KSlash('/');

	TStr str(iPtr);

    TInt firstSlash = str.Find( 0, KSlash );

	if ( firstSlash != KErrNotFound )

		{

		// document is all text after first slash

		return str.Right( firstSlash + 1 );

		}

	return TPtrC();

	}

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

// ParsePort

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

// 

TInt TURIParser::ParsePort( TInt& aNumber )

	{

	TPtrC port = ParsePort();

	if ( port.Length() == 0 )

		{

		return KErrNotFound;

		}

	return TUtil::StrToInt( port, aNumber );

	}

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

// ParsePort

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

// 

TPtrC TURIParser::ParsePort()