// 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:
// Example CTestStep derived implementation
// 
//

/**
 @file CalculationMethodsStep.cpp
 @internalTechnology
*/
#include "calculationmethodsstep.h"
#include "te_lbsapisuitedefs.h"

#include "lcfsbucommondefinitions.h"

#include <lbs.h>
#include <lbssatellite.h>

CCalculationMethodsStep::~CCalculationMethodsStep()
/**
 * Destructor
 */
	{
	}

CCalculationMethodsStep::CCalculationMethodsStep()
/**
 * Constructor
 */
	{
	// **MUST** call SetTestStepName in the constructor as the controlling
	// framework uses the test step name immediately following construction to set
	// up the step's unique logging ID.
	SetTestStepName(KCalculationMethodsStep);
	}

TVerdict CCalculationMethodsStep::doTestStepPreambleL()
/**
 * @return - TVerdict code
 * Override of base class virtual
 */
	{
	CTe_LbsApiSuiteStepBase::doTestStepPreambleL();
	if (TestStepResult()!=EPass)
		return   TestStepResult();
	// process some pre setting to this test step then set SetTestStepResult to EFail or Epass.
	SetTestStepResult(EPass);
	return TestStepResult();
	}


TVerdict CCalculationMethodsStep::doTestStepL()
/**
 * @return - TVerdict code
 * Override of base class pure virtual
 * Our implementation only gets called if the base class doTestStepPreambleL() did
 * not leave. That being the case, the current test result value will be EPass.
 */
	{
	  if (TestStepResult()==EPass)
		{
		TInt test;
		if(!GetIntFromConfig(ConfigSection(),KTe_LbsApiSuiteInt,test)
			)
			{
			// Leave if there's any error.
			User::Leave(KErrNotFound);
			}
		SetTestStepResult(EPass);
		StartL(test);
		}
	  return TestStepResult();
	}



TVerdict CCalculationMethodsStep::doTestStepPostambleL()
/**
 * @return - TVerdict code
 * Override of base class virtual
 */
	{
	// process something post setting to the test step
	// uncomment the following line if you have common post setting to all the test steps in there
	// CTe_LbsApiVariant2SuiteStepBase::doTestStepPostambleL();
	// uncomment the following line if you have post process or remove the following line if no post process
	// SetTestStepResult(EPass);		// or EFail
	return TestStepResult();
	}


void CCalculationMethodsStep::StartL(TInt aIndex)
	{
	switch(aIndex)
		{
		case 0:
			Calculation_InvalidL();
			break;
		case 1:
			Calculation_BasicsL();
			break;
		case 2:
			Calculation_TCoordinate_MoveBigL();
			break;
		}
	}


#define REPORT_REAL(_real) \
    report.Format(_L("%15.9f"), _real); \
    LOG_DES(report);

#define REPORT_REAL_16(_real) \
    report.Format(_L("%22.16f"), _real); \
    LOG_DES(report);

#define REPORT_REAL_G(_real) \
    report.Format(_L("%10g"), _real); \
    LOG_DES(report);

#define REPORT_CRLF \
    report.Format(_L("\n")); \
    LOG_DES(report);

#define REPORT_TAB \
    report.Format(_L("\t")); \
    LOG_DES(report);

//
//
// TCoordinate
//
//

void CCalculationMethodsStep::Calculation_BasicsL()
    {
    DECLARE_ERROR_LOGGING;
    StandardPrepareL();
    
    TRealX nan;
    nan.SetNaN();

    const TReal tlat = 10, tlon = 20, acc1 = 5, acc2 = 15;
    TReal32 distance, bearing, delta, speed;

    TCoordinate sCoord, tCoord, zero(0,0), target(tlat, tlon);
    TLocality sLoc, tLoc;
    TPosition sPos, tPos;

    //
    // 1. TCoordinate
    
    sCoord.SetCoordinate(0, 0);
    tCoord.SetCoordinate(tlat, tlon);
    
    CHECK(sCoord.Distance(tCoord, distance) == KErrNone);
    CHECK(sCoord.Distance(sCoord, distance) == KErrNone);
    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrNone);
    CHECK(sCoord.Move(distance, bearing) == KErrNone);
    CHECK(sCoord.Move(distance, bearing) == KErrNone);

    //
    // 2. TLocality
    
    sLoc = TLocality(zero, acc1);
    tLoc = TLocality(target, acc2);

    CHECK(sLoc.Distance(tCoord, distance) == KErrNone);
    CHECK(sLoc.Distance(sCoord, distance) == KErrNone);
    CHECK(sLoc.Distance(tLoc, distance, delta) == KErrNone);
    CHECK(sLoc.Distance(sLoc, distance, delta) == KErrNone);
    CHECK(sLoc.BearingTo(tCoord, bearing) == KErrNone);
    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrNone);

    //
    // 2. TPosition

    TTime time1, time2;
    time1.UniversalTime();
    time2 = time1 + TTimeIntervalMinutes(60);

    sPos = TPosition(sLoc, time1);
    tPos = TPosition(tLoc, time2);

    CHECK(sPos.Speed(tPos, speed) == KErrNone);
    CHECK(sPos.Speed(TPosition(sLoc, time2), speed) == KErrNone);
    CHECK(sPos.Speed(tPos, speed, delta) == KErrNone);
    CHECK(sPos.Speed(TPosition(sLoc, time2), speed, delta) == KErrNone);

    StandardCleanup();
    }
    
