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


//  INCLUDES

#include "FT_CPosTp5.h"
#include <EPos_CPosLandmark.h> 
#include <LbsPosition.h>
#include <e32def.h> 
#include <e32std.h> 
#include <e32math.h>


#include "FT_LandmarkConstants.h"

// CONSTANTS
// _LIT(KGetNameErr, "GetLandmarks name returns incorrect error code");
_LIT(KNameErr, "Landmark name is incorrect");
_LIT(KIdErr, "Landmark Id is incorrect");
_LIT(KLongitudeErr, "Longitude is incorrect");

_LIT(KLatitudeErr, "Latitude is incorrect");
_LIT(KHorizontalAccErr, "Horizontal accuracy is incorrect");
_LIT(KVerticalAccErr, "Vertical accuracy is incorrect");
_LIT(KAltitudeErr, "Altitude is incorrect");
_LIT(KNumOfAvailablePositionFieldsErr, "NumOfAvailablePositionFields is incorrect");
_LIT(KNumOfategoriesErr, "Number of categories is incorrect");
_LIT(KCoverageRadiusErr, "CoverageRadius is incorrect"); 
_LIT(KIconIndexErr, "Icon index is incorrect");
_LIT(KIconMaskIndexErr, "Icon MaskIndex is incorrect");
_LIT(KMbmFileNameErr, "MbmFileName is incorrect");
_LIT(KDescriptionErr, "Description is incorrect");
_LIT(KPositionFieldErr, "Error in positions fields");
          
_LIT(KNameTp5, "Lm-Tp5");

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


// ---------------------------------------------------------
// CPosTp5::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp5::StartL()
    { 
    _LIT(KNameTp5, "Lm-Tp5");
    RemoveDefaultDbL();
    CPosLandmark* landmark = CreateLandmarkLC(KNameTp5);
    
    CheckGetMethodsL(landmark);
    
    CheckRemoveMethodsL(landmark);

    CheckFieldsMaxLengthL();

    CleanupStack::PopAndDestroy(); // landmark

    CheckNaNErrorL();
    }

// ---------------------------------------------------------
// CPosTp5::CheckGetMethods
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp5::CheckGetMethodsL(CPosLandmark* aLandmark)
    {
 
    TPtrC landmarkName;
    aLandmark->GetLandmarkName(landmarkName);  
    AssertTrueSecL(landmarkName.Compare(KNameTp5) == KErrNone, KNameErr);
    AssertTrueSecL(aLandmark->LandmarkId() == 0, KIdErr);
    
    CPosLandmarkDatabase* lmd = OpenDatabaseLC();
    TPosLmItemId id=lmd->AddLandmarkL(*aLandmark);
    AssertTrueSecL(aLandmark->LandmarkId() == id, KIdErr);

    TLocality loc2;
    aLandmark->GetPosition(loc2);
    AssertTrueSecL(loc2.Longitude() == KLongitude, KLongitudeErr);
    AssertTrueSecL(loc2.Latitude() == KLatitude, KLatitudeErr);
    AssertTrueSecL(loc2.HorizontalAccuracy() == KHorizontalAcc, KHorizontalAccErr);
    AssertTrueSecL(loc2.VerticalAccuracy() == KVerticalAcc, KVerticalAccErr);
    AssertTrueSecL(loc2.Altitude() == KAltitude, KAltitudeErr);
    
    TReal32 r;
    aLandmark->GetCoverageRadius(r);
    AssertTrueSecL(r == KCoverageRadius, KCoverageRadiusErr);

    TPtrC mbmFileName;
    TInt index;
    TInt indexMask;
    aLandmark->GetIcon(mbmFileName, index, indexMask);
    AssertTrueSecL(mbmFileName.Compare(KMbmFileName) == KErrNone, KMbmFileNameErr);
    AssertTrueSecL(index == KIconIndex, KIconIndexErr);
    AssertTrueSecL(indexMask == KIconMaskIndex, KIconMaskIndexErr);

    TPtrC desc;
    aLandmark->GetLandmarkDescription(desc);
    AssertTrueSecL(desc.Compare(KDescription) == KErrNone, KDescriptionErr);
    AssertTrueSecL(KNoPosFields == aLandmark->NumOfAvailablePositionFields(), KNumOfAvailablePositionFieldsErr);
    
    TPositionFieldId posFieldId = aLandmark->FirstPositionFieldId();
    for (TUint i=0; i<KNoPosFields-1; i++)
        {
        CheckPositionFieldL(*aLandmark, posFieldId);
        posFieldId=aLandmark->NextPositionFieldId(posFieldId);
        }

    RArray<TPosLmItemId> categories;
    CleanupClosePushL(categories);
    aLandmark->GetCategoriesL(categories);
    AssertTrueSecL(categories.Count() == KNoCategories, KNumOfategoriesErr);
    CleanupStack::PopAndDestroy(2,lmd); 
    
   	}

