/****************************************************************************
**
** Copyright (C) 2017 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the examples of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** 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 https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** BSD License Usage
** Alternatively, you may use this file under the terms of the BSD license
** as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
**   * Redistributions of source code must retain the above copyright
**     notice, this list of conditions and the following disclaimer.
**   * Redistributions in binary form must reproduce the above copyright
**     notice, this list of conditions and the following disclaimer in
**     the documentation and/or other materials provided with the
**     distribution.
**   * Neither the name of The Qt Company Ltd nor the names of its
**     contributors may be used to endorse or promote products derived
**     from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "satellitemodel.h"
#include <QTimer>
#include <QDebug>

SatelliteModel::SatelliteModel(QObject *parent) :
    QAbstractListModel(parent), source(0), m_componentCompleted(false), m_running(false),
    m_runningRequested(false), demo(false), isSingle(false), singleRequestServed(false)
{
    source = QGeoSatelliteInfoSource::createDefaultSource(this);
    if (!demo && !source) {
        qWarning() << "No satellite data source found. Changing to demo mode.";
        demo = true;
    }
    if (!demo) {
        source->setUpdateInterval(3000);
        connect(source, SIGNAL(satellitesInViewUpdated(QList<QGeoSatelliteInfo>)),
                this, SLOT(satellitesInViewUpdated(QList<QGeoSatelliteInfo>)));
        connect(source, SIGNAL(satellitesInUseUpdated(QList<QGeoSatelliteInfo>)),
                this, SLOT(satellitesInUseUpdated(QList<QGeoSatelliteInfo>)));
        connect(source, SIGNAL(error(QGeoSatelliteInfoSource::Error)),
                this, SLOT(error(QGeoSatelliteInfoSource::Error)));
    }

    if (demo) {
        timer = new QTimer(this);
        connect(timer, SIGNAL(timeout()), this, SLOT(updateDemoData()));
        timer->start(3000);
    }
}

int SatelliteModel::rowCount(const QModelIndex &parent) const
{
    Q_UNUSED(parent);
    if (!source && !demo)
        return 0;

    return knownSatellites.count();
}

QVariant SatelliteModel::data(const QModelIndex &index, int role) const
{
    if (!demo && !source)
        return QVariant();

    if (!index.isValid() || index.row() < 0)
        return QVariant();

    if (index.row() >= knownSatellites.count()) {
        qWarning() << "SatelliteModel: Index out of bound";
        return QVariant();
    }

    const QGeoSatelliteInfo &info = knownSatellites.at(index.row());
    switch (role) {
    case IdentifierRole:
        return info.satelliteIdentifier();
    case InUseRole:
        return satellitesInUse.contains(info.satelliteIdentifier());
    case SignalStrengthRole:
        return info.signalStrength();
    case ElevationRole:
        if (!info.hasAttribute(QGeoSatelliteInfo::Elevation))
            return QVariant();
        return info.attribute(QGeoSatelliteInfo::Elevation);
    case AzimuthRole:
        if (!info.hasAttribute(QGeoSatelliteInfo::Azimuth))
            return QVariant();
        return info.attribute(QGeoSatelliteInfo::Azimuth);
    default:
        break;

    }

    return QVariant();
}

QHash<int, QByteArray> SatelliteModel::roleNames() const
{
    QHash<int, QByteArray> roleNames;
    roleNames.insert(IdentifierRole, "satelliteIdentifier");
    roleNames.insert(InUseRole, "isInUse");
    roleNames.insert(SignalStrengthRole, "signalStrength");
    roleNames.insert(ElevationRole, "elevation");
    roleNames.insert(AzimuthRole, "azimuth");
    return roleNames;
}

void SatelliteModel::componentComplete()
{
    m_componentCompleted = true;
    if (m_runningRequested)
        setRunning(true);
}

bool SatelliteModel::running() const
{
    return m_running;
}

bool SatelliteModel::isSingleRequest() const
{
    return isSingle;
}

void SatelliteModel::setSingleRequest(bool single)
{
    if (running()) {
        qWarning() << "Cannot change single request mode while running";
        return;
    }

    if (single != isSingle) { //flag changed
        isSingle = single;
        emit singleRequestChanged();
    }
}

void SatelliteModel::setRunning(bool isActive)
{
    if (!source && !demo)
        return;

    if (!m_componentCompleted) {
        m_runningRequested = isActive;
        return;
    }

    if (m_running == isActive)
        return;

    m_running = isActive;

    if (m_running) {
        clearModel();
        if (demo)
            timer->start(2000);
        else if (isSingleRequest())
            source->requestUpdate(10000);
        else
            source->startUpdates();

        if (demo)
            singleRequestServed = false;
    } else {
        if (demo)
            timer->stop();
        else if (!isSingleRequest())
            source->stopUpdates();
    }

    Q_EMIT runningChanged();
}

int SatelliteModel::entryCount() const
{
    return knownSatellites.count();
}

bool SatelliteModel::canProvideSatelliteInfo() const
{
    return !demo;
}

void SatelliteModel::clearModel()
{
    beginResetModel();
    knownSatelliteIds.clear();
    knownSatellites.clear();
    satellitesInUse.clear();
    endResetModel();
}

void SatelliteModel::updateDemoData()
{
    static bool flag = true;
    QList<QGeoSatelliteInfo> satellites;
    if (flag) {
        for (int i = 0; i<5; i++) {
            QGeoSatelliteInfo info;
            info.setSatelliteIdentifier(i);
            info.setSignalStrength(20 + 20*i);
            satellites.append(info);
        }
    } else {
        for (int i = 0; i<9; i++) {
            QGeoSatelliteInfo info;
            info.setSatelliteIdentifier(i*2);
            info.setSignalStrength(20 + 10*i);
            satellites.append(info);
        }
    }

    satellitesInViewUpdated(satellites);
    flag ? satellitesInUseUpdated(QList<QGeoSatelliteInfo>() << satellites.at(2))
         : satellitesInUseUpdated(QList<QGeoSatelliteInfo>() << satellites.at(3));
    flag = !flag;

    emit errorFound(flag);

    if (isSingleRequest() && !singleRequestServed) {
        singleRequestServed = true;
        setRunning(false);
    }
}

void SatelliteModel::error(QGeoSatelliteInfoSource::Error error)
{
    emit errorFound((int)error);
}

inline bool operator<(const QGeoSatelliteInfo& a, const QGeoSatelliteInfo& b)
{
    return a.satelliteIdentifier() < b.satelliteIdentifier();
}

void SatelliteModel::satellitesInViewUpdated(const QList<QGeoSatelliteInfo> &infos)
{
    if (!running())
        return;

    int oldEntryCount = knownSatellites.count();

    QSet<int> satelliteIdsInUpdate;
    foreach (const QGeoSatelliteInfo &info, infos)
        satelliteIdsInUpdate.insert(info.satelliteIdentifier());

    QSet<int> toBeRemoved = knownSatelliteIds - satelliteIdsInUpdate;

    //We reset the model as in reality just about all entry values change
    //and there are generally a lot of inserts and removals each time
    //Hence we don't bother with complex model update logic beyond resetModel()
    beginResetModel();

    knownSatellites = infos;

    //sort them for presentation purposes
    std::sort(knownSatellites.begin(), knownSatellites.end());

    //remove old "InUse" data
    //new satellites are by default not in "InUse"
    //existing satellites keep their "inUse" state
    satellitesInUse -= toBeRemoved;

    knownSatelliteIds = satelliteIdsInUpdate;
    endResetModel();

    if (oldEntryCount != knownSatellites.count())
        emit entryCountChanged();
}

void SatelliteModel::satellitesInUseUpdated(const QList<QGeoSatelliteInfo> &infos)
{
    if (!running())
        return;

    beginResetModel();

    satellitesInUse.clear();
    foreach (const QGeoSatelliteInfo &info, infos)
        satellitesInUse.insert(info.satelliteIdentifier());

    endResetModel();
}