/****************************************************************************
 **
 ** Copyright (C) 2017 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtSensors module 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 "sensoritem.h"
 #include <QtCore/QDebug>
 #include <QtSensors>

 /*
     \class QSensorItem
     \brief The QSensorItem type provides information about the metadata from a sensors installed on the system.
 */

 /*
     Construct a QSensorItem object with parent \a parent
 */
 QSensorItem::QSensorItem(QObject* parent)
     : QObject(parent)
     , _qsensor(0)
 {
 }

 /*
     Construct a QSensorItem object with QSensor \a sensor and parent \a parent
 */
 QSensorItem::QSensorItem(QSensor* sensor, QObject* parent)
     : QObject(parent)
     , _qsensor(sensor)
 {
 }

 /*
     Destructor of a QSensorItem
 */
 QSensorItem::~QSensorItem()
 {
 }

 /*
     \fn QSensorItem::startChanged()
     Notifies the client if the sensors has changed its start active status
 */

 /*
     \property QSensorItem::start
     This property starts or stops the sensor
 */
 bool QSensorItem::start()
 {
     return (_qsensor ? _qsensor->isActive() : false);
 }

 void QSensorItem::setStart(bool run)
 {
     if (_qsensor)
         _qsensor->setActive(run);
 }

 /*
     \property QSensorItem::id
     Returns the sensor id of the sensor item
 */
 QString QSensorItem::id()
 {
     return (_qsensor ? _qsensor->identifier() : "");
 }

 /*
     Set the new value \a val to the QPropertyInfo object \a property
 */
 void QSensorItem::changePropertyValue(QPropertyInfo* property, const QString& val)
 {
     if (_qsensor && _sensorProperties.contains(property)){
         if ( _qsensor->setProperty(property->name().toLatin1().constData(), QVariant(val)))
             updateSensorPropertyValues();
         else
             qWarning() << "new property value couldn't be set";
     }
 }

 /*
     Reading the metadata and activates the sensor.
 */
 void QSensorItem::select()
 {
     if (_sensorProperties.isEmpty()) {
         // Probe the reading using Qt's meta-object facilities
         //Read properties from reader
         QSensorReading *reading = _qsensor->reading();
         const QMetaObject *mo = reading->metaObject();
         int firstProperty = QSensorReading::staticMetaObject.propertyOffset();

         for (int i = firstProperty; i < mo->propertyCount(); ++i) {
             QString typeName = QLatin1String(mo->property(i).typeName());
             int crap = typeName.lastIndexOf("::");
             if (crap != -1)
                 typeName = typeName.mid(crap + 2);

             QPropertyInfo* pi = new QPropertyInfo(mo->property(i).name()
                                                   , i
                                                   , isWriteable(mo->property(i).name())
                                                   , typeName
                                                   , "-"
                                                   , this);
             _readerProperties.append(pi);
         }

         //Read properties from sensor
         const QMetaObject *mo1 = _qsensor->metaObject();
         firstProperty = QSensorReading::staticMetaObject.propertyOffset();

         for (int i = firstProperty; i < mo1->propertyCount(); ++i) {
             QString propertyname = mo1->property(i).name();
             if (ignoreProperty(propertyname))
                 continue;

             QString typeName = QLatin1String(mo1->property(i).typeName());
             int crap = typeName.lastIndexOf("::");
             if (crap != -1)
                 typeName = typeName.mid(crap + 2);

             QPropertyInfo* pi = new QPropertyInfo(propertyname
                                                   , i
                                                   , isWriteable(propertyname)
                                                   , typeName
                                                   , "-"
                                                   , this);
             _sensorProperties.append(pi);
         }
         updateSensorPropertyValues();
         connect(_qsensor, SIGNAL(readingChanged()), this, SLOT(sensorReadingChanged()));
     }
     connect(_qsensor, SIGNAL(activeChanged()), SIGNAL(startChanged()));
 }

 /*
     Unselect the sensor by stopping the sensor.
 */
 void QSensorItem::unSelect()
 {
     _qsensor->stop();
     disconnect(_qsensor, SIGNAL(activeChanged()), this , SIGNAL(startChanged()));
 }

 /*
     Updates the property values from QSensor
 */
 void QSensorItem::updateSensorPropertyValues()
 {
     if (_qsensor){
         const QMetaObject *mo = _qsensor->metaObject();
         for (int i = 0; i < _sensorProperties.count(); i++){
             QVariant val = mo->property(_sensorProperties[i]->index()).read(_qsensor);
             _sensorProperties[i]->setValue(convertValue(_sensorProperties[i]->typeName(), val));
         }
     }
 }

 /*
     \fn QSensorItem::propertiesChanged()
     Notifies the client if the list of the properties was changed
 */

 /*
     Updates the property values from the QSensorReader
 */
 void QSensorItem::sensorReadingChanged()
 {
     QSensorReading *reading = _qsensor->reading();
     const QMetaObject *mo = reading->metaObject();
     for (int i = 0; i < _readerProperties.count(); i++){
         QVariant val = mo->property(_readerProperties[i]->index()).read(reading);
         _readerProperties[i]->setValue(convertValue(_readerProperties[i]->typeName(), val));
     }
 }

 /*
     Returns true if the property with the name \a propertyname should be ignored
 */
 bool QSensorItem::ignoreProperty(const QString& propertyname)
 {
     if (propertyname == "reading" ||
         propertyname == "active" ||
         propertyname == "identifier" ||
         propertyname == "connectedToBackend" ||
         propertyname == "busy")
         return true;

     return false;
 }

 /*
     Returns true if the property with the name \a propertyname is writeable
 */
 bool QSensorItem::isWriteable(const QString& propertyname)
 {
     if (_qsensor){
         const QMetaObject *mo = _qsensor->metaObject();
         int propertyindex = mo->indexOfProperty(propertyname.toLocal8Bit().constData());
         if (propertyindex >= 0){
             QMetaProperty prop = mo->property(propertyindex);
             return prop.isWritable();
         }
         else {
             QSensorReading *reading = _qsensor->reading();
             const QMetaObject *moreader = reading->metaObject();
             propertyindex = moreader->indexOfProperty(propertyname.toLocal8Bit().constData());
             if (propertyindex >= 0){
                 QMetaProperty prop = mo->property(propertyindex);
                 return prop.isWritable();
             }
         }
     }

     return false;
 }

 /*
     Convert the variant \a val dependent on the type \a type and returns the converted value as a QString
 */
 QString QSensorItem::convertValue(const QString& type, const QVariant& val)
 {
     if (type == "LightLevel"){
         switch (val.toInt()) {
             case 1: return "Dark";
             case 2: return "Twilight";
             case 3: return "Light";
             case 4: return "Bright";
             case 5: return "Sunny";
             default: return "Undefined";
         }
     }
     else if (type == "Orientation"){
         switch (val.toInt()) {
             case 1: return "TopUp";
             case 2: return "TopDown";
             case 3: return "LeftUp";
             case 4: return "RightUp";
             case 5: return "FaceUp";
             case 6: return "FaceDown";
             default: return "Undefined";
         }
     }
     else if (type == "qrangelist"){
         qrangelist rangelist = val.value<qrangelist>();
         QStringList ranges;
         foreach (const qrange &r, rangelist) {
             if (r.first == r.second)
                 ranges << QString("%1 Hz").arg(r.first);
             else
                 ranges << QString("%1-%2 Hz").arg(r.first).arg(r.second);
         }
         if (ranges.count() > 0)
             return ranges.join(", ");
         return "-";
     }
     else if (type == "qoutputrangelist") {
         qoutputrangelist rangelist = val.value<qoutputrangelist>();
         QStringList ranges;
         foreach (const qoutputrange &r, rangelist) {
             ranges << QString("(%1, %2) += %3").arg(r.minimum).arg(r.maximum).arg(r.accuracy);
         }
         if (ranges.count() > 0)
             return ranges.join(", ");
         return "-";
     }

     return val.toString();
 }

 /*
     \property QSensorItem::properties
     Returns a list of all properties from the sensor
 */
 QQmlListProperty<QPropertyInfo> QSensorItem::properties()
 {
     _properties.clear();
     _properties.append(_sensorProperties);
     _properties.append(_readerProperties);
     return QQmlListProperty<QPropertyInfo> (this, _properties);
 }