/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsGeoPosition.h"

#include "mozilla/FloatingPoint.h"

#include "mozilla/dom/PositionBinding.h"

#include "mozilla/dom/CoordinatesBinding.h"

using mozilla::IsNaN;

// NaN() is a more convenient function name.

inline

double NaN()

{

  return mozilla::UnspecifiedNaN<double>();

}

#ifdef DEBUG

static

bool EqualOrNaN(double a, double b)

{

  return (a == b) || (IsNaN(a) && IsNaN(b));

}

#endif

////////////////////////////////////////////////////

// nsGeoPositionCoords

////////////////////////////////////////////////////

nsGeoPositionCoords::nsGeoPositionCoords(double aLat, double aLong,

                                         double aAlt, double aHError,

                                         double aVError, double aHeading,

                                         double aSpeed)

  : mLat(aLat)

  , mLong(aLong)

  , mAlt(aAlt)

  , mHError((aHError >= 0) ? aHError : 0)

    // altitudeAccuracy without an altitude doesn't make any sense.

  , mVError((aVError >= 0 && !IsNaN(aAlt)) ? aVError : NaN())

    // If the hosting device is stationary (i.e. the value of the speed attribute

    // is 0), then the value of the heading attribute must be NaN (or null).

  , mHeading((aHeading >= 0 && aHeading < 360 && aSpeed > 0)

             ? aHeading : NaN())

  , mSpeed(aSpeed >= 0 ? aSpeed : NaN())

{

  // Sanity check the location provider's results in debug builds. If the

  // location provider is returning bogus results, we'd like to know, but

  // we prefer to return some position data to JavaScript over a

  // POSITION_UNAVAILABLE error.

  MOZ_ASSERT(aLat >= -90 && aLat <= 90);

  MOZ_ASSERT(aLong >= -180 && aLong <= 180);

  MOZ_ASSERT(!(aLat == 0 && aLong == 0)); // valid but probably a bug

  MOZ_ASSERT(EqualOrNaN(mAlt, aAlt));

  MOZ_ASSERT(mHError == aHError);

  MOZ_ASSERT(EqualOrNaN(mVError, aVError));

  MOZ_ASSERT(EqualOrNaN(mHeading, aHeading));

  MOZ_ASSERT(EqualOrNaN(mSpeed, aSpeed));

}

nsGeoPositionCoords::~nsGeoPositionCoords()

{

}

NS_INTERFACE_MAP_BEGIN(nsGeoPositionCoords)

NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMGeoPositionCoords)

NS_INTERFACE_MAP_ENTRY(nsIDOMGeoPositionCoords)

NS_INTERFACE_MAP_END

NS_IMPL_ADDREF(nsGeoPositionCoords)

NS_IMPL_RELEASE(nsGeoPositionCoords)

NS_IMETHODIMP

nsGeoPositionCoords::GetLatitude(double *aLatitude)

{

  *aLatitude = mLat;

  return NS_OK;

}

NS_IMETHODIMP

nsGeoPositionCoords::GetLongitude(double *aLongitude)

{

  *aLongitude = mLong;

  return NS_OK;

}

NS_IMETHODIMP

nsGeoPositionCoords::GetAltitude(double *aAltitude)

{

  *aAltitude = mAlt;

  return NS_OK;

}

NS_IMETHODIMP

nsGeoPositionCoords::GetAccuracy(double *aAccuracy)

{

  *aAccuracy = mHError;

  return NS_OK;

}

NS_IMETHODIMP

nsGeoPositionCoords::GetAltitudeAccuracy(double *aAltitudeAccuracy)

{

  *aAltitudeAccuracy = mVError;

  return NS_OK;

}

NS_IMETHODIMP

nsGeoPositionCoords::GetHeading(double *aHeading)

{

  *aHeading = mHeading;

  return NS_OK;

}

NS_IMETHODIMP

nsGeoPositionCoords::GetSpeed(double *aSpeed)

{

  *aSpeed = mSpeed;

  return NS_OK;

}

////////////////////////////////////////////////////

// nsGeoPosition

////////////////////////////////////////////////////

nsGeoPosition::nsGeoPosition(double aLat, double aLong,

                             double aAlt, double aHError,

                             double aVError, double aHeading,

                             double aSpeed, DOMTimeStamp aTimestamp) :

    mTimestamp(aTimestamp)

{

    mCoords = new nsGeoPositionCoords(aLat, aLong,

                                      aAlt, aHError,

                                      aVError, aHeading,

                                      aSpeed);

}

nsGeoPosition::nsGeoPosition(nsIDOMGeoPositionCoords *aCoords,

                             DOMTimeStamp aTimestamp) :

  mTimestamp(aTimestamp),

  mCoords(aCoords)

{

}

nsGeoPosition::~nsGeoPosition()

{

}

NS_INTERFACE_MAP_BEGIN(nsGeoPosition)

NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMGeoPosition)

NS_INTERFACE_MAP_ENTRY(nsIDOMGeoPosition)

NS_INTERFACE_MAP_END

NS_IMPL_ADDREF(nsGeoPosition)

NS_IMPL_RELEASE(nsGeoPosition)

NS_IMETHODIMP

nsGeoPosition::GetTimestamp(DOMTimeStamp* aTimestamp)

{

  *aTimestamp = mTimestamp;

  return NS_OK;

}

NS_IMETHODIMP

nsGeoPosition::GetCoords(nsIDOMGeoPositionCoords * *aCoords)

{

  NS_IF_ADDREF(*aCoords = mCoords);

  return NS_OK;

}

namespace mozilla {

namespace dom {

NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(Position, mParent, mCoordinates)

NS_IMPL_CYCLE_COLLECTING_ADDREF(Position)

NS_IMPL_CYCLE_COLLECTING_RELEASE(Position)

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Position)

  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY

  NS_INTERFACE_MAP_ENTRY(nsISupports)

NS_INTERFACE_MAP_END

Position::Position(nsISupports* aParent, nsIDOMGeoPosition* aGeoPosition)

  : mParent(aParent)

  , mGeoPosition(aGeoPosition)

{

}

Position::~Position()

{

}

nsISupports*

Position::GetParentObject() const

{

  return mParent;

}

JSObject*

Position::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)

{

  return Position_Binding::Wrap(aCx, this, aGivenProto);

}

Coordinates*

Position::Coords()

{

  if (!mCoordinates) {

    nsCOMPtr<nsIDOMGeoPositionCoords> coords;

    mGeoPosition->GetCoords(getter_AddRefs(coords));

    MOZ_ASSERT(coords, "coords should not be null");

    mCoordinates = new Coordinates(this, coords);

  }

  return mCoordinates;

}

uint64_t

Position::Timestamp() const

{

  uint64_t rv;

  mGeoPosition->GetTimestamp(&rv);

  return rv;

}

NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(Coordinates, mPosition)

NS_IMPL_CYCLE_COLLECTING_ADDREF(Coordinates)

NS_IMPL_CYCLE_COLLECTING_RELEASE(Coordinates)

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Coordinates)

  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY

  NS_INTERFACE_MAP_ENTRY(nsISupports)

NS_INTERFACE_MAP_END

Coordinates::Coordinates(Position* aPosition, nsIDOMGeoPositionCoords* aCoords)

  : mPosition(aPosition)

  , mCoords(aCoords)

{

}

Coordinates::~Coordinates()

{

}

Position*

Coordinates::GetParentObject() const

{

  return mPosition;

}

JSObject*

Coordinates::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)

{

  return Coordinates_Binding::Wrap(aCx, this, aGivenProto);

}

#define GENERATE_COORDS_WRAPPED_GETTER(name) \

double                                       \

Coordinates::name() const                    \

{                                            \

  double rv;                                 \

  mCoords->Get##name(&rv);                   \

  return rv;                                 \

}

Unexecuted instantiation: mozilla::dom::Coordinates::Latitude() const

Unexecuted instantiation: mozilla::dom::Coordinates::Longitude() const

Unexecuted instantiation: mozilla::dom::Coordinates::Accuracy() const

#define GENERATE_COORDS_WRAPPED_GETTER_NULLABLE(name) \

Nullable<double>                                      \

Coordinates::Get##name() const                        \

{                                                     \

  double value;                                       \

  mCoords->Get##name(&value);                         \

  Nullable<double> rv;                                \

  if (!IsNaN(value)) {                                \

    rv.SetValue(value);                               \

  }                                                   \

  return rv;                                          \

}

Unexecuted instantiation: mozilla::dom::Coordinates::GetAltitude() const

Unexecuted instantiation: mozilla::dom::Coordinates::GetAltitudeAccuracy() const

Unexecuted instantiation: mozilla::dom::Coordinates::GetHeading() const

Unexecuted instantiation: mozilla::dom::Coordinates::GetSpeed() const

GENERATE_COORDS_WRAPPED_GETTER(Latitude)

GENERATE_COORDS_WRAPPED_GETTER(Longitude)

GENERATE_COORDS_WRAPPED_GETTER_NULLABLE(Altitude)

GENERATE_COORDS_WRAPPED_GETTER(Accuracy)

GENERATE_COORDS_WRAPPED_GETTER_NULLABLE(AltitudeAccuracy)

GENERATE_COORDS_WRAPPED_GETTER_NULLABLE(Heading)

GENERATE_COORDS_WRAPPED_GETTER_NULLABLE(Speed)

#undef GENERATE_COORDS_WRAPPED_GETTER

#undef GENERATE_COORDS_WRAPPED_GETTER_NULLABLE

} // namespace dom

} // namespace mozilla