/*

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

*

*/

#include <coemain.h>

#include <barsread.h>

#include <bautils.h>

#include <aknlists.h>

#include <AknIconUtils.h>

#include <AknWaitDialog.h>

#include <fbs.h>

#include <imageconversion.h>

#include <icl/imagedata.h>

#include <lbs.h>

#include <lbsposition.h>

#include <lbspositioninfo.h>

#include <EPos_CPosLandmark.h>

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLandmarkCategory.h>

#include <EPos_CPosLmCategoryManager.h>

#include "debug.h"

#include "mnrpengine.h"

#include "mnrputils.h"

#include "mnrpappserver.h"

#include "mnrpmapviewservice.h"

#ifdef RD_MAPNAV_BITMAP_ACCESS

#include "mnrpmapimageservice.h"

#endif

#include "mnrpmapmodel.h"

const TInt KUpdateInterval = 1 * 1000 * 1000; // 1 sec

const TInt KUpdateTimeout = 10 * 1000 * 1000; // 10 sec

const TInt KMaxX = 180;

const TInt KMinX = -180;

const TInt KMapWidth = KMaxX - KMinX;

const TInt KMaxY = 90;

const TInt KMinY = -90;

const TInt KMapHeight = KMaxY - KMinY;

const TReal KDegree = 1.0;

const TReal KMinute = KDegree / 60.0;

const TReal KSecond = KMinute / 60.0;

const TReal KMilliSecond = KSecond / 1000.0;

const TReal KMaxCell = 60 * KDegree;

const TReal KMinScale = 10 * KMilliSecond; // 0.01 second / 1 px

const TInt KBigCellsInView = 2;

const TInt KCellDividers[] = { 6, 2, 5 };

const TInt KNumCellDividers = 3;

const TReal KDefaultRadius = 1; // 1 degree

const TReal KRadiusBorderFactor = 1.1; // 110%

const TReal KEarthEquator = 40075000;

//const TReal KEarthRadius = 6371010;

const TInt KLmTextOffset = 3;

const TInt KLmTextShadowOffset = 1;

const TInt KGridPenSize( 1 );

// ============================ LOCAL FUNCTIONS ===============================

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

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

//

TPoint AbsoluteToImage( TRealPoint aAbsolute, TReal aImageToAbsoluteScale )

    {

    TInt s = ( KMapWidth / 2 + aAbsolute.iX ) / aImageToAbsoluteScale;

    TInt t = ( KMapHeight / 2 - aAbsolute.iY ) / aImageToAbsoluteScale;

    return TPoint( s , t );

    }

// ============================ MEMBER CLASSES' FUNCTIONS ===============================

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

//  TRealPoint implementation

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

//

TRealPoint::TRealPoint()

    {

    TRealX nan;

    nan.SetNaN();

    iX = nan;

    iY = nan;

    }

TRealPoint::TRealPoint( TReal aX, TReal aY )

    : iX( aX ), iY( aY )

    {

    }

TRealPoint::TRealPoint( TCoordinate aCoordinate )

    : iX( aCoordinate.Longitude() ), iY( aCoordinate.Latitude() )

    {

    }

TCoordinate TRealPoint::Coordinate()

    {

    return TCoordinate( iY, iX );

    }

TRealPoint TRealPoint::operator+(

    const TRealPoint& aRight )

    {

    return TRealPoint( this->iX + aRight.iX, this->iY + aRight.iY );

    }

TRealPoint TRealPoint::operator-(

    const TRealPoint& aRight )

    {

    return TRealPoint( this->iX - aRight.iX, this->iY - aRight.iY );

    }

TRealPoint TRealPoint::operator*( const TReal& aRight )

    {

    return TRealPoint( this->iX * aRight, this->iY * aRight );

    }

TRealPoint TRealPoint::operator/( const TReal& aRight )

    {

    return TRealPoint( this->iX / aRight, this->iY / aRight );

    }

void TRealPoint::Set( TReal aX, TReal aY )

    {

    iX = aX;

    iY = aY;

    }

TBool TRealPoint::IsValid()

    {

    return ( !Math::IsNaN( iX ) && !Math::IsNaN( iY ) );

    }

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

//  CDrawItem implementation

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

//

CMnrpMapModel::CDrawItem* CMnrpMapModel::CDrawItem::NewLC(

    const CPosLandmark& aLm )

    {

    CDrawItem* self = new (ELeave) CDrawItem;

    CleanupStack::PushL( self );

    TPtrC name;

    aLm.GetLandmarkName( name );

    self->iText = MnrpUtils::PrintableStringLC( name );

    CleanupStack::Pop( self->iText );

    TLocality loc;

    if ( KErrNone == aLm.GetPosition( loc ) )

        {

        self->SetAbsolutePosition( loc );

        }

    TPtrC iconFile;

    TInt iconIndex, maskIndex;

    if ( KErrNone == aLm.GetIcon( iconFile, iconIndex, maskIndex ) )

        {

        AknIconUtils::CreateIconL( self->iBitmap, self->iMask, iconFile, iconIndex, maskIndex );

        AknIconUtils::PreserveIconData( self->iBitmap );

        }

    return self;

    }

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

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