// ---------------------------------------------------------
// CPosTp5::CheckRemoveMethodsL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//    
void CPosTp5::CheckRemoveMethodsL(CPosLandmark* aLandmark)
    {
    aLandmark->RemoveLandmarkAttributes(CPosLandmark::ENoAttribute);
    aLandmark->RemoveLandmarkAttributes(CPosLandmark::EPosition);
    aLandmark->RemoveLandmarkAttributes(CPosLandmark::ECoverageRadius);
    aLandmark->RemoveLandmarkAttributes(CPosLandmark::ECategoryInfo);
    aLandmark->RemoveLandmarkAttributes(CPosLandmark::EIcon);
    aLandmark->RemoveLandmarkAttributes(CPosLandmark::EDescription);
    
    CheckRemovedL(aLandmark);
    _LIT(KLandmarkName, "Nisse");
    CPosLandmark* landmark = CreateLandmarkLC(KLandmarkName);
    landmark->RemoveLandmarkAttributes(CPosLandmark::EAllAttributes);
    CheckRemovedL(landmark);

    
    TUint16 tmp = (TUint16)EPositionFieldMediaLinksStart;
    landmark->RemovePositionField(EPositionFieldMediaLinksStart);
    landmark->RemovePositionField(EPositionFieldCountry);
    landmark->RemovePositionField(EPositionFieldHorizontalSpeed);
    // FrBo Below has been removed
    
    landmark->RemovePositionField(EPositionFieldMediaLinks); 
    landmark->RemovePositionField(EPositionFieldMediaLinksStart); 
    landmark->RemovePositionField(++tmp);
    landmark->RemovePositionField(++tmp);
    landmark->RemovePositionField(EPositionFieldIdLast);
    
    TPtrC ptr;    
    AssertTrueSecL(landmark->GetPositionField(EPositionFieldMediaLinksStart, ptr) == KErrNotFound, KPositionFieldErr);
    AssertTrueSecL(landmark->GetPositionField(EPositionFieldCountry, ptr) == KErrNotFound, KPositionFieldErr);
    AssertTrueSecL(landmark->GetPositionField(EPositionFieldHorizontalSpeed, ptr) == KErrNotFound, KPositionFieldErr);
    // FrBo Below has been removed
    
    AssertTrueSecL(landmark->GetPositionField(EPositionFieldMediaLinks, ptr) == KErrNotFound, KPositionFieldErr); 
    AssertTrueSecL(landmark->GetPositionField(EPositionFieldMediaLinksStart, ptr) == KErrNotFound, KPositionFieldErr); 
    AssertTrueSecL(landmark->GetPositionField(++tmp, ptr) == KErrNotFound, KPositionFieldErr); 
    AssertTrueSecL(landmark->GetPositionField(++tmp, ptr) == KErrNotFound, KPositionFieldErr); 
    AssertTrueSecL(landmark->GetPositionField(EPositionFieldIdLast, ptr) == KErrNotFound, KPositionFieldErr); 
    
    // Remove some non-existing fields, nothing should happen
    landmark->RemovePositionField(6000);
    AssertTrueSecL(landmark->GetPositionField(6000, ptr) == KErrNotFound, KPositionFieldErr); 
    landmark->RemovePositionField(6001);
    AssertTrueSecL(landmark->GetPositionField(6001, ptr) == KErrNotFound, KPositionFieldErr); 

    CleanupStack::PopAndDestroy(); // landmark 
    
    }

