/*
* 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: Implementation of CBlidRouter class which provides access to blid router. Blid route can be modified and read using this class
*
*/



// INCLUDE FILES
#include <f32file.h> // RFs
#include <e32math.h>
#include <sysutil.h>
#include <driveinfo.h>

#include "CBlidRouter.h"
#include "TNamedCoordinate.h"
#include "blidengconsts.h"

// CONSTANTS
const TInt KBlidInvalidWaypointIndex( -1 );

//Forward declaration. Function for sorted ordering of waypoints
TInt WaypointOrdering(const TNamedCoordinate& aCoordinate1, const TNamedCoordinate& aCoordinate2);

_LIT(KPanicText, "CBlidRouter");
enum TPanicCode
    {
    EBlidReadOutOfRange = 1
    };

// ============================ MEMBER FUNCTIONS ==============================
// ----------------------------------------------------------------------------
// CBlidRouter::CBlidRouter
// C++ default constructor can NOT contain any code, that
// might leave.
// ----------------------------------------------------------------------------
//
CBlidRouter::CBlidRouter()
    {
    iWaypointIndex = -1;    
    }

// ----------------------------------------------------------------------------
// CBlidRouter::ConstructL
// Symbian 2nd phase constructor can leave.
// ----------------------------------------------------------------------------
//
void CBlidRouter::ConstructL()
    {
    iLandmark = NULL;
    }

