// Copyright (c) 2001-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:

//

//  INCLUDES

#include "tlbscalculationcheck.h"

#include <e32math.h>

//CONSTANTS

const TReal KAccuracyHigh = 5.96E-8;

const TReal KAccuracyMedium = 4E-5;

const TReal KAccuracyLow = 4E-3;

// C++ default constructor 

T_LbsCalculationCheck::T_LbsCalculationCheck() :

    iErrorCode(KErrArgument),

    iBearingErrorCode(KErrArgument),

    iBearingDeltaErrorCode(KErrArgument),

    iSpeedErrorCode(KErrArgument),

    iMoveErrorCode(KErrArgument)

    {

    TRealX nan;

    nan.SetNaN();

    iDistance=nan;

    }

T_LbsCalculationCheck::T_LbsCalculationCheck(const TPosition& aSourcePosition, const TPosition& aTargetPosition) :

    iSourcePosition(aSourcePosition),

    iTargetPosition(aTargetPosition),

    iErrorCode(KErrArgument),

    iBearingErrorCode(KErrArgument),

    iBearingDeltaErrorCode(KErrArgument),

    iSpeedErrorCode(KErrArgument),

    iMoveErrorCode(KErrNone)

    {

    }

// C++ Constructor TDesC

T_LbsCalculationCheck::T_LbsCalculationCheck(const TDesC& aDes)

    {

    TReal lat1;

    TReal long1;

    TReal lat2;

    TReal long2;

    TReal32 err1=0;

    TReal32 err2=0;

    TReal time1=0;

    TReal time2=0;

    TLex line(aDes);

    line.Mark();

    TInt index=0;

    while (line.Peek() != '\n' && !(line.Peek()).Eos())

        {

        line.Inc();

        if (line.Peek() == '\t')

            {

            TPtrC token = line.MarkedToken();

            TLex val(token);              

            switch(index)

                {

                case ELat1Index:

                    val.Val(lat1, TChar(','));  

                    break;

                case ELong1Index:

                    val.Val(long1, TChar(','));

                    break;

                case ELat2Index:

                    val.Val(lat2, TChar(','));

                    break;

                case ELong2Index:

                    val.Val(long2, TChar(','));

                    break;

                case EErr1Index:

                    val.Val(err1, TChar(','));

                    break;

                case EErr2Index:

                    val.Val(err2, TChar(','));

                    break;

                case ETime1Index:

                    val.Val(time1, TChar(','));

                    break;

                case ETime2Index:

                    val.Val(time2, TChar(','));

                    break;

                case EDistanceIndex:

                    val.Val(iDistance, TChar(','));

                    break;

                case EErrorCodeIndex:

                    val.Val(iErrorCode);

                    break;

                case EDeltaIndex:

                    val.Val(iDelta, TChar(','));

                    break;

                case EBearingIndex:

                    val.Val(iBearing, TChar(','));

                    if (iBearing == 360.0)

                        iBearing = 0.0; 

                    break;

                case EBearingErrorCodeIndex:

                    val.Val(iBearingErrorCode);

                    break;

                case EBearingDelta:

                    val.Val(iBearingDelta, TChar(','));

                    break;

                case EDeltaErrorCode:

                    val.Val(iBearingDeltaErrorCode);

                    break;

                case ESpeedIndex:

                    val.Val(iSpeed, TChar(','));

                    break;

                case ESpeedErrorCodeIndex:

                    val.Val(iSpeedErrorCode);

                    break;

                case ESpeedDeltaIndex:

                    val.Val(iSpeedDelta, TChar(','));

                    break;

                case EMoveErrorCodeIndex:

                    val.Val(iMoveErrorCode);

                    break;

                }    

            line.Inc();

            line.Mark();

            ++index;

            }

        }

    iSourceLocality.SetCoordinate(lat1, long1, 5.0);

    iTargetLocality.SetCoordinate(lat2, long2, 100.0);

    iSourceLocality.SetHorizontalAccuracy(err1);

    iTargetLocality.SetHorizontalAccuracy(err2);

    iSourcePosition.SetCoordinate(lat1, long1, 5.0);

    iTargetPosition.SetCoordinate(lat2, long2, 100.0);

    iSourcePosition.SetHorizontalAccuracy(err1);

    iTargetPosition.SetHorizontalAccuracy(err2);

    TTime ttime1;

    TTime ttime2;

    ttime1.UniversalTime();

    ttime2.UniversalTime(); 

    if ((time1 < 1.0 || time2 < 1.0) && (time1 > -1.0 && time2 > -1.0))

        {

        time1 *= 1000000;    

        time2 *= 1000000;

        ttime1 += TTimeIntervalMicroSeconds((TInt)time1);

        ttime2 += TTimeIntervalMicroSeconds((TInt)time2);

        }

    else

        {

        ttime1 += TTimeIntervalSeconds((TInt)time1);

        ttime2 += TTimeIntervalSeconds((TInt)time2);

        }

    iSourcePosition.SetTime(ttime1);

    iTargetPosition.SetTime(ttime2);   

    }   