// ---------------------------------------------------------
// CPosTp5::CheckRemovedL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp5::CheckRemovedL(CPosLandmark* aLandmark)
    {
    _LIT(KPositionRemovedErr, "GetPosition is not returning an error code when position is not set");
    TLocality loc;
    AssertTrueSecL(aLandmark->GetPosition(loc) == KErrNotFound, KPositionRemovedErr);
   
    RArray<TPosLmItemId> categories;
    CleanupClosePushL(categories);
    aLandmark->GetCategoriesL(categories);
    AssertTrueSecL(categories.Count() == 0, KNumOfategoriesErr);
    CleanupStack::PopAndDestroy(&categories);

    TReal32 r;
    AssertTrueSecL(aLandmark->GetCoverageRadius(r) == KErrNotFound, KCoverageRadiusErr);
    
    TPtrC mbmFileName;
    TInt index;
    TInt indexMask;
    AssertTrueSecL(aLandmark->GetIcon(mbmFileName, index, indexMask) == KErrNotFound, KMbmFileNameErr);

    TPtrC desc;
    AssertTrueSecL(aLandmark->GetLandmarkDescription(desc) == KErrNotFound, KDescriptionErr);
   }

//---------------------------------------------------------
// CPosTp5::CheckPositionFieldIdL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp5::CheckPositionFieldL(const CPosLandmark& aLandmark, const TUint16 aId)
    {
    
    _LIT(KPositionFieldIdErr, "PositionFieldId is incorrect");
    _LIT(KComparePositionFieldValueErr, "PositionField value is different from set value");
    
    TUint16 tmp = (TUint16)EPositionFieldMediaLinksStart;
    TBuf<100> buf;
    buf.Format(_L("Looking for id:%d "),aId);
    iLog->Log(buf);
    
    TPtrC value;
    if (aId == EPositionFieldCountry)
        {
        aLandmark.GetPositionField(aId, value);             
        AssertTrueSecL(value.Compare(KCountry) == KErrNone, KComparePositionFieldValueErr);
        }
    else if (aId == EPositionFieldHorizontalSpeed)
        {
        aLandmark.GetPositionField(aId, value);
        AssertTrueSecL(value.Compare(KHorizontalSpeed) == KErrNone, KComparePositionFieldValueErr);
        }
       
    else if (aId == EPositionFieldMediaLinks)
        {
        aLandmark.GetPositionField(aId, value);
        AssertTrueSecL(value.Compare(KMediaLinks) == KErrNone, KComparePositionFieldValueErr);
        }
    else if (aId == EPositionFieldMediaLinksStart)
        {
        aLandmark.GetPositionField(aId, value);
        AssertTrueSecL(value.Compare(KMediaLink1) == KErrNone, KComparePositionFieldValueErr);
        iLog->Log(_L("EPositionFieldMediaLinksStart"));
        }
    else if (aId == EPositionFieldIdLast)
        {
        aLandmark.GetPositionField(aId, value);
        AssertTrueSecL(value.Compare(KLast) == KErrNone, KComparePositionFieldValueErr);
        }
    else if (aId == (tmp+1))
        {
        aLandmark.GetPositionField(aId, value);
        AssertTrueSecL(value.Compare(KMediaLink2) == KErrNone, KComparePositionFieldValueErr);
        }
    else if(aId == (tmp+2)) 
        {
        aLandmark.GetPositionField(aId, value);
        AssertTrueSecL(value.Compare(KMediaLink3) == KErrNone, KComparePositionFieldValueErr);
        }
    else
        {
        buf.Format(_L("Looking for id: %d %d %d"), aId, (tmp+1), (tmp+2));
        iLog->Log(buf);
        iLog->Log(KPositionFieldIdErr);
        User::Leave(KErrGeneral);
        }
     }

