/*
* Copyright (c) 2009 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:  Class used to set & get the trigger attributes
*
*/

#include "lbttriggernode.h"
#include "lbtcontextsourceplugindebug.h"


// ---------------------------------------------------------------------------
// TTriggerNode::SetTriggerNameL
// ---------------------------------------------------------------------------
//
void TTriggerNode::SetTriggerNameL( const TPtrC& aTriggerName )
    {
    // Check that the name is not NULL,if Yes then 
    // leave with KErrArgument
    if( aTriggerName == KNullDesC )
        {
        User::Leave( KErrArgument );
        }
    
    // Check that the length of the name is <= 256,if not then
    // extract only upto 256 characters before setting
    if( aTriggerName.Length() > KMaxNameLength )
        {
        iTriggerName.Set( aTriggerName.Mid( 0,KMaxNameLength ) );
        }
    else
        {
        iTriggerName.Set( aTriggerName );
        }
    }

// ---------------------------------------------------------------------------
// TTriggerNode::SetLatitudeL
// ---------------------------------------------------------------------------
//
void TTriggerNode::SetLatitudeL( const TPtrC& aLatitude )
    {
    LBTCONTEXTSOURCEPLUGINDEBUG ( "TTriggerNode::SetLatitudeL - IN" );
    // Check that the value is not NULL
    if( aLatitude == KNullDesC )
        {
        // set value to NaN & leave with KErrArgument
        TRealX nan;
        nan.SetNaN();
        iLatitude = nan;
        User::Leave( KErrArgument );
        }
    
    // Convert the string to TReal64
    // holds the parsed number in text form
    TBuf<KRealWidth> parsedLatitude;
    TLex lexer( aLatitude );
    User::LeaveIfError( lexer.Val( iLatitude,KRealPoint ) );
    // Format the real number to round off to 6 decimal digits
    // initialize the TRealFormat variable 
    TRealFormat realFormat;
    realFormat.iPoint = KRealPoint;
    realFormat.iType = KRealFormatFixed | KDoNotUseTriads;
    realFormat.iPlaces = KCoordinateDecimalPlaces;
    realFormat.iWidth = KRealWidth;
    User::LeaveIfError( parsedLatitude.Num( iLatitude,realFormat ) );
    // convert the formattted string back to TReal64
    TLex lex( parsedLatitude );
    User::LeaveIfError( lex.Val( iLatitude,KRealPoint ) );
    
    // Check the range of the latitude value,if not within range
    // leave with KErrArgument
    if ( !( iLatitude >= KMinLatitude && iLatitude <= KMaxLatitude ) )
        {
        User::Leave( KErrArgument );
        }
    LBTCONTEXTSOURCEPLUGINDEBUG ( "TTriggerNode::SetLatitudeL - OUT" );
    }

// ---------------------------------------------------------------------------
// TTriggerNode::SetLongitudeL
// ---------------------------------------------------------------------------
//
void TTriggerNode::SetLongitudeL( const TPtrC& aLongitude )
    {
    // Check that the value is not NULL
    if( aLongitude == KNullDesC )
        {
        // set value to NaN & leave with KErrArgument
        TRealX nan;
        nan.SetNaN();
        iLatitude = nan;
        User::Leave( KErrArgument );
        }
    
    // Convert the string to TReal64
    // holds the parsed number in text form
    TBuf<KRealWidth> parsedLongitude;
    TLex lexer( aLongitude );
    User::LeaveIfError( lexer.Val( iLongitude,KRealPoint ) );
    // Format the real number to round off to 6 decimal digits
    // initialize the TRealFormat variable 
    TRealFormat realFormat;
    realFormat.iPoint = KRealPoint;
    realFormat.iType = KRealFormatFixed | KDoNotUseTriads;
    realFormat.iPlaces = KCoordinateDecimalPlaces;
    realFormat.iWidth = KRealWidth;
    User::LeaveIfError( parsedLongitude.Num( iLongitude,realFormat ) );
    // convert the formattted string back to TReal64
    TLex lex( parsedLongitude );
    User::LeaveIfError( lex.Val( iLongitude,KRealPoint ) );
    
    // Check the range of the latitude value,if not within range
    // leave with KErrArgument
    if ( !( iLongitude >= KMinLongitude && iLongitude <= KMaxLongitude ) )
        {
        User::Leave( KErrArgument );
        }
    }

