/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* Copyright 2013 - 2025, nymea GmbH
* Contact: contact@nymea.io
*
* This file is part of nymea.
* This project including source code and documentation is protected by
* copyright law, and remains the property of nymea GmbH. All rights, including
* reproduction, publication, editing and translation, are reserved. The use of
* this project is subject to the terms of a license agreement to be concluded
* with nymea GmbH in accordance with the terms of use of nymea GmbH, available
* under https://nymea.io/license
*
* GNU Lesser General Public License Usage
* Alternatively, this project may be redistributed and/or modified under the
* terms of the GNU Lesser General Public License as published by the Free
* Software Foundation; version 3. This project is distributed in the hope that
* it will be useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this project. If not, see <https://www.gnu.org/licenses/>.
*
* For any further details and any questions please contact us under
* contact@nymea.io or see our FAQ/Licensing Information on
* https://nymea.io/license/faq
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#include "integrationpluginsenec.h"
#include "senecdiscovery.h"
#include "plugininfo.h"

#include <QJsonDocument>
#include <QJsonParseError>

#include <network/networkdevicediscovery.h>

#include "senecconnection.h"

IntegrationPluginSenec::IntegrationPluginSenec()
{
    // Testing the convert methods

    // QString rawValue = "fl_42A2E5E4"; // 81.449
    // float value = SenecStorageLan::parseFloat(rawValue);
    // qCWarning(dcSenec()) << rawValue << value;

    // QString rawValue = "st_foobar"; // foobar
    // QString value = SenecStorageLan::parseString(rawValue);
    // qCWarning(dcSenec()) << rawValue << value;

    // QString rawValue = "u8_64"; // 100
    // quint8 value = SenecStorageLan::parseUInt8(rawValue);
    // qCWarning(dcSenec()) << rawValue << value;


}

IntegrationPluginSenec::~IntegrationPluginSenec()
{

}

void IntegrationPluginSenec::discoverThings(ThingDiscoveryInfo *info)
{
    if (info->thingClassId() == senecStorageLanThingClassId) {

        if (!hardwareManager()->networkDeviceDiscovery()->available()) {
            qCWarning(dcSenec()) << "Failed to discover network devices. The network device discovery is not available.";
            info->finish(Thing::ThingErrorHardwareNotAvailable, QT_TR_NOOP("Unable to discover devices in your network."));
            return;
        }

        qCInfo(dcSenec()) << "Starting network discovery...";
        SenecDiscovery *discovery = new SenecDiscovery(hardwareManager()->networkManager(), hardwareManager()->networkDeviceDiscovery(), info);
        connect(discovery, &SenecDiscovery::discoveryFinished, info, [=](){
            ThingDescriptors descriptors;
            qCInfo(dcSenec()) << "Discovery finished. Found" << discovery->results().count() << "devices";
            foreach (const SenecDiscovery::Result &result, discovery->results()) {
                qCInfo(dcSenec()) << "Discovered device on" << result.networkDeviceInfo;

                QString title = "SENEC connection (" + result.deviceId + ")";
                QString description = result.networkDeviceInfo.address().toString();

                ThingDescriptor descriptor(senecStorageLanThingClassId, title, description);

                ParamList params;
                params << Param(senecStorageLanThingMacAddressParamTypeId, result.networkDeviceInfo.thingParamValueMacAddress());
                params << Param(senecStorageLanThingHostNameParamTypeId, result.networkDeviceInfo.thingParamValueHostName());
                params << Param(senecStorageLanThingAddressParamTypeId, result.networkDeviceInfo.thingParamValueAddress());
                descriptor.setParams(params);

                // Check if we already have set up this device
                Thing *existingThing = myThings().findByParams(params);
                if (existingThing) {
                    qCDebug(dcSenec()) << "This thing already exists in the system:" << result.networkDeviceInfo;
                    descriptor.setThingId(existingThing->id());
                }

                info->addThingDescriptor(descriptor);
            }

            info->finish(Thing::ThingErrorNoError);
        });

        discovery->startDiscovery();
    }
}