// ---------------------------------------------------------
// CPosTp5::CheckFieldsMaxLength
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp5::CheckFieldsMaxLengthL()
    {

    _LIT(K255Error, "Text field is not limited to 255 characters");
    _LIT(K4095Error, "Description field is not limited to 4095 characters");
    _LIT(KIconError, "Icon File Name field is not limited to correct nr of characters");

    HBufC* hbuf = HBufC::NewLC(4096);
    while(hbuf->Des().Length() < 255)
        {
        hbuf->Des().Append(_L("X"));
        }

    CPosLandmark* landmark = CPosLandmark::NewLC();
    landmark->SetLandmarkNameL(*hbuf);
    landmark->SetLandmarkDescriptionL(*hbuf);      
    landmark->SetPositionFieldL(EPositionFieldCountry, *hbuf);
    hbuf->Des().Append(_L("X"));

    TRAPD(err, landmark->SetLandmarkNameL(*hbuf));
    AssertTrueSecL(err == KErrArgument, K255Error);

    landmark->SetLandmarkDescriptionL(*hbuf);      
    
    TRAP(err, landmark->SetPositionFieldL(EPositionFieldCountry, *hbuf));
    AssertTrueSecL(err == KErrArgument, K255Error);
    
    while(hbuf->Des().Length() < 4095)
       {
        hbuf->Des().Append(_L("X"));
       }
    landmark->SetLandmarkDescriptionL(*hbuf);      
    hbuf->Des().Append(_L("X"));
    TRAP(err, landmark->SetLandmarkDescriptionL(*hbuf));      
    AssertTrueSecL(err == KErrArgument, K4095Error);
    
    CleanupStack::PopAndDestroy(2, hbuf);
    
    // Test setIconL
    // KMaxFileName is defined in e32const.h
    HBufC* icon = HBufC::NewLC(KMaxFileName+1);
    while(icon->Des().Length() < KMaxFileName)
        {
        icon->Des().Append(_L("X"));
        }

    landmark = CPosLandmark::NewLC();
    landmark->SetLandmarkNameL(_L("SomeLandmarkName"));
    landmark->SetLandmarkDescriptionL(_L("SomeLandmarkDescription"));
    landmark->SetIconL(*icon, 1, KPosLmIconMaskNotUsed);
    
    icon->Des().Append(_L("X"));

    TRAP(err, landmark->SetIconL(*icon, 1, KPosLmIconMaskNotUsed));
    AssertTrueSecL(err == KErrArgument, KIconError);
    CleanupStack::PopAndDestroy(landmark);
    CleanupStack::PopAndDestroy(icon); 
    
   
    }