// ---------------------------------------------------------------------------
// TTriggerNode::SetRegionL
// ---------------------------------------------------------------------------
//
void TTriggerNode::SetRegionL( const TPtrC& aRegion )
    {
    // Check that the value is not NULL
    if( aRegion == KNullDesC )
        {
        User::Leave( KErrArgument );
        }
    // check that the region specified is a circle,since it is the 
    // only permissible value else leave with KErrArgument
    // Convert the value read from file to lower case inorder to compare
    // the values
    TInt length = aRegion.Length();
    HBufC * buffer = HBufC::NewL( length );
    CleanupStack::PushL( buffer );
    TPtr ptr = buffer->Des();
    ptr.Copy( aRegion );
    ptr.LowerCase();

    if ( ! ( ptr.CompareC( KRegionValue ) ) )
        {
        iRegion.Set( aRegion );
        }
    else
        {
        User::Leave( KErrArgument );
        }
    CleanupStack::PopAndDestroy( buffer );
    }

// ---------------------------------------------------------------------------
// TTriggerNode::SetRadiusL
// ---------------------------------------------------------------------------
//
void TTriggerNode::SetRadiusL( const TPtrC& aRadius )
    {
    // Check that the value is not NULL
    if( aRadius == KNullDesC )
        {
        // set value to NaN & leave with KErrArgument
        TRealX nan;
        nan.SetNaN();
        iRadius = nan;
        User::Leave( KErrArgument );
        }

    // Check the radius value,
    // Minimum radius must be 100 meters
    TLex lex( aRadius );
    TReal radiusValue = 0;
    User::LeaveIfError( lex.Val( radiusValue ) );
    
    // Check that the radius value is positive else leave with KErrArgument
    if( radiusValue < 0 )
        {
        User::Leave( KErrArgument );
        }
    
    if ( radiusValue < KMinRadius )
        {
        iRadius = KMinRadius;
        }
    else
        {
        iRadius = radiusValue;
        }
    }

// ---------------------------------------------------------------------------
// TTriggerNode::SetDirection
// ---------------------------------------------------------------------------
//
void TTriggerNode::SetDirectionL( const TPtrC& aDirection )
    {
    // If the value is null,then set default value to 
    // CLbtTriggerConditionArea::EFireOnEnter
    if( aDirection == KNullDesC )
        {
        iDirection = CLbtTriggerConditionArea::EFireOnEnter;
        }
    
    // Compare the value set in the file with the permissible values
    // If it doesnt match ,then set the default value
    // Convert the value read to lower case to compare the strings
    TInt length = aDirection.Length();
    HBufC * buffer = HBufC::NewL( length );
    TPtr ptr = buffer->Des();
    ptr.Copy( aDirection );
    ptr.LowerCase();

    if( !( ptr.CompareC( KDirectionValueOnEntry ) ) )
        {
        iDirection = CLbtTriggerConditionArea::EFireOnEnter;
        }
    else if( !( ptr.CompareC( KDirectionValueOnExit ) ) )
        {
        iDirection = CLbtTriggerConditionArea::EFireOnExit;
        }
    else
        {
        iDirection = CLbtTriggerConditionArea::EFireOnEnter;
        }
    
    delete buffer;
    }

