/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the QtLocation module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL3$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPLv3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or later as published by the Free
** Software Foundation and appearing in the file LICENSE.GPL included in
** the packaging of this file. Please review the following information to
** ensure the GNU General Public License version 2.0 requirements will be
** met: http://www.gnu.org/licenses/gpl-2.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qgeocameracapabilities_p.h"

#include <QSharedData>
#include <cmath>

static const double invLog2 = 1.0 / std::log(2.0);

static double zoomLevelTo256(double zoomLevelForTileSize, double tileSize)
{
    return std::log( std::pow(2.0, zoomLevelForTileSize) * tileSize / 256.0 ) * invLog2;
}

QT_BEGIN_NAMESPACE

class QGeoCameraCapabilitiesPrivate : public QSharedData
{
public:
    QGeoCameraCapabilitiesPrivate();
    QGeoCameraCapabilitiesPrivate(const QGeoCameraCapabilitiesPrivate &other);
    ~QGeoCameraCapabilitiesPrivate();

    QGeoCameraCapabilitiesPrivate &operator = (const QGeoCameraCapabilitiesPrivate &other);

    bool operator == (const QGeoCameraCapabilitiesPrivate &rhs) const;

    bool supportsBearing_;
    bool supportsRolling_;
    bool supportsTilting_;

    // this is mutable so that it can be set from accessor functions that are const
    // TODO: remove the mutable here
    mutable bool valid_;

    double minZoom_;
    double maxZoom_;
    double minTilt_;
    double maxTilt_;
    int tileSize_;
    double minimumFieldOfView_;
    double maximumFieldOfView_;
    bool overzoomEnabled_;
};

QGeoCameraCapabilitiesPrivate::QGeoCameraCapabilitiesPrivate()
    : supportsBearing_(false),
      supportsRolling_(false),
      supportsTilting_(false),
      valid_(false),
      minZoom_(0.0),
      maxZoom_(0.0),
      minTilt_(0.0),
      maxTilt_(0.0),
      tileSize_(256),
      minimumFieldOfView_(45.0),  // Defaulting to a fixed FOV of 45 degrees. Too large FOVs cause the loading of too many tiles
      maximumFieldOfView_(45.0),
      overzoomEnabled_(false) {}


QGeoCameraCapabilitiesPrivate::QGeoCameraCapabilitiesPrivate(const QGeoCameraCapabilitiesPrivate &other)
    : QSharedData(other),
      supportsBearing_(other.supportsBearing_),
      supportsRolling_(other.supportsRolling_),
      supportsTilting_(other.supportsTilting_),
      valid_(other.valid_),
      minZoom_(other.minZoom_),
      maxZoom_(other.maxZoom_),
      minTilt_(other.minTilt_),
      maxTilt_(other.maxTilt_),
      tileSize_(other.tileSize_),
      minimumFieldOfView_(other.minimumFieldOfView_),
      maximumFieldOfView_(other.maximumFieldOfView_),
      overzoomEnabled_(other.overzoomEnabled_){}


QGeoCameraCapabilitiesPrivate::~QGeoCameraCapabilitiesPrivate() {}

QGeoCameraCapabilitiesPrivate &QGeoCameraCapabilitiesPrivate::operator = (const QGeoCameraCapabilitiesPrivate &other)
{
    if (this == &other)
        return *this;

    supportsBearing_ = other.supportsBearing_;
    supportsRolling_ = other.supportsRolling_;
    supportsTilting_ = other.supportsTilting_;
    valid_ = other.valid_;
    minZoom_ = other.minZoom_;
    maxZoom_ = other.maxZoom_;
    minTilt_ = other.minTilt_;
    maxTilt_ = other.maxTilt_;
    tileSize_ = other.tileSize_;
    minimumFieldOfView_ = other.minimumFieldOfView_;
    maximumFieldOfView_ = other.maximumFieldOfView_;
    overzoomEnabled_ = other.overzoomEnabled_;

    return *this;
}

bool QGeoCameraCapabilitiesPrivate::operator == (const QGeoCameraCapabilitiesPrivate &rhs) const
{
    return ((supportsBearing_ == rhs.supportsBearing_)
            && (supportsRolling_ == rhs.supportsRolling_)
            && (supportsTilting_ == rhs.supportsTilting_)
            && (valid_ == rhs.valid_)
            && (minZoom_ == rhs.minZoom_)
            && (maxZoom_ == rhs.maxZoom_)
            && (minTilt_ == rhs.minTilt_)
            && (maxTilt_ == rhs.maxTilt_)
            && (tileSize_ == rhs.tileSize_)
            && (minimumFieldOfView_ == rhs.minimumFieldOfView_)
            && (maximumFieldOfView_ == rhs.maximumFieldOfView_)
            && (overzoomEnabled_ == rhs.overzoomEnabled_));
}