// ----------------------------------------------------------------------------
// CBlidRouter::NewL
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CBlidRouter* CBlidRouter::NewL()
    {
    CBlidRouter* self = new( ELeave ) CBlidRouter;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ----------------------------------------------------------------------------
// CBlidRouter::~CBlidRouter
// ----------------------------------------------------------------------------
//
CBlidRouter::~CBlidRouter()
    {
    iRoute.ResetAndDestroy();
    iRoute.Close();
    if( iLandmark )
	    {
	    delete iLandmark;
	    }
    }

// ----------------------------------------------------------------------------
// CBlidRouter::At
// ----------------------------------------------------------------------------
//
TNamedCoordinate& CBlidRouter::At( TInt aIndex )
	{
    __ASSERT_ALWAYS(aIndex >= 0 && aIndex < iRoute.Count(),
        			User::Panic(KPanicText,EBlidReadOutOfRange));
    return *iRoute[aIndex];
	}

// ----------------------------------------------------------------------------
// CBlidRouter::AppendL
// ----------------------------------------------------------------------------
//
TInt CBlidRouter::AppendL( TNamedCoordinate* aCoordinate, TBool aCheckForMemory )
	{
	RFs fs;
    User::LeaveIfError(fs.Connect()); 
    CleanupClosePushL( fs ); 
    
    if(aCheckForMemory)
    	{
    	if ( SysUtil::DiskSpaceBelowCriticalLevelL( &fs, sizeof(aCoordinate), DriveInfo::EDefaultPhoneMemory ) )
		    {
		    CleanupStack::PopAndDestroy(); // fs
		    return KErrDiskFull;        
			}
    	}    
	CleanupStack::PopAndDestroy(); // fs
	TInt retVal;
	TLinearOrder<TNamedCoordinate> order(WaypointOrdering);    		
    retVal = iRoute.InsertInOrder(aCoordinate, order);    
    return retVal;
	}


// ----------------------------------------------------------------------------
// CBlidRouter::RemoveL
// ----------------------------------------------------------------------------
//
TInt CBlidRouter::RemoveL( TInt aIndex )
	{
    __ASSERT_ALWAYS(aIndex >= 0 && aIndex < iRoute.Count(),
            User::Panic(KPanicText,EBlidReadOutOfRange));
    RFs fs;
    User::LeaveIfError(fs.Connect()); 
    CleanupClosePushL( fs ); 

    if ( SysUtil::DiskSpaceBelowCriticalLevelL( &fs, 0, DriveInfo::EDefaultPhoneMemory ) )
        {
        CleanupStack::PopAndDestroy(); // fs
        return KErrDiskFull;        
		}
	CleanupStack::PopAndDestroy(); // fs
    TNamedCoordinate* plot = iRoute[aIndex];
    iRoute.Remove( aIndex );
    delete plot;
    return KErrNone;
	}

// ----------------------------------------------------------------------------
// CBlidRouter::ResetAndDestroy
// ----------------------------------------------------------------------------
//
void CBlidRouter::ResetAndDestroy()
    {
    iRoute.ResetAndDestroy();
    }

// ----------------------------------------------------------------------------
// CBlidRouter::Count
// ----------------------------------------------------------------------------
//
TInt CBlidRouter::Count()
	{
    return iRoute.Count();
	}

// ----------------------------------------------------------------------------
// CBlidRouter::Waypoint()
// Waypoint getter
// ----------------------------------------------------------------------------
//
TNamedCoordinate* CBlidRouter::Waypoint()
    {
    if(!iIsWaypoint || iWaypointIndex == KBlidInvalidWaypointIndex)
	    {
	    return NULL;
	    }
	else if( iWaypointIndex == KManualWaypointIndex )
	    {
	    return &iManualWaypoint;
	    }
    else
	    {
	    return &iWaypoint;	
	    }
    }

// ----------------------------------------------------------------------------
// CBlidRouter::IndexOfWaypoint
// ----------------------------------------------------------------------------
//
TInt CBlidRouter::IndexOfWaypoint() const
    {
    return iWaypointIndex;
    }

// ----------------------------------------------------------------------------
// CBlidRouter::SetWaypoint( const TInt aIndex )
// Waypoint setter
// ----------------------------------------------------------------------------
//
void CBlidRouter::SetWaypoint( const TInt aIndex )
    {
    iWaypoint = At( aIndex );  
    iWaypointIndex = aIndex;
    iIsWaypoint = ETrue;
    }

// ----------------------------------------------------------------------------
// CBlidRouter::RemoveWaypoint()
// ----------------------------------------------------------------------------
//
void CBlidRouter::RemoveWaypoint()
    {
    iWaypointIndex = -1;
    }

// ----------------------------------------------------------------------------
// CBlidRouter::ClearSetPoints()
// ----------------------------------------------------------------------------
//
void CBlidRouter::ClearSetPoints()
	{
	RemoveWaypoint();
	if(iLandmark)
		{
		delete iLandmark;
		iLandmark = NULL;			
		}
	}

// ----------------------------------------------------------------------------
// CBlidRouter::ExternalizeL
// ----------------------------------------------------------------------------
//
void CBlidRouter::ExternalizeL( RWriteStream& aStream ) 
    {
    TDesC *name;
    TInt count( Count() );
    aStream.WriteInt32L( count );
    for (TInt i = 0; i < count; i++ )
        {
        name = At( i ).Name();
        if ( name )
            {
            CleanupStack::PushL( name );
            aStream.WriteInt32L( name->Length() );
            aStream.WriteL( *name );
            CleanupStack::PopAndDestroy(); //name
            name = NULL;
            
            if (  !Math::IsNaN(At( i ).Latitude()) )
                {
                aStream.WriteReal64L( At( i ).Latitude() );
                }
            else 
                {
                aStream.WriteReal64L( 0 );
                }

            if (  !Math::IsNaN(At( i ).Longitude()) )
                {
                aStream.WriteReal64L( At( i ).Longitude() );
                }
            else 
                {
                aStream.WriteReal64L( 0 );
                }

            if (  !Math::IsNaN(At( i ).Altitude()) )
                {
                aStream.WriteReal32L( At( i ).Altitude() );
                }
            else 
                {
                aStream.WriteReal32L( 0 );
                }
			if (  !Math::IsNaN(At( i ).Accuracy()) )
                {
                aStream.WriteReal32L( At( i ).Accuracy() );
                }
            else 
                {
                aStream.WriteReal32L( 0 );
                }
            }
        }   
    }

// ----------------------------------------------------------------------------
// CBlidRouter::InternalizeV1L
// ----------------------------------------------------------------------------
//
void CBlidRouter::InternalizeV1L( RReadStream& aStream )
    {
    TInt i;
    TInt count( aStream.ReadInt32L() );    
    TInt length(0);
    TBuf<KBlidWaypointNameMaxLen> name;
    for ( i = 0; i < count; i++ )
        {
        length = aStream.ReadInt32L();
        aStream.ReadL( name, length );
        TReal64 latitude = aStream.ReadReal64L();
        TReal64 longitude = aStream.ReadReal64L();
        TReal32 altitude = aStream.ReadReal32L();
        TReal32 accuracy = aStream.ReadReal32L();
        TNamedCoordinate* plot = new(ELeave)TNamedCoordinate(
                            latitude, 
                            longitude,
                            altitude,
                            name,accuracy);
        CleanupStack::PushL( plot );
        //iRouter takes ownership of plot
        User::LeaveIfError( AppendL( plot, EFalse ) );
        CleanupStack::Pop(); //plot
        name.Zero();
        }
    }
	
// ----------------------------------------------------------------------------
// CBlidRouter::Landmark
// ----------------------------------------------------------------------------
//	
CPosLandmark* CBlidRouter::Landmark() const
	{
	if( iLandmark && !iIsWaypoint  )
		{
		return iLandmark;	
		}		
	else
		{
		return NULL;	
		}	
	}

// ----------------------------------------------------------------------------
// CBlidRouter::SetLandmark
// ----------------------------------------------------------------------------
//    
void CBlidRouter::SetLandmark(CPosLandmark* aLandmark) 
	{
	if( iLandmark )
		{
		delete iLandmark;	
		}
	
	iLandmark = aLandmark;
	iIsWaypoint = EFalse;
	}
	
// ----------------------------------------------------------------------------
// CBlidRouter::IsWaypointSet
// ----------------------------------------------------------------------------
//
TBool CBlidRouter::IsWaypointSet()
	{
	return iIsWaypoint;
	}

// ----------------------------------------------------------------------------
// CBlidRouter::IsAnyPointSet
// ----------------------------------------------------------------------------
//
TBool CBlidRouter::IsAnyPointSet()
	{
	if( iLandmark || (iWaypointIndex != -1) )
		{
		return ETrue;	
		}
	else
		{
		return EFalse;	
		}	
	}
// ----------------------------------------------------------------------------
// CBlidRouter::SetManualWaypoint
// ----------------------------------------------------------------------------
//
void CBlidRouter::SetManualWaypoint(TReal latitude, TReal longitude, TDesC& aName)
    {
    iWaypointIndex = KManualWaypointIndex;
    iIsWaypoint = ETrue;
    iManualWaypoint.SetCoordinate(latitude, longitude);
    iManualWaypoint.SetName(aName);
    }

// ----------------------------------------------------------------------------
// CBlidRouter::FindWaypointIndex
// ----------------------------------------------------------------------------
//
TInt CBlidRouter::FindWaypointIndex( TNamedCoordinate* aCoordinate )
    {
    TLinearOrder<TNamedCoordinate> order(WaypointOrdering); 
    iRoute.Sort( order );
    TInt lReturn = iRoute.Find( aCoordinate );
    return lReturn;
    }
// ----------------------------------------------------------------------------
// WaypointOrdering() : Function used for ordering of waypoints
// ----------------------------------------------------------------------------
//
TInt WaypointOrdering(const TNamedCoordinate& aCoordinate1, const TNamedCoordinate& aCoordinate2)
    {
    HBufC* name1 = aCoordinate1.Name();
    HBufC* name2 = aCoordinate2.Name();
    TInt retVal = name1->Compare(name2->Des());
    delete name1;
    delete name2;
    return retVal;
    }
//  End of File