void IntegrationPluginSenec::startPairing(ThingPairingInfo *info)
{
    if (info->thingClassId() == senecConnectionThingClassId) {
        qCDebug(dcSenec()) << "Start pairing process ...";

        SenecConnection *connection = new SenecConnection(hardwareManager()->networkManager(), this);
        //m_unfinishedTadoAccounts.insert(info->thingId(), tado);

        connect(info, &ThingPairingInfo::aborted, this, [connection]() {
            qCWarning(dcSenec()) << "Thing pairing has been aborted, cleaning up...";
            //m_unfinishedTadoAccounts.remove(info->thingId());
            connection->deleteLater();
        });

        connect(connection, &SenecConnection::initFinished, info, [info, connection] (bool success) {
            if (!success) {
                info->finish(Thing::ThingErrorAuthenticationFailure);
                return;
            }

            qCDebug(dcSenec()) << "Senec server is reachable. Starting the OpenID auth process" << connection->authEndpoint().toString(QUrl::FullyEncoded);
            info->setOAuthUrl(connection->authEndpoint());
            info->finish(Thing::ThingErrorNoError);
        });

        connection->initialize();
    }
}

void IntegrationPluginSenec::confirmPairing(ThingPairingInfo *info, const QString &username, const QString &secret)
{
    if (info->thingClassId() == senecAccountThingClassId) {

        qCDebug(dcSenec()) << "Start logging in" << username << secret.left(2) + QString(secret.length() - 2, '*');

        QVariantMap requestMap;
        requestMap.insert("username", username);
        requestMap.insert("password", secret);

        QNetworkRequest request(SenecAccount::loginUrl());
        request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");

        QNetworkReply *reply = hardwareManager()->networkManager()->post(request, QJsonDocument::fromVariant(requestMap).toJson(QJsonDocument::Indented));
        connect(reply, &QNetworkReply::finished, reply, &QNetworkReply::deleteLater);
        connect(reply, &QNetworkReply::finished, this, [reply, info, username, this] {

            int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
            // Check HTTP status code
            if (status != 200 || reply->error() != QNetworkReply::NoError) {
                qCWarning(dcSenec()) << "Login request finished with error. Status:" << status << "Error:" << reply->errorString();
                info->finish(Thing::ThingErrorAuthenticationFailure, QT_TR_NOOP("Username or password is invalid."));
                return;
            }

            // Note: as of now (API 4.4.3) the login seems to return a static token, which does not require any refresh.
            // Not as bad as saving user and password on the device, but almost ...

            // https://documenter.getpostman.com/view/932140/2s9YXib2td

            QByteArray responseData = reply->readAll();

            QJsonParseError jsonError;
            QVariantMap responseMap = QJsonDocument::fromJson(responseData, &jsonError).toVariant().toMap();
            if (jsonError.error != QJsonParseError::NoError) {
                qCWarning(dcSenec()) << "Login request finished successfully, but the response contains invalid JSON object:" << responseData;
                info->finish(Thing::ThingErrorAuthenticationFailure);
                return;
            }

            if (!responseMap.contains("token") || !responseMap.contains("refreshToken")) {
                qCWarning(dcSenec()) << "Login request finished successfully, but the response JSON does not contain the expected properties" << qUtf8Printable(responseData);
                info->finish(Thing::ThingErrorHardwareFailure);
                return;
            }

            QString token = responseMap.value("token").toString();
            QString refreshToken = responseMap.value("refreshToken").toString();

            pluginStorage()->beginGroup(info->thingId().toString());
            pluginStorage()->setValue("username", username);
            pluginStorage()->setValue("token", token);
            pluginStorage()->setValue("refreshToken", refreshToken);
            pluginStorage()->endGroup();

            info->finish(Thing::ThingErrorNoError);
        });
    }
}