/*!
    \class QGeoCameraCapabilities
    \inmodule QtLocation
    \ingroup QtLocation-impl
    \since 5.6
    \internal

    \brief The QGeoCameraCapabilities class describes the limitations on camera settings imposed by a mapping plugin.

    Different mapping plugins will support different ranges of zoom levels, and not all mapping plugins will
    be able to support, bearing, tilting and rolling of the camera.

    This class describes what the plugin supports, and is used to restrict changes to the camera information
    associated with a \l QGeoMap such that the camera information stays within these limits.
*/

/*!
    Constructs a camera capabilities object.
*/
QGeoCameraCapabilities::QGeoCameraCapabilities()
    : d(new QGeoCameraCapabilitiesPrivate()) {}

/*!
    Constructs a camera capabilities object from the contents of \a other.
*/
QGeoCameraCapabilities::QGeoCameraCapabilities(const QGeoCameraCapabilities &other)
    : d(other.d) {}

/*!
    Destroys this camera capabilities object.
*/
QGeoCameraCapabilities::~QGeoCameraCapabilities() {}

/*!
    Assigns the contents of \a other to this camera capabilities object and
    returns a reference to this camera capabilities object.
*/
QGeoCameraCapabilities &QGeoCameraCapabilities::operator = (const QGeoCameraCapabilities &other)
{
    if (this == &other)
        return *this;

    d = other.d;
    return *this;
}

bool QGeoCameraCapabilities::operator == (const QGeoCameraCapabilities &rhs) const
{
    return (*(d.constData()) == *(rhs.d.constData()));
}

bool QGeoCameraCapabilities::operator != (const QGeoCameraCapabilities &other) const
{
    return !(operator==(other));
}

void QGeoCameraCapabilities::setTileSize(int tileSize)
{
    if (tileSize < 1)
        return;
    d->tileSize_ = tileSize;
}

int QGeoCameraCapabilities::tileSize() const
{
    return d->tileSize_;
}

/*!
    Returns whether this instance of the class is considered "valid". To be
    valid, the instance must have had at least one capability set (to either
    true or false) using a set method, or copied from another instance
    (such as by the assignment operator).
*/
bool QGeoCameraCapabilities::isValid() const
{
    return d->valid_;
}

/*!
    Sets the minimum zoom level supported by the associated plugin to \a maximumZoomLevel.

    Larger values of the zoom level correspond to more detailed views of the
    map.
*/
void QGeoCameraCapabilities::setMinimumZoomLevel(double minimumZoomLevel)
{
    d->minZoom_ = minimumZoomLevel;
    d->valid_ = true;
}

/*!
    Returns the minimum zoom level supported by the associated plugin.

    Larger values of the zoom level correspond to more detailed views of the
    map.
*/
double QGeoCameraCapabilities::minimumZoomLevel() const
{
    return d->minZoom_;
}

double QGeoCameraCapabilities::minimumZoomLevelAt256() const
{
    if (d->tileSize_ == 256)
        return d->minZoom_;
    return qMax<double>(0, zoomLevelTo256(d->minZoom_, d->tileSize_));
}

/*!
    Sets the maximum zoom level supported by the associated plugin to \a maximumZoomLevel.

    Larger values of the zoom level correspond to more detailed views of the
    map.
*/
void QGeoCameraCapabilities::setMaximumZoomLevel(double maximumZoomLevel)
{
    d->maxZoom_ = maximumZoomLevel;
    d->valid_ = true;
}

/*!
    Returns the maximum zoom level supported by the associated plugin.

    Larger values of the zoom level correspond to more detailed views of the
    map.
*/
double QGeoCameraCapabilities::maximumZoomLevel() const
{
    return d->maxZoom_;
}

double QGeoCameraCapabilities::maximumZoomLevelAt256() const
{
    if (d->tileSize_ == 256)
        return d->maxZoom_;
    return qMax<double>(0, zoomLevelTo256(d->maxZoom_, d->tileSize_));
}

/*!
    Sets whether the associated plugin can render a map when the camera
    has an arbitrary bearing to \a supportsBearing.
*/
void QGeoCameraCapabilities::setSupportsBearing(bool supportsBearing)
{
    d->supportsBearing_ = supportsBearing;
    d->valid_ = true;
}

/*!
    Returns whether the associated plugin can render a map when the camera
    has an arbitrary bearing.
*/
bool QGeoCameraCapabilities::supportsBearing() const
{
    return d->supportsBearing_;
}