//

CMnrpMapModel::CDrawItem* CMnrpMapModel::CDrawItem::NewLC(

    const CPosLandmark& aLm,

    CPosLmCategoryManager& aCatman )

    {

    CDrawItem* self = NewLC( aLm );

    if ( !self->iBitmap )

        {

        // try icon from category

        RArray<TPosLmItemId> cats;

        CleanupClosePushL( cats );

        aLm.GetCategoriesL( cats );

        if ( cats.Count() == 1 )

            {

            CPosLandmarkCategory* cat = aCatman.ReadCategoryLC( cats[0] );

            TPtrC iconFile;

            TInt iconIndex, maskIndex;

            if ( KErrNone == cat->GetIcon( iconFile, iconIndex, maskIndex ) )

                {

                AknIconUtils::CreateIconL( self->iBitmap, self->iMask, iconFile, iconIndex, maskIndex );

                AknIconUtils::PreserveIconData( self->iBitmap );

                }

            CleanupStack::PopAndDestroy( cat );

            }

        CleanupStack::PopAndDestroy( &cats );

        }

    return self;

    }

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

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

//

void CMnrpMapModel::CDrawItem::SetAbsolutePosition( const TLocality& aLocality )

    {

    iAbsolutePosition = TRealPoint( aLocality.Longitude(), aLocality.Latitude() );

    }

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

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

//

CMnrpMapModel::CDrawItem::~CDrawItem()

    {

    if ( iBitmap )

        {

        AknIconUtils::DestroyIconData( iBitmap );

        }

    delete iBitmap;

    delete iMask;

    delete iText;

    }

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

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

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

//

CMnrpMapModel::CMnrpMapModel(

    MMapModelObserver& aObserver,

    CMnrpEngine& aEngine )

    :

    iObserver( &aObserver ), iEngine( aEngine )

    {

    iScale = 1;

    iViewOrigin.Set( 0, 0 );

    }

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

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

//

CMnrpMapModel::CMnrpMapModel( CMnrpEngine& aEngine )

    : iEngine( aEngine )

    {

    iScale = 1;

    iViewOrigin.Set( 0, 0 );

    }

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

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

//

CMnrpMapModel::~CMnrpMapModel()

    {

    delete iPositionRequest;

    iDrawItems.ResetAndDestroy();

    }

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

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

//

