/*
* Copyright (c) 2006 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:  CMnrpEngine class implementation
*
*/


#include <coemain.h>
#include <aknlists.h>
#include <barsread2.h>
#include <barsc2.h> 

#include <lbsposition.h>
#include <lbspositioninfo.h>

#include <EPos_CPosLandmark.h>
#include <EPos_CPosLandmarkDatabase.h>

#include <mnrefproviderengine.rsg>

#include "../inc/debug.h"
#include "mnrpengine.h"

_LIT( KCitiesResourceFile, "\\resource\\mnrefproviderengine.rsc");

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

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CMnrpEngine::CMnrpEngine()
    { 
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C CMnrpEngine::~CMnrpEngine()
    {
    iPlaces.ResetAndDestroy();
    iFileSession.Close();
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C CMnrpEngine* CMnrpEngine::NewL()
    {
    CMnrpEngine* self = new (ELeave) CMnrpEngine();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CMnrpEngine::ConstructL()
    {
    User::LeaveIfError( iFileSession.Connect() );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C TArray<CPosLandmark*> CMnrpEngine::KnownPlacesL()
    {
    if ( iPlaces.Count() == 0 )
        {
        TRAP_IGNORE( LoadKnownPlacesL() );
        }

    return iPlaces.Array();        
    }
    
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C CPosLandmark* CMnrpEngine::AddressToCoordLC( const CPosLandmark& aAddress )
    {
    CPosLandmark* lm = AddressToCoordL( aAddress );
    if ( lm )
        {
        CleanupStack::PushL( lm );
        return lm;
        }
    else
        {
        User::Leave( KErrNotFound );
        return NULL;
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C CPosLandmark* CMnrpEngine::AddressToCoordL( const CPosLandmark& aAddress )
    {
    TPtrC city, country;
    aAddress.GetPositionField( EPositionFieldCity, city );
    
    TArray<CPosLandmark*> pois = KnownPlacesL();
    
    if ( city.Length() )
        {
        for ( TInt i = 0; i < pois.Count(); i++ )
            {
            TPtrC poiCity;
            pois[i]->GetPositionField( EPositionFieldCity, poiCity );
            if ( poiCity.CompareF( city ) == 0 )
                {
                return CPosLandmark::NewL( *pois[i] );
                }
            }
        }
    
    return NULL;
    }
    
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C CPosLandmark* CMnrpEngine::AddressToCoordLC( const TDesC& aAddress )
    {
    CPosLandmark* lm = AddressToCoordL( aAddress );
    if ( lm )
        {
        CleanupStack::PushL( lm );
        return lm;
        }
    else
        {
        User::Leave( KErrNotFound );
        return NULL;
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C CPosLandmark* CMnrpEngine::AddressToCoordL( const TDesC& aAddress )
    {
    TArray<CPosLandmark*> pois = KnownPlacesL();

    if ( aAddress.Length() )
        {
        for ( TInt i = 0; i < pois.Count(); i++ )
            {
            TPtrC city, country;
            pois[i]->GetPositionField( EPositionFieldCity, city );
            pois[i]->GetPositionField( EPositionFieldCountry, country );
            
            if ( aAddress.FindF( city ) >= 0 )
                {
                return CPosLandmark::NewL( *pois[i] );
                }
            }
        }
        
    return NULL;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C TReal32 CMnrpEngine::DistanceBetweenLandmarks( 
    const CPosLandmark& aFrom,
    const CPosLandmark& aTo )
    {
    TRealX nan;
    nan.SetNaN();
    TReal32 distance = nan;
    
    TLocality locFrom, locTo;

    if ( aFrom.GetPosition( locFrom ) == KErrNone &&
         aTo.GetPosition( locTo ) == KErrNone )
        {
        TReal32 dist;
        if ( locFrom.Distance( locTo, dist ) == KErrNone )
            {
            distance = dist;
            }
        }
    return distance;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C void CMnrpEngine::FindClosestPoisL( 
    const CPosLandmark& aReference,
    RArray<CMnrpEngine::TDistanceToPoi>& aNeighbourPois,
    TInt aMaxMatches )
    {
    aNeighbourPois.Reset();
    TArray<CPosLandmark*> pois = KnownPlacesL();

    // calc distances to known places and find out closest ones
    for ( TInt i = 0; i < pois.Count(); i++ )
        {
        CPosLandmark* poi = pois[i];

        TReal32 distance = DistanceBetweenLandmarks( aReference, *poi );
        
        if ( Math::IsNaN( distance ) )
            {
            continue;
            }
        
        TDistanceToPoi newDistToPoi;
        newDistToPoi.iPoiIndex = i;
        newDistToPoi.iDistance = distance;

        for ( TInt k = 0; k < aNeighbourPois.Count(); k++ )
            {
            TDistanceToPoi distToPoi = aNeighbourPois[k];
            if ( distance < distToPoi.iDistance )
                {
                // current POI is closer to reference than current neighbour
                aNeighbourPois.InsertL( newDistToPoi, k );
                break;
                }
            }

        if ( aNeighbourPois.Count() < aMaxMatches )
            {
            aNeighbourPois.AppendL( newDistToPoi );
            }

        if ( aNeighbourPois.Count() > aMaxMatches )
            {
            aNeighbourPois.Remove( aNeighbourPois.Count() - 1 ); // remove last
            }
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
CPosLandmark* CMnrpEngine::CreateCloseLandmarkLC( 
    const CPosLandmark& aReference,
    TReal32 aDistance )
    {
    CPosLandmark* lm = CPosLandmark::NewLC( aReference );
    TPtrC oldName;
    lm->GetLandmarkName( oldName );
    
    // create street in the form of "50 km to <POI name>"
    const TInt KDistValueLen = 5; // "40000"
    const TInt KAdditionalChars = 7; // " km to "

    _LIT( KLocationNameFormat, "%d m to %S" );
    _LIT( KLocationNameFormatKm, "%d km to %S" );

    HBufC* locName = HBufC::NewLC( oldName.Length() + KDistValueLen + KAdditionalChars );

    if ( aDistance < 1000 )
        {
        locName->Des().Format( KLocationNameFormat, TInt( aDistance ), &oldName );
        }
    else
        {
        locName->Des().Format( KLocationNameFormatKm, TInt( aDistance / 1000 ), &oldName );
        }

    lm->SetPositionFieldL( EPositionFieldLocationName, *locName );
    lm->SetPositionFieldL( EPositionFieldStreet, *locName );
   
    CleanupStack::PopAndDestroy( locName );
    return lm; // left in stack
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C CPosLandmark* CMnrpEngine::CoordToAddressLC( const TCoordinate& aLocation )
    {
    TArray<CPosLandmark*> pois = KnownPlacesL();

    // find closest POI
    RArray<TDistanceToPoi> matches;
	CleanupClosePushL( matches );
    
    CPosLandmark* temp = CPosLandmark::NewLC();
    TLocality loc( aLocation, 0 ); // accuracy is not used by this implementation
    temp->SetPositionL( loc );
    FindClosestPoisL( *temp, matches, 1 ); // only one match needed
    CleanupStack::PopAndDestroy( temp );
    
    if ( matches.Count() < 1 )
		{
		User::Leave( KErrNotFound );
		}

    TDistanceToPoi distToPoi = matches[0];
	CleanupStack::PopAndDestroy( &matches );

    CPosLandmark* lm = CreateCloseLandmarkLC(
        *pois[distToPoi.iPoiIndex],
        distToPoi.iDistance );

    return lm; // left in stack
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C void CMnrpEngine::BestCoordToAddressMatchesL( 
    const TCoordinate& aLocation,
    RPointerArray<CPosLandmark>& aMatches,
    TInt aMaxMatches )
    {
    TArray<CPosLandmark*> pois = KnownPlacesL();

    // find closest POIs
    RArray<TDistanceToPoi> matches;
    CleanupClosePushL( matches );
    
    CPosLandmark* temp = CPosLandmark::NewLC();
    TLocality loc( aLocation, 0 ); // accuracy is not used by this implementation
    temp->SetPositionL( loc );
    FindClosestPoisL( *temp, matches, aMaxMatches );
    CleanupStack::PopAndDestroy( temp );
    
    for ( TInt i = 0; i < matches.Count(); i++ )
        {
        TDistanceToPoi distToPoi = matches[i];
        
        CPosLandmark* lm = CreateCloseLandmarkLC( 
            *pois[distToPoi.iPoiIndex], 
            distToPoi.iDistance );
            
        aMatches.AppendL( lm );    
        CleanupStack::Pop( lm );
        }
    CleanupStack::PopAndDestroy( &matches );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C void CMnrpEngine::FindResourceFileL( 
    const TDesC& aFilePathAndName,
    TFileName& aRscFile )
    {
    TParse parse;
    parse.Set( aFilePathAndName, NULL, NULL );
    
    TFindFile finder( iFileSession );
    if ( finder.FindByDir( parse.NameAndExt(), parse.Path() ) == KErrNone )
        {
        aRscFile.Copy( finder.File() );
        }
    else
        {
        User::Leave( KErrNotFound );
        }
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C RFs& CMnrpEngine::Fs() 
    { 
    return iFileSession;
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CMnrpEngine::LoadKnownPlacesL()
    {
    TFileName resourceFile;
    FindResourceFileL( KCitiesResourceFile(), resourceFile );

    CResourceFile* resFile = CResourceFile::NewLC( iFileSession, resourceFile, 0, 0 );
    resFile->ConfirmSignatureL( 0 );

    RResourceReader reader;

    reader.OpenLC( resFile, R_MNREFPROVIDERENGINE_PLACES );
    ReadPlacesResourceL( reader );
    CleanupStack::PopAndDestroy( &reader );
    
    CleanupStack::PopAndDestroy( resFile );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CMnrpEngine::ReadPlacesResourceL( RResourceReader& aReader )
    {
    TInt size = aReader.ReadInt16L();

    for ( TInt i = 0; i < size; i++ )
        {
        HBufC* city = aReader.ReadHBufCL();
        CleanupStack::PushL( city );
        HBufC* country = aReader.ReadHBufCL();
        CleanupStack::PushL( country );

        TReal64 lat = aReader.ReadReal64L();
        TReal64 lon = aReader.ReadReal64L();
        
        CPosLandmark* lm = CPosLandmark::NewLC();
        lm->SetLandmarkNameL( *city );
        
        lm->SetPositionFieldL( EPositionFieldCity, *city );
        lm->SetPositionFieldL( EPositionFieldCountry, *country );
        
        TLocality coord;
        coord.SetCoordinate( lat, lon );
        lm->SetPositionL( coord );
        
        iPlaces.AppendL( lm );
        CleanupStack::Pop( lm );
        CleanupStack::PopAndDestroy( country );
        CleanupStack::PopAndDestroy( city );
        }
    }