void CCalculationMethodsStep::Calculation_InvalidL()
    {
    DECLARE_ERROR_LOGGING;
    StandardPrepareL();
    
    TRealX nan;
    nan.SetNaN();
    
    const TReal lat = 10, lon = 20, acc = 5;
    const TReal32 dist = 1000, bear = 60;
    
    const TCoordinate zeroCoord(0, 0), north(90, 0), south(-90, 0);
    
    enum ENanParam
        {
        LAT, LON, ACC,
        };

    const TCoordinate nanCoord[] = 
        {
        TCoordinate(nan, lon),
        TCoordinate(lat, nan)
        };

    const TLocality nanLoc[] = 
        {
        TLocality(nanCoord[LAT], acc),
        TLocality(nanCoord[LON], acc),
        TLocality(zeroCoord, nan)
        };

    //
    // 1. TCoordinate
    
    TCoordinate sCoord, tCoord;
    TReal32 distance, bearing;

    // NaN in Distance, BearingTo, Move

    tCoord = zeroCoord;

    sCoord = nanCoord[LAT];
    CHECK(sCoord.Distance(tCoord, distance) == KErrArgument);
    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrArgument);
    CHECK(sCoord.Move(dist, bear) == KErrArgument);

    sCoord = nanCoord[LON];
    CHECK(sCoord.Distance(tCoord, distance) == KErrArgument);
    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrArgument);
    CHECK(sCoord.Move(dist, bear) == KErrArgument);

    sCoord = zeroCoord;

    tCoord = nanCoord[LAT];
    CHECK(sCoord.Distance(tCoord, distance) == KErrArgument);
    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrArgument);

    tCoord = nanCoord[LON];
    CHECK(sCoord.Distance(tCoord, distance) == KErrArgument);
    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrArgument);
    
    // Incalculable cases
    
    // poles
    tCoord = zeroCoord;

    sCoord = north;
    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrPositionIncalculable);
    CHECK(sCoord.Move(dist, bear) == KErrPositionIncalculable);

    sCoord = south;
    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrPositionIncalculable);
    CHECK(sCoord.Move(dist, bear) == KErrPositionIncalculable);
    
    // same coords
    sCoord = tCoord = zeroCoord;
    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrPositionIncalculable);
    
    // antipodal
    tCoord.SetCoordinate(-zeroCoord.Latitude(), zeroCoord.Longitude() + 180);
    CHECK(sCoord.BearingTo(tCoord, bearing) == KErrPositionIncalculable);

    //
    // 2. TLocality
    
    TLocality sLoc, tLoc;
    TReal32 delta;

    // NaN in Distance and BearingTo

    tLoc = TLocality(zeroCoord, acc);

    sLoc = nanLoc[LAT];
    CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument);
    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument);

    sLoc = nanLoc[LON];
    CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument);
    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument);

    sLoc = nanLoc[ACC];
    CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument);
    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument);

    sLoc = TLocality(zeroCoord, acc);

    tLoc = nanLoc[LAT];
    CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument);
    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument);

    tLoc = nanLoc[LON];
    CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument);
    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument);
    
    tLoc = nanLoc[ACC];
    CHECK(sLoc.Distance(tLoc, distance, delta) == KErrArgument);
    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrArgument);
    
    // Incalculable cases
    
    // 1 latitude degree is about 117 km
    const TReal32 circle = 200 * 1000;
    
    // pole in error circle
    sLoc = TLocality(TCoordinate(89, 0), circle); 
    tLoc = TLocality(zeroCoord, 0);
    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrPositionIncalculable);
    
    // overlapping error circles
    sLoc = TLocality(TCoordinate(1, 0), circle);
    tLoc = TLocality(TCoordinate(-1, 0), circle);
    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrPositionIncalculable);

    // overlapping error circles if target is antipodal
    sLoc = TLocality(TCoordinate(1, 0), circle);
    tLoc = TLocality(TCoordinate(1, 180), circle); // antipodal is (-1, 0)
    CHECK(sLoc.BearingTo(tLoc, bearing, delta) == KErrPositionIncalculable);

    //
    // 3. TPosition
    
    TPosition sPos, tPos;
    TReal32 speed;
    
    // Nan in Speed methods
    TTime time1, time2;
    time1.UniversalTime();
    time2 = time1 + TTimeIntervalMinutes(60);
    
    tPos = TPosition(TLocality(zeroCoord, acc), time2);

    sPos = TPosition(nanLoc[LAT], time1);
    CHECK(sPos.Speed(tPos, speed) == KErrArgument);
    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);

    sPos = TPosition(nanLoc[LON], time1);
    CHECK(sPos.Speed(tPos, speed) == KErrArgument);
    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);

    sPos = TPosition(nanLoc[ACC], time1);
    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);
    
    sPos = TPosition(TLocality(zeroCoord, acc), time1);

    tPos = TPosition(nanLoc[LAT], time2);
    CHECK(sPos.Speed(tPos, speed) == KErrArgument);
    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);

    tPos = TPosition(nanLoc[LON], time2);
    CHECK(sPos.Speed(tPos, speed) == KErrArgument);
    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);

    tPos = TPosition(nanLoc[ACC], time2);
    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);
    
    // Zero time

    sPos = TPosition(TLocality(zeroCoord, acc), 0);
    tPos = TPosition(TLocality(zeroCoord, acc), time2);
    CHECK(sPos.Speed(tPos, speed) == KErrArgument);
    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);

    sPos = TPosition(TLocality(zeroCoord, acc), time1);
    tPos = TPosition(TLocality(zeroCoord, acc), 0);
    CHECK(sPos.Speed(tPos, speed) == KErrArgument);
    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);
    
    // Same time

    sPos = TPosition(TLocality(zeroCoord, acc), time1);
    tPos = TPosition(TLocality(zeroCoord, acc), time1);
    CHECK(sPos.Speed(tPos, speed) == KErrArgument);
    CHECK(sPos.Speed(tPos, speed, delta) == KErrArgument);

    StandardCleanup();
    }