TInt T_LbsCalculationCheck::CheckDistance()

    {

    TInt err=0;

    TReal32 distance;

    err = iSourceLocality.Distance(iTargetLocality, distance);

    if (err != iErrorCode)

        {

        iReturnedErrorCode = err;

        return KErrCalculationCheckErrorCode;

        }

    if(!err)

        {

        if (!Equals32(distance, iDistance, KAccuracyHigh))

            {

            iCalculated=distance;

            return KErrCalculationCheckDistance;

            }

        }

    return KErrNone;

    }

TInt T_LbsCalculationCheck::CheckBearing()

    {

    TInt err=0;

    TReal32 bearing;

    err = iSourceLocality.BearingTo(iTargetLocality, bearing);

    if (err != iBearingErrorCode)

        {

        iReturnedErrorCode = err;

        return KErrCalculationCheckErrorCode;

        }

    if(!err)

        {

        TReal accuracy;

        if (bearing < 1 )

            {    

            accuracy=KAccuracyLow;

            }

        else

            {

            accuracy=KAccuracyHigh;

            }

        if (!Equals32(bearing, iBearing, accuracy))

            {

            iCalculated=bearing;

            return KErrCalculationCheckBearing;

            }

        }

    return KErrNone;

    }

TInt T_LbsCalculationCheck::CheckDistanceCoordinate()

    {

    TInt err=0;

    TReal32 distance;

    TCoordinate source(iSourceLocality.Latitude(), iSourceLocality.Longitude());

    TCoordinate target(iTargetLocality.Latitude(), iTargetLocality.Longitude());

    err=source.Distance(target, distance);

    if (err != iErrorCode)

        {

        iReturnedErrorCode = err;

        return KErrCalculationCheckErrorCode;

        }

    if(!err)

        { 

        if (!Equals32(distance, iDistance, KAccuracyHigh))

            {

            iCalculated=distance;

            return KErrCalculationCheckDistance;

            }

        }

    return KErrNone;

    }

TInt T_LbsCalculationCheck::CheckBearingCoordinate()

    {

    TReal32 bearing;

    TCoordinate source(iSourceLocality.Latitude(), iSourceLocality.Longitude());

    TCoordinate target(iTargetLocality.Latitude(), iTargetLocality.Longitude());

    TInt err=0;

    err=source.BearingTo(target, bearing);

    if (err != iBearingErrorCode)

        {

        iReturnedErrorCode = err;

        return KErrCalculationCheckErrorCode;

        }

    if(!err)

        {

        TReal accuracy;

        if (bearing < 1 )

            {    

            accuracy=KAccuracyLow;

            }

        else

            {

            accuracy=KAccuracyHigh;

            }

        if (!Equals32(bearing, iBearing, accuracy))

            {

            iCalculated=bearing;

            return KErrCalculationCheckBearing;

            }

        }

    return KErrNone;

    }

TInt T_LbsCalculationCheck::CheckDistanceDelta()

    {

    TInt err=0;

    TReal32 distance;

    TReal32 delta;

    err = iSourceLocality.Distance(iTargetLocality, distance, delta);

    if (err != iErrorCode)

        {

        iReturnedErrorCode = err;

        return KErrCalculationCheckErrorCode;

        }

    if(!err)

        { 

        if (!Equals32(distance, iDistance, KAccuracyHigh) )

            {

            iCalculated=distance;

            return KErrCalculationCheckDistance;

            }

        if (!Equals32(delta, iDelta, KAccuracyLow))

            {

            iCalculated=delta;

            return KErrCalculationCheckDistanceDelta;

            }

        }

    return KErrNone;

    }