// ---------------------------------------------------------------------------
// TTriggerNode::SetContextSource
// ---------------------------------------------------------------------------
//
void TTriggerNode::SetContextSource( const TPtrC& aSetName )
    {
    // If the value is null,then set default context source value to "Location"
    if( aSetName == KNullDesC )
        {
        iSetName.Set( KDefaultContextSourceName );
        }
    
    // Check that the length of the name is <= 256,if not then
    // extract only upto 256 characters before setting
    if( aSetName.Length() > KMaxNameLength )
        {
        iSetName.Set( aSetName.Mid( 0,KMaxNameLength ) );
        }
    else
        {
        iSetName.Set(aSetName);
        }
    }

// ---------------------------------------------------------------------------
// TTriggerNode::SetCurrentState
// ---------------------------------------------------------------------------
//
void TTriggerNode::SetCurrentStateL( const TPtrC& aCurrentState )
    {
    // If the value is null,then set default value to 
    // CLbtTriggerEntry::EStateEnabled
    if( aCurrentState == KNullDesC )
        {
        iCurrentState = CLbtTriggerEntry::EStateEnabled;
        }
    
    // Compare the value set in the file with the permissible values
    // If it doesnt match ,then set the default value
    // Convert the value read to lower case to compare the strings
    TInt length = aCurrentState.Length();
    HBufC * buffer = HBufC::NewL( length );
    TPtr ptr = buffer->Des();
    ptr.Copy( aCurrentState );
    ptr.LowerCase();

    if( !( ptr.CompareC( KCurrentStateOn ) ) )
        {
        iCurrentState = CLbtTriggerEntry::EStateEnabled;
        }
    else if( !( ptr.CompareC( KCurrentStateOff ) ) )
        {
        iCurrentState = CLbtTriggerEntry::EStateDisabled;
        }
    else
        {
        iCurrentState = CLbtTriggerEntry::EStateEnabled;
        }
    
    delete buffer;
    }

// ---------------------------------------------------------------------------
// TTriggerNode::GetTriggerName
// ---------------------------------------------------------------------------
//
TInt TTriggerNode::GetTriggerName( TPtrC& aTriggerName )
    {
    if ( iTriggerName == KNullDesC )
        {
        return KErrNotFound;
        }

    aTriggerName.Set( iTriggerName );
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// TTriggerNode::GetLatitude
// ---------------------------------------------------------------------------
//
TInt TTriggerNode::GetLatitude( TReal& aLatitude )
    {
    if ( Math::IsNaN( iLatitude ) ) 
        {
        return KErrNotFound;
        }

    aLatitude = iLatitude;
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// TTriggerNode::GetLongitude
// ---------------------------------------------------------------------------
//
TInt TTriggerNode::GetLongitude( TReal& aLongitude )
    {
    if ( Math::IsNaN( iLongitude ) ) 
        {
        return KErrNotFound;
        }

    aLongitude = iLongitude;
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// TTriggerNode::GetDirection
// ---------------------------------------------------------------------------
//
CLbtTriggerConditionArea::TDirection TTriggerNode::GetDirection()
    {
    return iDirection;
    }



// ---------------------------------------------------------------------------
// TTriggerNode::GetRegion
// ---------------------------------------------------------------------------
//
TInt TTriggerNode::GetRegion( TPtrC& aRegion )
    {
    if ( iRegion == KNullDesC )
        {
        return KErrNotFound;
        }

    aRegion.Set( iRegion );
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// TTriggerNode::GetRadius
// ---------------------------------------------------------------------------
//
TInt TTriggerNode::GetRadius( TReal& aRadius )
    {
    if ( Math::IsNaN( iRadius ) ) 
        {
        return KErrNotFound;
        }

    aRadius = iRadius;
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// TTriggerNode::GetContextSource
// ---------------------------------------------------------------------------
//
TPtrC& TTriggerNode::GetContextSource()
    {
    return iSetName;
    }

// ---------------------------------------------------------------------------
// TTriggerNode::GetCurrentState
// ---------------------------------------------------------------------------
//
CLbtTriggerEntry::TLbtTriggerState TTriggerNode::GetCurrentState()
    {
    return iCurrentState;
    }