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

//

// INCLUDE FILES

#include <e32math.h>

#include <lbspositioninfo.h>

#include "EPos_TPosDataSimulator.h"

#include "EPos_TDesTokeniser.h"

#include "EPos_SimPsyConstants.h"

// CONSTANTS

const TUint8 KPosDataSeparator = '=';

const TUint8 KPosDefaultDataEndMarker = ';';

_LIT8(KHacc, "Horizontal accuracy");

_LIT8(KVacc, "Vertical accuracy");

_LIT8(KPowerupTime, "Powerup time");

_LIT8(KLongitude, "Longitude");

_LIT8(KLatitude, "Latitude");

_LIT8(KSpeed, "Speed");

_LIT8(KCourse, "Course");

_LIT8(KRandom, "Random");

_LIT8(KDeterministic, "Deterministic");

_LIT8(KTimeToFixMin, "TimeToFix min");

_LIT8(KTimeToFixMax, "TimeToFix max");

// ================= MEMBER FUNCTIONS =======================

// C++ default constructor can NOT contain any code, that

// might leave.

//

TPosDataSimulator::TPosDataSimulator() :

    iHAcc(0),

    iVAcc(0),

    iLonErrorRadius(0),

    iLatErrorRadius(0),

    iErrorAngle(0),

    iSpeed(0),

    iTrueCourse(0),

    iOrigLatitude(0),

    iOrigLongitude(0),

    iLatitude(0),

    iLongitude(0),

    iAltError(0),

    iPowerupTime(0),

    iRandomMode(EFalse),

    iTTFMin(0),

    iTTFMax(0),

    iFailFrequency(0),

    iRandomTTF(0),

    iSeed(0)

    {

    TTime time;

    time.UniversalTime();

    iSeed = time.Int64();

    }

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

// TPosDataSimulator::ComputeNewPositionL

//

// (other items were commented in a header).

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

//

TInt TPosDataSimulator::ComputeNewPositionL(

    TPosition& aPosition,

    const TTime& aRequestStartTime,

    const TTime& aLastRequestTime)

    {

    if (iSpeed != 0)

        {

        TReal cHdng1;

        TReal cLat1;

        TReal sAlpha;

        TReal sLat1;

        TReal cAlpha;

        TReal latitude = aPosition.Latitude() - iLatErrorRadius;

        TReal delay = (static_cast<TReal>

            (aRequestStartTime.MicroSecondsFrom(aLastRequestTime).

            Int64()))/KToSeconds;

        if (delay == 0)

            {

            delay = 1;

            }

        TReal alpha = (iSpeed*delay)/KEarthRadius;

        // Compute new latitude

        User::LeaveIfError(Math::Cos(cHdng1, iTrueCourse * KToRadians));

        User::LeaveIfError(Math::Cos(cLat1,  latitude * KToRadians));

        User::LeaveIfError(Math::Sin(sAlpha, alpha));

        User::LeaveIfError(Math::Sin(sLat1,  latitude * KToRadians));

        User::LeaveIfError(Math::Cos(cAlpha, alpha));

        TReal sLat2 = cHdng1 * cLat1 * sAlpha + sLat1 * cAlpha;

        TReal lat2;

        User::LeaveIfError(Math::ASin(lat2, sLat2));

        iLatitude = lat2 * KToDegrees;

        // Compute new longitude

        TReal cLat2;

        User::LeaveIfError(Math::Cos(cLat2, lat2));

        TReal tmp =(cAlpha - sLat1 * sLat2) / (cLat1 * cLat2);

        TReal newLong;

        ModifyCosArgIfNeeded(tmp);

        User::LeaveIfError(Math::ACos(newLong, tmp));

        newLong *= KToDegrees;

        // newLong will always be positive. If the course indicates that

        // longitude should be decreased (sin(course) < 0), the sign should

        // be changed.

        TReal sCourse;

        User::LeaveIfError(Math::Sin(sCourse, iTrueCourse * KToRadians));

        if (sCourse < 0)

            {

            newLong = -newLong;

            }

        iLongitude = aPosition.Longitude() + newLong;

        LongitudeBoundsCheck(iLongitude);

        ComputeNewErrorForLatLonAltL(iLatitude, iLongitude,

            iLatitude, iLongitude);

        // Compute new course

        TReal newCourse;

        tmp = (sLat1 - sLat2*cAlpha) / (cLat2 * sAlpha);

        ModifyCosArgIfNeeded(tmp);

        User::LeaveIfError(Math::ACos(newCourse, tmp));

        newCourse *= KToDegrees;

        }

    else

        {

        ComputeNewErrorForLatLonAltL(iOrigLatitude, iOrigLongitude,

            iLatitude, iLongitude);

        }

    // Set position

    aPosition.SetCoordinate(iLatitude, iLongitude, iAltError);

    aPosition.SetAccuracy(iHAcc, iVAcc);

    return KErrNone;

    }

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

