/*

* Copyright (c) 2006 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:    RLS and Presence XDM, This class represents validity part of 

*                 a Presence Condition

*

*/

// Includes

#include <XdmDocumentNode.h>

#include <XdmNodeAttribute.h>

#include <xcapappusagedef.h>

#include <utf.h>

#include "prescondvalidity.h"

#include "cpresencexdm.h"

#include "rlspresxdmlogger.h"

#include "rlspresxdmconstsint.h"

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

// TPresCondValidity::TPresCondValidity()

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

//	

EXPORT_C TPresCondValidity::TPresCondValidity(): iPresXDM(NULL)

    {

    OPENG_DP(D_OPENG_LIT( "TPresCondValidity::TPresCondValidity()" ));

    }

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

// TPresCondValidity::Init()

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

//    

EXPORT_C void TPresCondValidity::Init(CPresenceXDM* const aPresXDM)

    {

    OPENG_DP(D_OPENG_LIT( "TPresCondValidity::Init(%d)" ), aPresXDM);

    iPresXDM = aPresXDM;

    }

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

// TPresCondValidity::GetValidity()

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

//	

EXPORT_C TInt TPresCondValidity::GetValidityL(const TDesC& aRuleID, 

                                        RArray<TTimePeriod>& aValidTimes)

	{

    OPENG_DP(D_OPENG_LIT( "TPresCondValidity::GetValidity()" ) );

    OPENG_DP(D_OPENG_LIT( "     aRuleID = %S"),&aRuleID);

	CXdmDocumentNode* validityNode = GetValidityNodeL(aRuleID, EFalse);

	if(validityNode==NULL)

	    return KErrNotFound;

	TInt nodeCount = validityNode->NodeCount();

    OPENG_DP(D_OPENG_LIT( "     validityNode->NodeCount() = %d"),nodeCount);

	if(!nodeCount)

	    return KErrNotFound;

	RPointerArray<CXdmDocumentNode> fromNodes;

	RPointerArray<CXdmDocumentNode> untilNodes;

	HBufC* fromPtr(NULL);

	HBufC* untilPtr(NULL); 

	TTime fromTime(0);

	TTime untilTime(0);

	TTimePeriod myTimePeriod;

    // Get all the <from> nodes

  	validityNode->Find(KXdmFrom, fromNodes);

    validityNode->Find(KXdmUntil, untilNodes);

    if((fromNodes.Count()) != (untilNodes.Count()))

        {

        fromNodes.Close();

        untilNodes.Close();

        return KErrGeneral;

        }

    nodeCount = fromNodes.Count();

    OPENG_DP(D_OPENG_LIT( "     nodesCount = %d" ),nodeCount);

	for(TInt i=0; i<nodeCount; i++)

	    {

	    // processing from

	    (fromNodes[i])->SetLeafNode(ETrue);

	    fromPtr = CnvUtfConverter::ConvertToUnicodeFromUtf8L((fromNodes[i])->LeafNodeContent());

	    CleanupStack::PushL(fromPtr);

	    OPENG_DP(D_OPENG_LIT( "     from string at i(%d): %S" ),i,&(*fromPtr));

	    ParseFromXMLTimeString(fromPtr->Des(), fromTime);

	    CleanupStack::PopAndDestroy(fromPtr);

	    ConvertToLocal(fromTime);

	    ((aValidTimes[i]).from).Set(fromTime.DateTime().Year(),fromTime.DateTime().Month(),

	        fromTime.DateTime().Day(),fromTime.DateTime().Hour(),fromTime.DateTime().Minute(),

	        fromTime.DateTime().Second(), fromTime.DateTime().MicroSecond());

	    OPENG_DP(D_OPENG_LIT( "     from at i = %d" ),i);

	    LogDateTime((aValidTimes[i]).from);

	    // processing until

	    (untilNodes[i])->SetLeafNode(ETrue);

	    untilPtr = CnvUtfConverter::ConvertToUnicodeFromUtf8L((untilNodes[i])->LeafNodeContent());

	    CleanupStack::PushL(untilPtr);

	    OPENG_DP(D_OPENG_LIT( "     until string at i(%d): %S" ),i,&(*untilPtr));

	    ParseFromXMLTimeString(untilPtr->Des(), untilTime);

	    CleanupStack::PopAndDestroy(untilPtr);

	    ConvertToLocal(untilTime);

	    (aValidTimes[i]).until.Set(untilTime.DateTime().Year(),untilTime.DateTime().Month(),

	        untilTime.DateTime().Day(),untilTime.DateTime().Hour(),untilTime.DateTime().Minute(),

	        untilTime.DateTime().Second(),untilTime.DateTime().MicroSecond());

	    OPENG_DP(D_OPENG_LIT( "     until at i = %d" ),i);

	    LogDateTime((aValidTimes[i]).until);

	    }

    fromNodes.Close();

    untilNodes.Close();

	return KErrNone;

	}

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