void IntegrationPluginSenec::setupThing(ThingSetupInfo *info)
{
    Thing *thing = info->thing();
    qCDebug(dcSenec()) << "Setting up" << thing->name() << thing->params();

    if (thing->thingClassId() == senecAccountThingClassId) {
        // Load login information
        pluginStorage()->beginGroup(thing->id().toString());
        QString token = pluginStorage()->value("token").toString();
        QString refreshToken = pluginStorage()->value("refreshToken").toString();
        QString username = pluginStorage()->value("username").toString();
        pluginStorage()->endGroup();

        SenecAccount *account = new SenecAccount(hardwareManager()->networkManager(), username, token, refreshToken, this);
        m_accounts.insert(thing, account);
        info->finish(Thing::ThingErrorNoError);

        thing->setStateValue(senecAccountUserDisplayNameStateTypeId, username);

    } if (thing->thingClassId() == senecStorageLanThingClassId) {

        // Handle reconfigure
        if (m_monitors.contains(thing)) {
            qCDebug(dcSenec()) << "Unregister existing monitor and recreate a new one...";
            hardwareManager()->networkDeviceDiscovery()->unregisterMonitor(m_monitors.take(thing));
        }

        NetworkDeviceMonitor *monitor = hardwareManager()->networkDeviceDiscovery()->registerMonitor(thing);
        m_monitors.insert(thing, monitor);

        SenecStorageLan *storage = new SenecStorageLan(hardwareManager()->networkManager(), monitor->networkDeviceInfo().address(), this);
        m_storages.insert(thing, storage);

        connect(monitor, &NetworkDeviceMonitor::reachableChanged, storage, [monitor, storage](bool reachable){
            if (reachable) {
                storage->setAddress(monitor->networkDeviceInfo().address());
                storage->initialize();
            }
        });

        connect(storage, &SenecStorageLan::availableChanged, thing, [thing, this](bool available){
            thing->setStateValue(senecStorageLanConnectedStateTypeId, available);

            foreach (Thing *child, myThings().filterByParentId(thing->id())) {
                child->setStateValue("connected", available);
            }
        });

        connect(storage, &SenecStorageLan::updatedFinished, thing, [storage, thing, this](bool success){

            thing->setStateValue(senecStorageLanConnectedStateTypeId, storage->available());
            foreach (Thing *child, myThings().filterByParentId(thing->id())) {
                child->setStateValue("connected", storage->available());
            }

            if (!success)
                return;

            thing->setStateValue(senecStorageLanCapacityStateTypeId, storage->capacity());
            thing->setStateValue(senecStorageLanBatteryLevelStateTypeId, storage->batteryLevel());
            thing->setStateValue(senecStorageLanBatteryCriticalStateTypeId, storage->batteryLevel() < 10.0);
            thing->setStateValue(senecStorageLanCurrentPowerStateTypeId, storage->batteryPower());
            if (storage->batteryPower() > 0) {
                thing->setStateValue(senecStorageLanChargingStateStateTypeId, "charging");
            } else if (storage->batteryPower() < 0) {
                thing->setStateValue(senecStorageLanChargingStateStateTypeId, "discharging");
            } else {
                thing->setStateValue(senecStorageLanChargingStateStateTypeId, "idle");
            }

            // Check if we have a meter
            Thing *meterThing = nullptr;
            Things meterThings = myThings().filterByThingClassId(senecMeterThingClassId).filterByParentId(thing->id());

            if (!meterThings.isEmpty())
                meterThing = meterThings.first();

            // If so, update
            if (meterThing) {
                meterThing->setStateValue(senecMeterCurrentPowerStateTypeId, storage->gridPower());
                meterThing->setStateValue(senecMeterConnectedStateTypeId, true);
            }

            // Check if we have an inverter
            Thing *inverterThing = nullptr;
            Things inverterThings = myThings().filterByThingClassId(senecInverterThingClassId).filterByParentId(thing->id());
            if (!inverterThings.isEmpty()) {
                inverterThing = inverterThings.first();
            }

            // If so, update
            if (inverterThing) {
                inverterThing->setStateValue(senecInverterCurrentPowerStateTypeId, storage->inverterPower());
                inverterThing->setStateValue(senecInverterConnectedStateTypeId, true);
            }
        });

        connect(thing, &Thing::settingChanged, this, [this, thing](const ParamTypeId &paramTypeId, const QVariant &value){
            if (paramTypeId == senecStorageLanSettingsAddMeterParamTypeId) {

                if (value.toBool()) {
                    // Check if we have to add the meter
                    if (myThings().filterByThingClassId(senecMeterThingClassId).filterByParentId(thing->id()).isEmpty()) {
                        qCDebug(dcSenec()) << "Add meter for" << thing->name();
                        emit autoThingsAppeared(ThingDescriptors() << ThingDescriptor(senecMeterThingClassId, "SENEC Meter", QString(), thing->id()));
                    }
                } else {
                    // Check if we have to remove the meter
                    Things existingMeters = myThings().filterByThingClassId(senecMeterThingClassId).filterByParentId(thing->id());
                    if (!existingMeters.isEmpty()) {
                        qCDebug(dcSenec()) << "Remove meter thing for" << thing->name();
                        emit autoThingDisappeared(existingMeters.takeFirst()->id());
                    }
                }
            } else if (paramTypeId == senecStorageLanSettingsAddMeterParamTypeId) {

                if (value.toBool()) {
                    // Check if we have to add the meter
                    if (myThings().filterByThingClassId(senecInverterThingClassId).filterByParentId(thing->id()).isEmpty()) {
                        qCDebug(dcSenec()) << "Add inverter for" << thing->name();
                        emit autoThingsAppeared(ThingDescriptors() << ThingDescriptor(senecInverterThingClassId, "SENEC Inverter", QString(), thing->id()));
                    }
                } else {
                    // Check if we have to remove the meter
                    Things existingInverters = myThings().filterByThingClassId(senecInverterThingClassId).filterByParentId(thing->id());
                    if (!existingInverters.isEmpty()) {
                        qCDebug(dcSenec()) << "Remove inverter thing for" << thing->name();
                        emit autoThingDisappeared(existingInverters.takeFirst()->id());
                    }
                }
            }
        });

        info->finish(Thing::ThingErrorNoError);

        storage->initialize();

    } else if (thing->thingClassId() == senecStorageThingClassId) {

        connect(thing, &Thing::settingChanged, this, [this, thing](const ParamTypeId &paramTypeId, const QVariant &value){
            if (paramTypeId == senecStorageSettingsCapacityParamTypeId) {
                thing->setStateValue(senecStorageCapacityStateTypeId, value.toDouble());
            } else if (paramTypeId == senecStorageSettingsAddMeterParamTypeId) {

                if (value.toBool()) {
                    // Check if we have to add the meter
                    if (myThings().filterByThingClassId(senecMeterThingClassId).filterByParentId(thing->id()).isEmpty()) {
                        qCDebug(dcSenec()) << "Add meter for" << thing->name();
                        emit autoThingsAppeared(ThingDescriptors() << ThingDescriptor(senecMeterThingClassId, "SENEC Meter", QString(), thing->id()));
                    }
                } else {
                    // Check if we have to remove the meter
                    Things existingMeters = myThings().filterByThingClassId(senecMeterThingClassId).filterByParentId(thing->id());
                    if (!existingMeters.isEmpty()) {
                        qCDebug(dcSenec()) << "Remove meter thing for" << thing->name();
                        emit autoThingDisappeared(existingMeters.takeFirst()->id());
                    }
                }
            } else if (paramTypeId == senecStorageSettingsAddInverterParamTypeId) {

                if (value.toBool()) {
                    // Check if we have to add the meter
                    if (myThings().filterByThingClassId(senecInverterThingClassId).filterByParentId(thing->id()).isEmpty()) {
                        qCDebug(dcSenec()) << "Add inverter for" << thing->name();
                        emit autoThingsAppeared(ThingDescriptors() << ThingDescriptor(senecInverterThingClassId, "SENEC Inverter", QString(), thing->id()));
                    }
                } else {
                    // Check if we have to remove the meter
                    Things existingInverters = myThings().filterByThingClassId(senecInverterThingClassId).filterByParentId(thing->id());
                    if (!existingInverters.isEmpty()) {
                        qCDebug(dcSenec()) << "Remove inverter thing for" << thing->name();
                        emit autoThingDisappeared(existingInverters.takeFirst()->id());
                    }
                }
            }
        });

        info->finish(Thing::ThingErrorNoError);

    } else if (thing->thingClassId() == senecMeterThingClassId) {
        info->finish(Thing::ThingErrorNoError);
    } else if (thing->thingClassId() == senecInverterThingClassId) {
        info->finish(Thing::ThingErrorNoError);
    }
}