// TPosDataSimulator::ParseAndCreatePosObjectL

//

// (other items were commented in a header).

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

//

void TPosDataSimulator::ParseAndCreatePosObjectL(

    TPosition& aPosition,

    const CDesC8Array* aDataArray)

    {

    TInt itemsFound = 0;

    for (TInt i = 0; i < aDataArray->Count(); i++)

        {

        TDesTokeniser tokeniser(aDataArray->MdcaPoint(i));

        TPtrC8 field = tokeniser.NextToken(KPosDataSeparator);

        TPtrC8 value = tokeniser.NextToken(KPosDefaultDataEndMarker);

        // trim any trailing spaces off the field:

        const TText8* first = field.Ptr();

        const TText8* last = first + field.Length() - 1;

        while ((last >= first) && TChar(*last).IsSpace() )

        	{

        	last--;

        	}

        TUint8 len = (last + 1 - first);

        TPtrC8  fieldTrimmed(first, len);   

        if (fieldTrimmed.MatchF(KHacc) == 0)

            { // {float} 0 -

            LeaveIfNegativeRealL(value);

            iHAcc = DesToFloatL(value);

            itemsFound++;

            }

        else if (fieldTrimmed.MatchF(KVacc) == 0)

            { // {float} 0 -

            LeaveIfNegativeRealL(value);

            iVAcc = DesToFloatL(value);

            itemsFound++;

            }

        else if (fieldTrimmed.MatchF(KTimeToFixMin) == 0)

            { // {integer} 0 -

            LeaveIfNegativeIntL(value);

            iTTFMin = DesToIntL(value);

            itemsFound++;

            }

        else if (fieldTrimmed.MatchF(KTimeToFixMax) == 0)

            { // {integer} 0 -

            LeaveIfNegativeIntL(value);

            iTTFMax = DesToIntL(value);

            itemsFound++;

            }

        else if (fieldTrimmed.MatchF(KPowerupTime) == 0)

            { // {integer} 0 -

            LeaveIfNegativeIntL(value);

            iPowerupTime = DesToIntL(value);

            itemsFound++;

            }

        else if (fieldTrimmed.MatchF(KLongitude) == 0)

            { // {float} - 180 - 180

            CheckLatLonBoundariesL(value, TReal(180));

            iOrigLongitude = DesToRealL(value);

            LongitudeBoundsCheck(iOrigLongitude);

            itemsFound++;

            }

        else if (fieldTrimmed.MatchF(KLatitude) == 0)

            { // {float} - 90 - 90

            CheckLatLonBoundariesL(value, TReal(90));

            iOrigLatitude = DesToRealL(value);

            if (iOrigLatitude == 90 || iOrigLatitude == -90)

                {

                iOrigLatitude = 89.9999;

                }

            itemsFound++;

            }

        else if (fieldTrimmed.MatchF(KSpeed) == 0)

            { // {float} 0 -

            LeaveIfNegativeRealL(value);

            // Speed NOT used in current supported classes

            iSpeed = DesToFloatL(value);

            itemsFound++;

            }

        else if (fieldTrimmed.MatchF(KCourse) == 0)

            { // {float} 0 - 360

            // TrueCourse NOT used in current supported classes

            CheckCourseBoundariesL(value);

            iTrueCourse = DesToFloatL(value);

            itemsFound++;

            }

        else if (fieldTrimmed.MatchF(KRandom) == 0)

            { // {integer} 0 -

            LeaveIfNegativeIntL(value);

            iFailFrequency = DesToIntL(value);

            iRandomMode = ETrue;

            itemsFound++;

            }

        else if (fieldTrimmed.MatchF(KDeterministic) == 0)

            { // {integer} 0 -

            LeaveIfNegativeIntL(value);

            iFailFrequency = DesToIntL(value);

            iRandomMode = EFalse;

            itemsFound++;

            }

        }

    if (itemsFound != KNoOfSimulatedDataItems)

        {

        User::Leave(KErrCorrupt);

        }

    aPosition.SetCoordinate(iOrigLatitude, iOrigLongitude, iAltError);

    aPosition.SetAccuracy(iHAcc, iVAcc);

    }

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