// TPresCondValidity::DeleteAllValidity()

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

//

EXPORT_C TInt TPresCondValidity::DeleteAllValidityL(const TDesC& aRuleID)

	{

    OPENG_DP(D_OPENG_LIT( "TPresCondValidity::DeleteAllValidity()" ) );

    OPENG_DP(D_OPENG_LIT( "     aRuleID = %S"),&aRuleID);

    __ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady));

	CXdmDocumentNode* validityNode = GetValidityNodeL(aRuleID, EFalse);

	if(validityNode==NULL)

	    return KErrNotFound;

	iPresXDM->RemoveFromModelL(validityNode);

	OPENG_DP(D_OPENG_LIT( "     removed"));

	return KErrNone;

	}

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

// TPresCondValidity::AddValidityL()

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

//

EXPORT_C TInt TPresCondValidity::AddValidityL(const TDesC& aRuleID, 

                                                const TTimePeriod aValidTime)

	{

    OPENG_DP(D_OPENG_LIT( "TPresCondValidity::AddValidityL()" ) );

    OPENG_DP(D_OPENG_LIT( "     aRuleID = %S"),&aRuleID);

    OPENG_DP(D_OPENG_LIT( "     from:"));

    LogDateTime(aValidTime.from);

    OPENG_DP(D_OPENG_LIT( "     until:"));

    LogDateTime(aValidTime.until);

	CXdmDocumentNode* validityNode = GetValidityNodeL(aRuleID, ETrue);

	if(validityNode==NULL)

	    return KErrNotFound;

	TBuf<KPresDateTimeBufLength> fromString;

	TBuf<KPresDateTimeBufLength> untilString;

	TTime fromTTime(aValidTime.from);

	TTime untilTTime(aValidTime.until);

	// convert to universal times

	ConvertToUniversal(fromTTime);

	ConvertToUniversal(untilTTime);

	// get the xml strings

	FormatToXMLTimeStringL(fromString, fromTTime);

    FormatToXMLTimeStringL(untilString, untilTTime);

    OPENG_DP(D_OPENG_LIT( "     from: %S"), &fromString);

    OPENG_DP(D_OPENG_LIT( "     until: %S"), &untilString);

    // make the nodes

	CXdmDocumentNode* fromNode = validityNode->CreateChileNodeL(KXdmFrom);

	CXdmDocumentNode* untilNode = validityNode->CreateChileNodeL(KXdmUntil);

	// make the leaf and put contents

	fromNode->SetLeafNode(ETrue);

	fromNode->SetLeafNodeContentL(fromString);

	untilNode->SetLeafNode(ETrue);

	untilNode->SetLeafNodeContentL(untilString);

	return KErrNone;		

	}

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

// TPresCondValidity::IsTimeValidL()

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

//	

EXPORT_C TBool TPresCondValidity::IsTimeValidL(const TDesC& aRuleID, 

                                                const TTimePeriod aTime)

    {

    OPENG_DP(D_OPENG_LIT( "TPresCondValidity::IsTimeValid()" ) );

    OPENG_DP(D_OPENG_LIT( "     aRuleID = %S"),&aRuleID);

    OPENG_DP(D_OPENG_LIT( "     from:"));

    LogDateTime(aTime.from);

    OPENG_DP(D_OPENG_LIT( "     until:"));

    LogDateTime(aTime.until);

	CXdmDocumentNode* validityNode = GetValidityNodeL(aRuleID, EFalse);

	if (validityNode==NULL)

	    return ETrue;   // because all times are valid if no validity node

	TBool result(EFalse);

	RArray<TTimePeriod> validTimes;

	GetValidityL(aRuleID, validTimes);

	TTime givenfromTime(aTime.from);

	TTime givenuntilTime(aTime.until);

	TInt validTimeCounts = validTimes.Count();

	for(TInt i=0; i<validTimeCounts; i++)

	    {

	    TTime fromTime((validTimes[i]).from);

	    TTime untilTime((validTimes[i]).until);

	    if( (givenfromTime>=fromTime) && (givenuntilTime<=untilTime) )

	        {

            result = ETrue;

	        break;

	        }

	    }

	validTimes.Close();

	OPENG_DP(D_OPENG_LIT( "     result = %d"),result);

	return result;   

    }

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