void IntegrationPluginSenec::postSetupThing(Thing *thing)
{
    if (thing->thingClassId() == senecAccountThingClassId) {

        // Search for now things, first poll the
        SenecAccount *account = m_accounts.value(thing);

        // Check installation, create things if not already created
        QNetworkReply *reply = account->getSystems();
        connect(reply, &QNetworkReply::finished, reply, &QNetworkReply::deleteLater);
        connect(reply, &QNetworkReply::finished, account, [reply, thing, this] {

            int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
            // Check HTTP status code
            if (status != 200 || reply->error() != QNetworkReply::NoError) {
                qCWarning(dcSenec()) << "Systems request finished with error. Status:" << status << "Error:" << reply->errorString();
                if (status == 401) {
                    qCWarning(dcSenec()) << "Authentication error, reconfigure and re-login should fix this problem.";
                    thing->setStateValue(senecAccountLoggedInStateTypeId, false);
                }

                thing->setStateValue(senecAccountConnectedStateTypeId, false);
                return;
            }

            QByteArray responseData = reply->readAll();

            QJsonParseError jsonError;
            QJsonDocument jsonDoc = QJsonDocument::fromJson(responseData, &jsonError);
            QVariant responseVariant = jsonDoc.toVariant();
            if (jsonError.error != QJsonParseError::NoError) {
                qCWarning(dcSenec()) << "Systems request finished successfully, but the response contains invalid JSON object:" << responseData;
                thing->setStateValue(senecAccountConnectedStateTypeId, false);
                return;
            }

            qCDebug(dcSenec()) << "Systems request finished successfully" << qUtf8Printable(jsonDoc.toJson());
            thing->setStateValue(senecAccountLoggedInStateTypeId, true);
            thing->setStateValue(senecAccountConnectedStateTypeId, true);

            ThingDescriptors descriptors;
            foreach (const QVariant &installation, responseVariant.toList()) {
                QVariantMap installationMap = installation.toMap();

                // Note: for now we only support V4 systems
                if (!installationMap.value("systemType").toString().toLower().contains("v4"))
                    continue;

                // This is a V4 storage, let's check if we already created one
                QString id = installationMap.value("id").toString();
                Things existingThings = myThings().filterByThingClassId(senecStorageThingClassId).filterByParam(senecStorageThingIdParamTypeId, id);
                if (existingThings.isEmpty()) {
                    qCDebug(dcSenec()) << "Creating new storage for" << id;
                    ThingDescriptor descriptor(senecStorageThingClassId, "SENEC.Home P4", id);
                    descriptor.setParentId(thing->id());
                    ParamList params;
                    params.append(Param(senecStorageThingIdParamTypeId, id));
                    descriptor.setParams(params);
                    descriptors.append(descriptor);
                } else {
                    qCDebug(dcSenec()) << "Thing for storage" << id << "already created.";
                }
            }

            if (!descriptors.isEmpty()) {
                qCDebug(dcSenec()) << "Adding" << descriptors.count() << "new SENEC.Home" << (descriptors.count() > 1 ? "storages" : "storage");
                emit autoThingsAppeared(descriptors);
            }
        });
    } else if (thing->thingClassId() == senecStorageThingClassId) {

        thing->setStateValue(senecStorageCapacityStateTypeId, thing->setting(senecStorageSettingsCapacityParamTypeId).toDouble());

        SenecAccount *account = m_accounts.value(myThings().findById(thing->parentId()));
        QString id = thing->paramValue(senecStorageThingIdParamTypeId).toString();

        QNetworkReply *reply = account->getTechnicalData(id);
        connect(reply, &QNetworkReply::finished, reply, &QNetworkReply::deleteLater);
        connect(reply, &QNetworkReply::finished, account, [reply, thing, this] {

            int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
            // Check HTTP status code
            if (status != 200 || reply->error() != QNetworkReply::NoError) {
                qCWarning(dcSenec()) << "Technical data request finished with error. Status:" << status << "Error:" << reply->errorString();
                thing->setStateValue(senecStorageConnectedStateTypeId, false);
                return;
            }

            QByteArray responseData = reply->readAll();

            QJsonParseError jsonError;
            QJsonDocument jsonDoc = QJsonDocument::fromJson(responseData, &jsonError);
            //QVariantMap responseMap = jsonDoc.toVariant().toMap();
            if (jsonError.error != QJsonParseError::NoError) {
                qCWarning(dcSenec()) << "Technical data request finished successfully, but the response contains invalid JSON object:" << responseData;
                return;
            }

            qCDebug(dcSenec()) << "Technical data request finished successfully" << qUtf8Printable(jsonDoc.toJson());
            thing->setStateValue(senecStorageConnectedStateTypeId, true);

            refresh(thing);
        });
    }

    // Create the refresh timer if not already set up
    if (!m_refreshTimer) {
        qCDebug(dcSenec()) << "Starting refresh timer ...";
        m_refreshTimer = hardwareManager()->pluginTimerManager()->registerTimer(5);
        connect(m_refreshTimer, &PluginTimer::timeout, this, [this](){
            refresh();
        });

        m_refreshTimer->start();
    }
}