// ---------------------------------------------------------
// CPosTp5::CheckNaNErrorL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp5::CheckNaNErrorL()
    {
    iLog->Log(_L("CheckErrorL"));
    CPosLandmarkDatabase* lmdb = OpenDatabaseLC();
    CPosLandmark* landmark = CPosLandmark::NewLC();
    
    ExecuteAndDeleteLD(lmdb->CompactL());
    TInt errorsFound = KErrNone;
    TRealX NaN;
    NaN.SetNaN();

    // Used for testing SDK:
    // This part should result in log:
    // Not Equal1
    // Not Equal2
    TRealX pos1;
    TRealX pos2;

    iLog->Log(_L("Testing with NaN and 45"));
    pos1.SetNaN();
    pos2 = 45;

    if (pos2 == pos1) 
        iLog->Log(_L("Equal1"));
        else
        iLog->Log(_L("Not Equal1"));

    if (pos2 != pos1) 
        iLog->Log(_L("Not Equal2"));
        else
        iLog->Log(_L("Equal2"));


    iLog->Log(_L("Testing with NaN and 0"));
    pos1.SetNaN();
    pos2 = 0;

    if (pos2 == pos1) 
        iLog->Log(_L("Equal1"));
        else
        iLog->Log(_L("Not Equal1"));

    if (pos2 != pos1) 
        iLog->Log(_L("Not Equal2"));
        else
        iLog->Log(_L("Equal2"));

    iLog->Log(_L("Testing with NaN and NaN"));
    pos1.SetNaN();
    pos2.SetNaN();

    if (pos2 == pos1) 
        iLog->Log(_L("Equal1"));
        else
        iLog->Log(_L("Not Equal1"));

    if (pos2 != pos1) 
        iLog->Log(_L("Not Equal2"));
        else
        iLog->Log(_L("Equal2"));

    landmark->SetLandmarkNameL(_L("TestingLandmarkError"));

    // Only set position with Latitude and Longitude (thus Altitude and Accuracy is NaN)
    TLocality loc;
    loc.SetCoordinate(1,2);
    landmark->SetPositionL(loc);

    TPosLmItemId myId = lmdb->AddLandmarkL(*landmark);
    CleanupStack::PopAndDestroy(landmark);

    //////////////////////////////////////
    // Test Altitude
    landmark = lmdb->ReadLandmarkLC(myId);    
    landmark->GetPosition(loc);

    loc.SetCoordinate(1,2, 123);
    landmark->SetPositionL(loc);

    lmdb->UpdateLandmarkL(*landmark);
    CleanupStack::PopAndDestroy(landmark);

    landmark = lmdb->ReadLandmarkLC(myId);
    TLocality loc3;
    landmark->GetPosition(loc3);

    if (TRealX(loc3.Altitude()).IsNaN())
        {
        iLog->Log(_L("Error: Altitude is Nan"));
        errorsFound++;
        }
    else if (loc3.Altitude() != 123)
        {
        iLog->Log(_L("Error: Incorrect altitude returned"));
        errorsFound++;
        }

    // Reset landmark
    loc.SetCoordinate(1,2, NaN);
    landmark->SetPositionL(loc);
    lmdb->UpdateLandmarkL(*landmark);
    CleanupStack::PopAndDestroy(landmark);

    //////////////////////////////////////
    // Test Horizontal accuracy
    landmark = lmdb->ReadLandmarkLC(myId);
    loc.SetCoordinate(1,2, NaN);
    loc.SetHorizontalAccuracy(12);
    landmark->SetPositionL(loc);

    lmdb->UpdateLandmarkL(*landmark);
    CleanupStack::PopAndDestroy(landmark);

    landmark = lmdb->ReadLandmarkLC(myId);
    landmark->GetPosition(loc3);

    if (TRealX(loc3.HorizontalAccuracy()).IsNaN())
        {
        iLog->Log(_L("Error: Horizontal accuracy is Nan"));
        errorsFound++;
        }
    else if (loc3.HorizontalAccuracy() != 12)
        {
        iLog->Log(_L("Error: Incorrect horizontal accuracy returned"));
        errorsFound++;
        }

    CleanupStack::PopAndDestroy(landmark);

    //////////////////////////////////////
    // Test with NaN for hor acc
    landmark = lmdb->ReadLandmarkLC(myId);
    loc.SetCoordinate(1,2, NaN);
    loc.SetHorizontalAccuracy(NaN);
    landmark->SetPositionL(loc);

    lmdb->UpdateLandmarkL(*landmark);
    CleanupStack::PopAndDestroy(landmark);

    landmark = lmdb->ReadLandmarkLC(myId);
    landmark->GetPosition(loc3);

    if (TRealX(loc3.HorizontalAccuracy()).IsNaN())
        {
        iLog->Log(_L("Horizontal accuracy is correctly set to Nan"));
        }
    else
        {
        iLog->Log(_L("Error: Incorrect horizontal accuracy returned"));
        errorsFound++;
        }

    CleanupStack::PopAndDestroy(landmark);

    //////////////////////////////////////
    // Test Vertical accuracy
    landmark = lmdb->ReadLandmarkLC(myId);
    loc.SetCoordinate(1,2, NaN);
    loc.SetVerticalAccuracy(21);
    landmark->SetPositionL(loc);

    lmdb->UpdateLandmarkL(*landmark);
    CleanupStack::PopAndDestroy(landmark);

    landmark = lmdb->ReadLandmarkLC(myId);
    landmark->GetPosition(loc3);

    if (TRealX(loc3.VerticalAccuracy()).IsNaN())
        {
        iLog->Log(_L("Error: Vertical accuracy is Nan"));
        errorsFound++;
        }
    else if (loc3.VerticalAccuracy() != 21)
        {
        iLog->Log(_L("Error: Incorrect vertical accuracy returned"));
        errorsFound++;
        }

    CleanupStack::PopAndDestroy(landmark);

    //////////////////////////////////////
    // Test landmark description
    landmark = lmdb->ReadLandmarkLC(myId);
    landmark->SetLandmarkDescriptionL(_L("TestingLandmarkErrorDescription"));
    lmdb->UpdateLandmarkL(*landmark);
    CleanupStack::PopAndDestroy(landmark);

    landmark = lmdb->ReadLandmarkLC(myId);
    TPtrC des;
    landmark->GetLandmarkDescription(des);
    TInt res = des.CompareC(_L("TestingLandmarkErrorDescription"));

    if (res != KErrNone)
        {
        iLog->Log(_L("Error: Incorrect description returned"));
        errorsFound++;
        }

    CleanupStack::PopAndDestroy(landmark);

    //////////////////////////////////////
    // Test coverage radius
    landmark = lmdb->ReadLandmarkLC(myId);
    landmark->SetCoverageRadius(15);
    lmdb->UpdateLandmarkL(*landmark);
    CleanupStack::PopAndDestroy(landmark);

    landmark = lmdb->ReadLandmarkLC(myId);
    landmark->GetPosition(loc3);
    TReal32 radius;
    landmark->GetCoverageRadius(radius);
    if (TRealX(radius).IsNaN())
        {
        iLog->Log(_L("Error: Radius is Nan"));
        errorsFound++;
        }
    else if (radius != 15)
        {
        iLog->Log(_L("Error: Incorrect radius returned"));
        errorsFound++;
        }
    //////////////////////////////////////
    CleanupStack::PopAndDestroy(landmark);
    //////////////////////////////////////
    // Test coverage radius, part2
    // Set coverage radius to NaN
    landmark = lmdb->ReadLandmarkLC(myId);
    TRealX nan;
    nan.SetNaN();
    landmark->SetCoverageRadius(nan);
    lmdb->UpdateLandmarkL(*landmark);
    CleanupStack::PopAndDestroy(landmark);

    landmark = lmdb->ReadLandmarkLC(myId);
    landmark->GetPosition(loc3);

    res = landmark->GetCoverageRadius(radius);
    if (res != KErrNotFound)
        {
        iLog->Log(_L("Error: GetCoverageRadius should return KErrNotFound when set to NaN"));
        errorsFound++;
        }
    //////////////////////////////////////
    CleanupStack::PopAndDestroy(landmark);    
    
    CleanupStack::PopAndDestroy(lmdb);

    if (errorsFound != KErrNone)
        {
        
        iLog->Log(_L("Errors found in part CheckNaNErrorL()"));
        User::Leave(-1);
        }
       
    }