// TPresCondValidity::GetValidityNode()

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

//    

CXdmDocumentNode* TPresCondValidity::GetValidityNodeL(const TDesC& aRuleID, 

                                                        TBool aCreate)

    {

    OPENG_DP(D_OPENG_LIT( " TPresCondValidity::GetValidityNodeL()" ) );

    OPENG_DP(D_OPENG_LIT( "     GetValidityNodeL aRuleID = %S, aCreate = %d"),

                                                            &aRuleID, aCreate);

    __ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady));                                                        

    CXdmDocumentNode* conditionNode = iPresXDM->GetRuleChildNodeL(aRuleID, 

                                                    KXdmConditions, aCreate);

    if (conditionNode==NULL)

        return conditionNode;

    RPointerArray<CXdmDocumentNode> nodes;

    CXdmDocumentNode* validityNode(NULL);

    // Finding sphere node

	conditionNode->Find(KXdmValidity, nodes);

    OPENG_DP(D_OPENG_LIT( "     GetValidityNodeL nodeCount = %d"),nodes.Count());

	if(nodes.Count()) // if identity node exist

	    {

	    validityNode = nodes[0]; // only one sphere node can exist

	    }

	else if (aCreate) // if asked to create

	    {

	    validityNode = conditionNode->CreateChileNodeL(KXdmValidity);

	    }

    nodes.Close();        

    return validityNode;   

    }

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

// TPresCondValidity::ParseFromXMLTimeString()

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

//    

TInt TPresCondValidity::ParseFromXMLTimeString(const TDesC& aXMLTimeString, 

                                                         TTime& aUTCDateTime)

    {

    OPENG_DP(D_OPENG_LIT( " TPresCondValidity::ParseFromXMLTimeString()" ) );

    OPENG_DP(D_OPENG_LIT( "     ParseFromXMLTimeString aXMLTimeString = %S"), 

                                                                &aXMLTimeString);

    TInt err(KErrNone);

    // Initializing the locale

    TLocale myLocale, systemLocale;

    myLocale.Refresh();

    systemLocale.Refresh();

    myLocale.SetDateFormat(EDateJapanese);

    myLocale.SetDateSeparator('-',1);

    myLocale.SetDateSeparator('-',2);

    myLocale.SetDateSeparator('T',3);

    myLocale.SetTimeFormat(ETime24);

    myLocale.SetTimeSeparator(':',1);

    myLocale.SetTimeSeparator(':',2);

    myLocale.SetTimeSeparator(' ',3);

    myLocale.Set();

    TTime myTime;

    TTime myUTCtime;

    TChar uTCtimeSign(aXMLTimeString[23]); // 23 is ascii T

    // parsing main time

    TBuf<KPresDateTimeBufLength> dateTimeBuffer(aXMLTimeString);

    dateTimeBuffer.Delete(KPresDTWithoutUTCLength-1,6);

    dateTimeBuffer.Replace(KPresDTSeperatorPos,1,KPresSpaceString);

    myTime.Parse(dateTimeBuffer);

    // parsing utc time

    TBuf<KPresDateTimeBufLength> uTCbuffer(aXMLTimeString);

    uTCbuffer.Delete(0,KPresDTWithoutUTCLength);

    myUTCtime.Parse(uTCbuffer);

    TDateTime uTCDateTime = myUTCtime.DateTime();

    // adding or substracting utc from main time

    if(uTCtimeSign=='+') // if diff is positive

        {

        aUTCDateTime = myTime - TTimeIntervalHours(uTCDateTime.Hour());

        aUTCDateTime = aUTCDateTime - TTimeIntervalMinutes(uTCDateTime.Minute());            

        }

    else if(uTCtimeSign=='-')

        {

        aUTCDateTime = myTime + TTimeIntervalHours(uTCDateTime.Hour());

        aUTCDateTime = aUTCDateTime + TTimeIntervalMinutes(uTCDateTime.Minute());            

        }

    else

        err = KErrArgument;

    // putting the system locale back

    systemLocale.Set();

    return err;    

    }

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