TReal32 NextReal32Value(TReal32 aReal32)
	{
    TInt32* pint32 = (TInt32*) &(aReal32);
    (*pint32) = (*pint32) + 1; // works ok only if increment does not touch exponent!!!
    return *((TReal32*) pint32);
	}

TReal32 PrevReal32Value(TReal32 aReal32)
	{
    TInt32* pint32 = (TInt32*) &(aReal32);
    (*pint32) = (*pint32) - 1; // works ok only if decrement does not touch exponent!!!
    return *((TReal32*) pint32);
	}

void CCalculationMethodsStep::Calculation_TCoordinate_MoveBigL()
	{
    DECLARE_ERROR_LOGGING;
    StandardPrepareL();
    
    TBuf<256> report;
    const TReal32 KEarthRadius = 6371010;
    const TReal32 KAccuracy = 0.1;

    TInt bearing;
    TReal32 alpha, arc = 2*KPi*KEarthRadius;
    TCoordinate center(0,0), farPoint, closePoint, diff;

    _LIT(KHeader, "=== TCoordinate::Move() test for big distances ===\n");
    INFO_PRINTF1(KHeader);
    
    for (int lon = -180; lon < 180; lon += 60)
    	{
        center = TCoordinate(0, lon);

        report.Format(_L("Center = (%f,%f), Arc(m) = %g(%g)\n"),
                center.Latitude(), center.Longitude(), arc, NextReal32Value(arc));

        for (bearing = 0; bearing < 360; bearing +=60)
        	{
            for (alpha = 0; alpha < 180; alpha += 30)
            	{
                farPoint = closePoint = center;

                TReal32 smallDistance = alpha * KDegToRad * KEarthRadius;
                closePoint.Move(bearing, smallDistance);

                TReal bigDistance = ((2*KPi) - alpha*KDegToRad) * KEarthRadius;
                farPoint.Move(bearing + 180, bigDistance);

                diff = TCoordinate(closePoint.Latitude() - farPoint.Latitude(),
                                   closePoint.Longitude() - farPoint.Longitude());

                if ((Abs(diff.Latitude()) > KAccuracy) ||
                    (Abs(diff.Longitude()) > KAccuracy))
                	{
                    report.Format(_L("Alpha %g\n"), alpha);
                    LOG_DES(report);

                    _LIT(KBearingDistance, "\tBearing %3d, Dist(m) %g: (%f;%f)\n");
                    report.Format(KBearingDistance, bearing, smallDistance, closePoint.Latitude(), closePoint.Longitude());
                    LOG_DES(report);

                    report.Format(KBearingDistance, bearing + 180, bigDistance, farPoint.Latitude(), farPoint.Longitude());
                    LOG_DES(report);

                    report.Format(_L("\tDiff (%f;%f)\n"), diff.Latitude(), diff.Longitude());
                    LOG_DES(report);
                	}
            	}
        	}
    	}

    _LIT(KFooter, "=== TCoordinate::Move() test done ===\n");
    INFO_PRINTF1(KFooter);
    
    StandardCleanup();
	}