void IntegrationPluginSenec::thingRemoved(Thing *thing)
{
    if (thing->thingClassId() == senecAccountThingClassId) {
        if (m_accounts.contains(thing))
            m_accounts.take(thing)->deleteLater();

        // Wipe any stored login information
        pluginStorage()->beginGroup(thing->id().toString());
        pluginStorage()->remove("");
        pluginStorage()->endGroup();
    }

    if (thing->thingClassId() == senecStorageLanThingClassId) {
        hardwareManager()->networkDeviceDiscovery()->unregisterMonitor(m_monitors.take(thing));
        m_storages.take(thing)->deleteLater();
    }

    if (myThings().isEmpty()) {
        qCDebug(dcSenec()) << "Stopping refresh timer";
        hardwareManager()->pluginTimerManager()->unregisterTimer(m_refreshTimer);
        m_refreshTimer = nullptr;
    }
}

void IntegrationPluginSenec::executeAction(ThingActionInfo *info)
{
    info->finish(Thing::ThingErrorNoError);
}

void IntegrationPluginSenec::refresh(Thing *thing)
{
    // If no thing given, refresh all storages recursive
    if (!thing) {
        foreach (Thing *storageThing, myThings().filterByThingClassId(senecStorageThingClassId)) {
            refresh(storageThing);
        }

        foreach (Thing *storageLanThing, myThings().filterByThingClassId(senecStorageLanThingClassId)) {
            m_storages.value(storageLanThing)->update();
        }

        return;
    }

    Thing *parentThing = myThings().findById(thing->parentId());
    SenecAccount *account = m_accounts.value(parentThing);
    QString id = thing->paramValue(senecStorageThingIdParamTypeId).toString();

    QNetworkReply *reply = account->getDashboard(id);
    connect(reply, &QNetworkReply::finished, reply, &QNetworkReply::deleteLater);
    connect(reply, &QNetworkReply::finished, account, [reply, thing, this] {

        // Check if we have a meter
        Thing *meterThing = nullptr;
        Things meterThings = myThings().filterByThingClassId(senecMeterThingClassId).filterByParentId(thing->id());
        if (!meterThings.isEmpty()) {
            meterThing = meterThings.first();
        }

        int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
        // Check HTTP status code
        if (status != 200 || reply->error() != QNetworkReply::NoError) {
            qCWarning(dcSenec()) << "Dashboard request finished with error. Status:" << status << "Error:" << reply->errorString();
            thing->setStateValue(senecStorageConnectedStateTypeId, false);
            if (meterThing) {
                meterThing->setStateValue(senecMeterConnectedStateTypeId, false);
            }
            return;
        }

        QByteArray responseData = reply->readAll();

        QJsonParseError jsonError;
        QJsonDocument jsonDoc = QJsonDocument::fromJson(responseData, &jsonError);
        QVariantMap responseMap = jsonDoc.toVariant().toMap();
        if (jsonError.error != QJsonParseError::NoError) {
            qCWarning(dcSenec()) << "Dashboard request finished successfully, but the response contains invalid JSON object:" << responseData;
            return;
        }

        qCDebug(dcSenec()) << "Dashboard request finished successfully" << qUtf8Printable(jsonDoc.toJson());
        thing->setStateValue(senecStorageConnectedStateTypeId, true);

        QVariantMap currentDataMap = responseMap.value("currently").toMap();
        float batteryCharge = qRound(currentDataMap.value("batteryChargeInW").toFloat() * 100) / 100.0;
        float batteryDischarge = qRound(currentDataMap.value("batteryDischargeInW").toFloat() * 100) / 100.0;
        int batteryLevel = currentDataMap.value("batteryLevelInPercent").toInt();

        // qCDebug(dcSenec()) << "charge:" << batteryCharge << "W" << "discharge:" << batteryDischarge << "W" << "level" << batteryLevel << "%";

        // Note: there are some situations where the battery is charging and discharging at the same time.
        // In that case we use the bigger power. Maybe we cloudl als sum them up, that should be tested...

        float currentPower = 0;
        if (batteryCharge != 0 && batteryDischarge != 0) {
            if (batteryCharge > batteryDischarge) {
                currentPower = batteryCharge;
            } else {
                currentPower = -batteryDischarge;
            }
        } else if (batteryCharge != 0) {
            currentPower = batteryCharge;
        } else if (batteryDischarge != 0) {
            currentPower = -batteryDischarge;
        }

        if (currentPower > 0) {
            thing->setStateValue(senecStorageChargingStateStateTypeId, "charging");
        } else if (currentPower < 0) {
            thing->setStateValue(senecStorageChargingStateStateTypeId, "discharging");
        } else {
            thing->setStateValue(senecStorageChargingStateStateTypeId, "idle");
        }

        thing->setStateValue(senecStorageCurrentPowerStateTypeId, currentPower);
        thing->setStateValue(senecStorageBatteryLevelStateTypeId, batteryLevel);
        thing->setStateValue(senecStorageBatteryCriticalStateTypeId, batteryLevel < 10);

        // Check if we have a meter
        if (meterThing) {
            float gridConsume = qRound(currentDataMap.value("gridDrawInW").toFloat() * 100) / 100.0;
            float gridReturn = qRound(currentDataMap.value("gridFeedInInW").toFloat() * 100) / 100.0;

            qCDebug(dcSenec()) << "Grid power: consume" << gridConsume << "W" << "return:" << gridReturn << "W";

            double currentPower = 0;

            if (gridConsume != 0) {
                currentPower = gridConsume;
            } else if (gridReturn != 0) {
                currentPower = -gridReturn;
            }

            meterThing->setStateValue(senecMeterCurrentPowerStateTypeId, currentPower);
            meterThing->setStateValue(senecMeterConnectedStateTypeId, true);
        }
    });
}