// TPresCondValidity::FormatToXMLTimeStringL()

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

//

TInt TPresCondValidity::FormatToXMLTimeStringL(TDes& aXMLTimeString, 

                                                    const TTime aUTCDateTime)

    {

    OPENG_DP(D_OPENG_LIT( " TPresCondValidity::FormatToXMLTimeString()" ) );

    OPENG_DP(D_OPENG_LIT( "     FormatToXMLTimeString aUTCDateTime:"));

    LogDateTime(aUTCDateTime.DateTime());

    // Initializing the locale

    TLocale myLocale, systemLocale;

    myLocale.Refresh();

    systemLocale.Refresh();

    myLocale.SetDateFormat(EDateJapanese);

    myLocale.SetDateSeparator('-',1);

    myLocale.SetDateSeparator('-',2);

    myLocale.SetDateSeparator('T',3);

    myLocale.SetTimeFormat(ETime24);

    myLocale.SetTimeSeparator(':',1);

    myLocale.SetTimeSeparator(':',2);

    myLocale.SetTimeSeparator(' ',3);

    myLocale.Set();

    // getting UTC difference    

    TTimeIntervalSeconds uTCseconds = systemLocale.UniversalTimeOffset();

    // processing main time and date component

    TTime mainTTime = aUTCDateTime + uTCseconds;            

    mainTTime.FormatL(aXMLTimeString, KPresDateTimeFormatString);

    // Processing for time difference

    TChar uTCtimeSign('+');

    TDateTime myUTCtime(0,EJanuary,0,0,0,0,0);

    TTime uTCTTime(myUTCtime);

    if(uTCseconds.Int()<0)

        {

        uTCtimeSign = '-';

        uTCseconds = (uTCseconds.Int())*(-1);        

        }

    uTCTTime = uTCTTime + uTCseconds;

    TBuf<KPresDateTimeBufLength> dateTimeUTCBuffer;

    uTCTTime.FormatL(dateTimeUTCBuffer, KPresUTCFormatString);

    // Appending the time difference to main string

    aXMLTimeString.Append(dateTimeUTCBuffer);

    // put time difference sign to main string

    aXMLTimeString[23] = uTCtimeSign;

    // putting the system locale back

    systemLocale.Set();

    return KErrNone;

    }

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

// TPresCondValidity::ConvertToUniversal()

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

//    

void TPresCondValidity::ConvertToUniversal(TTime& aDateTime)

    {

    OPENG_DP(D_OPENG_LIT( " TPresCondValidity::ConvertToUniversal()" ) );

    OPENG_DP(D_OPENG_LIT( "     ConvertToUniversal aDateTime:"));

    LogDateTime(aDateTime.DateTime());

    TLocale myLocale;

    myLocale.Refresh();

    // getting UTC difference    

    TTimeIntervalSeconds uTCseconds = myLocale.UniversalTimeOffset();

    aDateTime = aDateTime - uTCseconds;

    }

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

// TPresCondValidity::ConvertToLocal()

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

//        

void TPresCondValidity::ConvertToLocal(TTime& aDateTime)

    {

    OPENG_DP(D_OPENG_LIT( " TPresCondValidity::ConvertToLocal()" ) );

    OPENG_DP(D_OPENG_LIT( "     ConvertToLocal aDateTime:"));

    LogDateTime(aDateTime.DateTime());

    TLocale myLocale;

    myLocale.Refresh();

    // getting UTC difference    

    TTimeIntervalSeconds uTCseconds = myLocale.UniversalTimeOffset();

    aDateTime = aDateTime + uTCseconds;

    }

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

// TPresCondValidity::LogDateTime()

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

//

void TPresCondValidity::LogDateTime(TDateTime aDateTime)

    {

    OPENG_DP(D_OPENG_LIT( "         %d, %d, %d, %d, %d, %d, %d"),

                    aDateTime.Year(), aDateTime.Month()+1, aDateTime.Day()+1,

                    aDateTime.Hour(), aDateTime.Minute(), aDateTime.Second(),

                                                    aDateTime.MicroSecond() );

    }

// end of file