/*!
    Sets whether the associated plugin can render a map when the
    camera is rolled to \a supportsRolling.
*/
void QGeoCameraCapabilities::setSupportsRolling(bool supportsRolling)
{
    d->supportsRolling_ = supportsRolling;
    d->valid_ = true;
}

/*!
    Returns whether the associated plugin can render a map when the
    camera is rolled.
*/
bool QGeoCameraCapabilities::supportsRolling() const
{
    return d->supportsRolling_;
}

/*!
    Sets whether the associated plugin can render a map when the
    camera is tilted to \a supportsTilting.
*/
void QGeoCameraCapabilities::setSupportsTilting(bool supportsTilting)
{
    d->supportsTilting_ = supportsTilting;
    d->valid_ = true;
}

/*!
    Returns whether the associated plugin can render a map when the
    camera is tilted.
*/
bool QGeoCameraCapabilities::supportsTilting() const
{
    return d->supportsTilting_;
}

/*!
    Sets the minimum tilt supported by the associated plugin to \a minimumTilt.

    The value is in degrees where 0 is equivalent to 90 degrees between
    the line of view and earth's surface, that is, looking straight down to earth.
*/
void QGeoCameraCapabilities::setMinimumTilt(double minimumTilt)
{
    d->minTilt_ = minimumTilt;
    d->valid_ = true;
}

/*!
    Returns the minimum tilt supported by the associated plugin.

    The value is in degrees where 0 is equivalent to 90 degrees between
    the line of view and earth's surface, that is, looking straight down to earth.
*/
double QGeoCameraCapabilities::minimumTilt() const
{
    return d->minTilt_;
}

/*!
    Sets the maximum tilt supported by the associated plugin to \a maximumTilt.

    The value is in degrees where 0 is equivalent to 90 degrees between
    the line of view and earth's surface, that is, looking straight down to earth.
*/
void QGeoCameraCapabilities::setMaximumTilt(double maximumTilt)
{
    d->maxTilt_ = maximumTilt;
    d->valid_ = true;
}

/*!
    Returns the maximum tilt supported by the associated plugin.

    The value is in degrees where 0 is equivalent to 90 degrees between
    the line of view and earth's surface, that is, looking straight down to earth.
*/
double QGeoCameraCapabilities::maximumTilt() const
{
    return d->maxTilt_;
}

/*!
    Sets the minimum field of view supported by the associated plugin to \a minimumFieldOfView.
    The value is in degrees and is clamped against a [1, 179] range.

    \since 5.9
*/
void QGeoCameraCapabilities::setMinimumFieldOfView(double minimumFieldOfView)
{
    d->minimumFieldOfView_ = qBound(1.0, minimumFieldOfView, 179.0);
    d->valid_ = true;
}

/*!
    Returns the minimum field of view supported by the associated plugin.
    The value is in degrees.

    \since 5.9
*/
double QGeoCameraCapabilities::minimumFieldOfView() const
{
    return d->minimumFieldOfView_;
}

/*!
    Sets the maximum field of view supported by the associated plugin to \a maximumFieldOfView.
    The value is in degrees and is clamped against a [1, 179] range.

    \since 5.9
*/
void QGeoCameraCapabilities::setMaximumFieldOfView(double maximumFieldOfView)
{
    d->maximumFieldOfView_ = qBound(1.0, maximumFieldOfView, 179.0);
    d->valid_ = true;
}

/*!
    Returns the maximum field of view supported by the associated plugin.
    The value is in degrees.

    \since 5.9
*/
double QGeoCameraCapabilities::maximumFieldOfView() const
{
    return d->maximumFieldOfView_;
}

/*!
    Sets whether overzooming is supported by the associated plugin.

    Overzooming means that zoom levels outside the [minimumZL, maximumZL] range can be set,
    and if tiles aren't available for those zoom levels, either tiles from other zoom levels
    will be used, or nothing will be shown.

    Set this value to false if the plugin is not capable of that. For example if using
    a mapping engine that always clamp the zoomLevel value, which may cause misalignment in case
    of stacked map elements.

    \since 5.9
*/
void QGeoCameraCapabilities::setOverzoomEnabled(bool overzoomEnabled)
{
    d->overzoomEnabled_ = overzoomEnabled;
    d->valid_ = true;
}

/*!
    Returns whether overzooming is supported by the associated plugin.

    \since 5.9
*/
bool QGeoCameraCapabilities::overzoomEnabled() const
{
    return d->overzoomEnabled_;
}


QT_END_NAMESPACE