TInt T_LbsCalculationCheck::CheckBearingDelta()

    {

    TReal32 bearing;

    TReal32 delta;

    TInt err=0;

    err = iSourceLocality.BearingTo(iTargetLocality, bearing, delta);

    if (err != iBearingDeltaErrorCode)

        {

        iReturnedErrorCode = err;

        return KErrCalculationCheckErrorCode;

        }

    if(!err)

        {

        TReal accuracy;

        if (bearing < 1 )

            {    

            accuracy=KAccuracyLow;

            }

        else

            {

            accuracy=KAccuracyHigh;

            }

        if (!Equals32(bearing, iBearing, accuracy) )

            {

            iCalculated=bearing;

            return KErrCalculationCheckDistance;

            }

        if (!Equals32(delta, iBearingDelta, KAccuracyHigh))

            {

            iCalculated=delta;

            return KErrCalculationCheckBearingDelta;

            }

        }

    return KErrNone;

    }

TInt T_LbsCalculationCheck::CheckSpeed()

    {

    TInt err=0;

    TReal32 speed;

    err = iSourcePosition.Speed(iTargetPosition, speed);

    if (err != iSpeedErrorCode)

        {

        iReturnedErrorCode = err;

        return KErrCalculationCheckErrorCode;

        }

    if(!err)

        {

        if (!Equals32(speed, iSpeed, KAccuracyHigh))

            {

            iCalculated=speed;

            return KErrCalculationCheckSpeed;

            }

        }

    return KErrNone;    

    }

TInt T_LbsCalculationCheck::CheckSpeedDelta()

    {

    TInt err=0;

    TReal32 speed;

    TReal32 delta;

    err = iSourcePosition.Speed(iTargetPosition, speed, delta);

    if (err != iSpeedErrorCode)

        {

        iReturnedErrorCode = err;

        return KErrCalculationCheckErrorCode;

        }

    if(!err)

        {

        if (!Equals32(speed, iSpeed, KAccuracyHigh))

            {

            iCalculated=speed;

            return KErrCalculationCheckSpeed;

            }

         if (!Equals32(delta, iSpeedDelta, KAccuracyHigh))

            {

            iCalculated=delta;

            return KErrCalculationCheckSpeedDelta;

            }

        }

    return KErrNone;    

    }

TInt T_LbsCalculationCheck::CheckMove()

    {

    TInt err=0;

    TCoordinate source(iSourcePosition.Latitude(), iSourcePosition.Longitude());

    err=source.Move(iBearing, iDistance);

    if (err != iMoveErrorCode)

        {

        iReturnedErrorCode = err;

        return KErrCalculationCheckErrorCode;

        }

    if(!err)

        {

        if (iTargetPosition.Latitude() == 90.0 || iTargetPosition.Latitude() == -90.0)

            {

            if (!Equals32(source.Latitude(), iTargetPosition.Latitude(), KAccuracyMedium))

                {

                iCalcCoordinate=source;

                return KErrCalculationCheckMove;

                }

            }

        else

            {

            if (!Equals32(source.Latitude(), iTargetPosition.Latitude(), KAccuracyMedium) ||

                !Equals32(source.Longitude(), iTargetPosition.Longitude(), KAccuracyMedium))

                {

                iCalcCoordinate=source;

                return KErrCalculationCheckMove;

                }

            }

        }

    return KErrNone;    

    }

TBool T_LbsCalculationCheck::Equals32(const TReal aValue1, const TReal aValue2, const TReal aAccuracy)

    {

    TReal maxAllowedError = aAccuracy;

    TReal maxValue;

    aValue1 > aValue2 ? maxValue=aValue1 : maxValue=aValue2;

    while (maxValue >= 1.0)

        {

        maxValue /= 10.0;

        maxAllowedError *= 10.0;

        }

    TReal absError = Abs(aValue1-aValue2);

    return (absError < maxAllowedError); 

    }

void T_LbsCalculationCheck::GetSourcePosition(TPosition& aSourcePosition) const

    {

    aSourcePosition=iSourcePosition;

    }

void T_LbsCalculationCheck::GetTargetPosition(TPosition& aTargetPosition) const 

    {

    aTargetPosition=iTargetPosition;

    }

void T_LbsCalculationCheck::GetCalcCoordinate(TCoordinate& aCoordinate) const

    {

    aCoordinate=iCalcCoordinate;

    }

TReal T_LbsCalculationCheck::Distance() const

    {

    return iDistance;

    }

TReal T_LbsCalculationCheck::Calculated() const

    {

    return iCalculated;

    }

TReal T_LbsCalculationCheck::Delta() const

    {

    return iDelta;

    }

TReal T_LbsCalculationCheck::BearingDelta() const

    {

    return iBearingDelta;

    }

TInt T_LbsCalculationCheck::ErrorCode() const

    {

    return iErrorCode;

    }

TInt T_LbsCalculationCheck::BearingErrorCode() const

    {

    return iBearingErrorCode;

    }

TInt T_LbsCalculationCheck::SpeedErrorCode() const