// TPosDataSimulator::TimeToWait

//

// (other items were commented in a header).

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

//

TTimeIntervalMicroSeconds TPosDataSimulator::TimeToWait(

    const TTime& aRequestStartTime)

    {

    // 500 ms as execution time after wait.

    //

    TInt executionTimeAfterWait = 500000;

    TInt timetowait = iTTFMin;

    iRandomTTF = (iTTFMin + (Math::Rand(iSeed) % (iTTFMax-iTTFMin+1)))

        * KToMicroSeconds;

    TTime now;

    now.UniversalTime();

    TInt delay = I64INT(now.MicroSecondsFrom(aRequestStartTime).Int64());

    if (delay < iRandomTTF)

        {

        timetowait = Min(iTTFMax * KToMicroSeconds - executionTimeAfterWait,

                        Max(iTTFMin * KToMicroSeconds + executionTimeAfterWait,

                            iRandomTTF - delay));

        }

    else

        {

        timetowait = Max(iTTFMin * KToMicroSeconds + executionTimeAfterWait,

            iRandomTTF - delay);

        }

    return TTimeIntervalMicroSeconds(TInt64(timetowait));

    }

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

// TPosDataSimulator::FailThisRequest

//

// (other items were commented in a header).

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

//

TInt TPosDataSimulator::FailThisRequest(TInt aNumberOfRequests)

    {

    TInt err = KErrNone;

    if (iFailFrequency != 0)

        {

        if (iRandomMode)

            {

            TInt randomNum = Math::Rand(iSeed);

            TInt res = KMaxTInt/iFailFrequency;

            if (randomNum < res)

                {

                err = KErrorCodeForFailedRequest;

                }

            }

        else

            {

            if (aNumberOfRequests % iFailFrequency == 0)

                {

                err = KErrorCodeForFailedRequest;

                }

            }

        }

    return err;

    }

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

// TPosDataSimulator::PowerupTime

//

// (other items were commented in a header).

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

//

TTimeIntervalMicroSeconds TPosDataSimulator::PowerupTime()

    {

    TInt powerUp = iPowerupTime * KToMicroSeconds;

    return TTimeIntervalMicroSeconds(TInt64(powerUp));

    }

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

// TPosDataSimulator::GetRandomError

//

// (other items were commented in a header).

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

//

TReal TPosDataSimulator::GetRandomError()

    {

    TReal error = 0;

    for (TInt j = 0; j < KTimesToRandom; j++)

        {

        error += Math::FRand(iSeed);

        }

    error -= KTimesToRandom/2;

    return error;

    }

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

// TPosDataSimulator::ComputeNewErrorForLatLonAltL

//

// (other items were commented in a header).

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

//