EXPORT_C CMnrpMapModel* CMnrpMapModel::NewL(

    MMapModelObserver& aObserver,

    CMnrpEngine& aEngine )

    {

    CMnrpMapModel* self = new (ELeave) CMnrpMapModel( aObserver, aEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

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

//

EXPORT_C CMnrpMapModel* CMnrpMapModel::NewL( CMnrpEngine& aEngine )

    {

    CMnrpMapModel* self = new (ELeave) CMnrpMapModel( aEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

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

//

void CMnrpMapModel::ConstructL()

    {

    _LIT( KRequestorName, "MnRefProvider" );

    iPositionRequest = CMnrpPositionRequest::NewL( KRequestorName, *this );

    TPositionUpdateOptions options;

    options.SetUpdateInterval( TTimeIntervalMicroSeconds( KUpdateInterval ) );

    options.SetUpdateTimeOut( TTimeIntervalMicroSeconds( KUpdateTimeout ) );

    iPositionRequest->SetOptionsL( options );

    AddCitiesL();

    }

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

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

//

TBool CMnrpMapModel::CheckDrawItemHasPositionL( CDrawItem& aItem, const CPosLandmark& aLandmark )

	{

    if ( !aItem.AbsolutePosition().IsValid() )

        {

        // try to find coordinate by address

        CPosLandmark* poi = iEngine.AddressToCoordL( aLandmark );

        if ( poi )

        	{

            TLocality pos;

            poi->GetPosition( pos );

            aItem.SetAbsolutePosition( pos );

        	}

    	delete poi;

        }

    return aItem.AbsolutePosition().IsValid();

	}

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

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

//

EXPORT_C void CMnrpMapModel::UpdateModelL( CMnrpMapViewService& aService )

    {

    ASSERT( iObserver );

    iDrawItems.ResetAndDestroy();

    iShowCurrentLocation =

        aService.CurrentLocationOption() != CMnMapView::ECurrentLocationDisabled;

    if ( iShowCurrentLocation )

        {

        iPositionRequest->FetchNewPosition();

        }

    // Add client-defined marks

    iNumIgnoredLandmarks = 0;

    TRealPoint min, max;

    // add non-linked landmarks

    for ( TInt i = 0; i < aService.LandmarksToShow().Count(); i++)

        {

        const CPosLandmark* lm = aService.LandmarksToShow()[i];

        CDrawItem* item = CDrawItem::NewLC( *lm );

        if ( CheckDrawItemHasPositionL( *item, *lm ) )

        	{

        	iDrawItems.AppendL( item );

            CleanupStack::Pop( item );

            AdjustBoundingBox( *item, min, max );

        	}

        else

        	{

            CleanupStack::PopAndDestroy( item );

            iNumIgnoredLandmarks++;

        	}

        }

    // add linked landmarks

    for ( TInt db = 0; db < aService.LandmarksToShowDatabases().Count(); db++ )

        {

        const HBufC* uri = aService.LandmarksToShowDatabases()[db];

        LOG1("MnRefProvider::LinkedLandmarks: database (%S)", uri );

        CPosLandmarkDatabase* lmdb = CPosLandmarkDatabase::OpenL( *uri );

        CleanupStack::PushL( lmdb );

        if ( lmdb->IsInitializingNeeded() )

            {

            ExecuteAndDeleteLD( lmdb->InitializeL() );

            }

        CPosLmCategoryManager* catman = CPosLmCategoryManager::NewL( *lmdb );

        CleanupStack::PushL( catman );

        for ( TInt i = 0; i < aService.LinkedLandmarksToShow(db).Count(); i++)

            {

            TPosLmItemId id = aService.LinkedLandmarksToShow(db)[i];

            LOG1("MnRefProvider::LinkedLandmarks: id (%d)", id );

            CPosLandmark* lm = lmdb->ReadLandmarkLC( id );

            CDrawItem* item = CDrawItem::NewLC( *lm, *catman );

            if ( CheckDrawItemHasPositionL( *item, *lm ) )

            	{

            	iDrawItems.AppendL( item );

                CleanupStack::Pop( item );

                AdjustBoundingBox( *item, min, max );

            	}

            else

            	{

                CleanupStack::PopAndDestroy( item );

                iNumIgnoredLandmarks++;

            	}

            CleanupStack::PopAndDestroy( lm );

            }

        CleanupStack::PopAndDestroy( catman );

        CleanupStack::PopAndDestroy( lmdb );

        }

    // Add predefined places

    AddCitiesL();

    LOG4("MnRefProvider::BoundingBox: %f, %f, %f, %f", min.iX, min.iY, max.iX, max.iY );

    // set origin

    iUseCurrentLocationAsOrigin = EFalse;

    if ( aService.IsAreaCentralPointSet() )

        {

        TCoordinate center;

        aService.GetAreaCentralPoint( center );

        iViewOrigin.Set( center.Longitude(), center.Latitude() );

        }

    else if ( !Math::IsNaN( max.iX ) ) // others are also valid then

        {

        iViewOrigin.Set( ( max.iX + min.iX ) / 2, ( max.iY + min.iY ) / 2 );

        }

    else if ( iShowCurrentLocation )

        {

        // get current location and use it as center point

        // this implementation defers location acquiring

        iUseCurrentLocationAsOrigin = ETrue;

        // FetchCurrentLocation();

        iViewOrigin.Set( 0, 0 );

        }

    else

        {

        iViewOrigin.Set( 0, 0 );

        }

    LOG2("MnRefProvider: viewOrigin (%f, %f)", iViewOrigin.iX, iViewOrigin.iY);

    // set scale

    TReal desiredScale = 0;

    TReal radius = 0;

    if ( !Math::IsNaN( aService.AreaRadius() ) )

        {

         // Radius setting is easy in this implementation

         // because map is rectangular just convert meters to degrees

        radius = Abs( aService.AreaRadius() ) / KEarthEquator * 360;

        LOG1("MnRefProvider: user radius (%f)", radius );

        }

    else if ( !Math::IsNaN( max.iX ) ) // others are also valid then

        {

        // get radius from bounding box

        radius = Max( Abs( max.iX - min.iX ), Abs( max.iY - min.iY ) );

        LOG2("MnRefProvider: bounding radius (%f), with border (%f)", radius, radius * KRadiusBorderFactor );

        radius *= KRadiusBorderFactor;

        }

    else

        {

        // default radius

        }

    if ( radius <= 0 )

        {

        radius = KDefaultRadius;

        LOG1("MnRefProvider: default radius (%f)", radius );

        }

    desiredScale = radius / TReal( Max( iScreenSize.iWidth, iScreenSize.iHeight ) );

    LOG3("MnRefProvider: desired scale (%f), min (%f), max(%f)",

        desiredScale, KMinScale, MaxScale() );

    iScale = Max( Min( desiredScale, MaxScale() ), KMinScale );

    CheckBorders();

    LOG1("MnRefProvider: scale (%f)", iScale );

    iObserver->HandleModelUpdateL();

    }

#ifdef RD_MAPNAV_BITMAP_ACCESS

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

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

//

EXPORT_C void CMnrpMapModel::UpdateModelL( const CMnrpMapImageService& aService )

    {

    iDrawItems.ResetAndDestroy();

    iShowCurrentLocation =

        aService.ShowOptions() & CMnMapImage::EShowOptionCurrentLocation;

    if ( iShowCurrentLocation )

        {

        iPositionRequest->FetchNewPosition();

        }

    if ( aService.ShowOptions() & CMnMapImage::EShowOptionLandmarks)