void TPosDataSimulator::ComputeNewErrorForLatLonAltL(

    TReal& aFromLatitude,

    TReal& aFromLongitude,

    TReal& aToLatitude,

    TReal& aToLongitude)

    {

    // Add random error to lon and lat

    // Latitude

    TReal error = GetRandomError();

    error *= iHAcc;

    iLatErrorRadius = (error * 360) / (2 * KEarthRadius * KPi);

    // Longitude

    error = GetRandomError();

    error *= iHAcc;

    iLonErrorRadius = (error * 360) / (2 * KEarthRadius * KPi);

    // Angle

    TReal rand = Math::FRand(iSeed);

    iErrorAngle = rand * 360;

    TReal cosAlpha;

    User::LeaveIfError(Math::Cos(cosAlpha, iErrorAngle * KToRadians));

    TReal sinAlpha;

    User::LeaveIfError(Math::Sin(sinAlpha, iErrorAngle * KToRadians));

    // Add error to latitude

    aToLatitude = aFromLatitude + iLatErrorRadius * sinAlpha;

    // Add error to longitude

    aToLongitude = aFromLongitude + iLonErrorRadius * cosAlpha;

    // Add random error to altitude

    iAltError = (TReal32) GetRandomError();

    iAltError *= iVAcc;

    }

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

// TPosDataSimulator::DesToIntL

//

// (other items were commented in a header).

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

//

TInt TPosDataSimulator::DesToIntL(const TDesC8& aDes)

    {

    TLex8   lexer(aDes);

    TInt    integer;

    User::LeaveIfError(lexer.Val(integer));

    return integer;

    }

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

// TPosDataSimulator::DesToFloatL

//

// (other items were commented in a header).

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

//

TReal32 TPosDataSimulator::DesToFloatL(const TDesC8& aDes)

    {

    TLex8       lexer(aDes);

    TReal32     floatNumber;

    User::LeaveIfError(lexer.Val(floatNumber, TChar('.')));

    return floatNumber;

    }

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

// TPosDataSimulator::DesToRealL

//

// (other items were commented in a header).

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

//

TReal TPosDataSimulator::DesToRealL(const TDesC8& aDes)

    {

    TLex8 lexer(aDes);

    TReal realNumber;

    User::LeaveIfError(lexer.Val(realNumber, TChar('.')));

    return realNumber;

    }

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

// TPosDataSimulator::LeaveIfNegativeIntL

//

// (other items were commented in a header).

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

//

void TPosDataSimulator::LeaveIfNegativeIntL(const TDesC8& aDes)

    {

    TLex8 lexer(aDes);

    TInt  number;

    User::LeaveIfError(lexer.Val(number));

    if (number < 0)

        {

        User::Leave(KErrCorrupt);

        }

    CheckEosL(lexer);

    }

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

// TPosDataSimulator::LeaveIfNegativeRealL

//

// (other items were commented in a header).

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

//

void TPosDataSimulator::LeaveIfNegativeRealL(const TDesC8& aDes)

    {

    TLex8 lexer(aDes);

    TReal  number;

    User::LeaveIfError(lexer.Val(number, TChar('.')));

    if (number < 0)

        {

        User::Leave(KErrCorrupt);

        }

    CheckEosL(lexer);

    }

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

// TPosDataSimulator::CheckLatLonBoundariesL

//

// (other items were commented in a header).

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

//

void TPosDataSimulator::CheckLatLonBoundariesL(

    const TDesC8& aDes, TReal aMinMaxValue)

    {

    TLex8 lexer(aDes);

    TReal lat;

    User::LeaveIfError(lexer.Val(lat, TChar('.')));

    if (lat < -aMinMaxValue || lat > aMinMaxValue)

        {

        User::Leave(KErrCorrupt);

        }

    CheckEosL(lexer);

    }

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

// TPosDataSimulator::CheckEosL

//

// (other items were commented in a header).

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

//

void TPosDataSimulator::CheckEosL(TLex8& aLexer)

    {

    aLexer.SkipSpace();

    if (!aLexer.Eos())

        {

        User::Leave(KErrCorrupt);

        }

    }

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

// TPosDataSimulator::CheckCourseBoundariesL

//

// (other items were commented in a header).

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

//

void TPosDataSimulator::CheckCourseBoundariesL(

    const TDesC8& aDes)