// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

#include "devicedetector.h"

#include "../qdbconstants.h"
#include "../qdbdevice.h"
#include "../qdbtr.h"
#include "../qdbutils.h"

#include <projectexplorer/devicesupport/devicemanager.h>
#include <projectexplorer/devicesupport/sshparameters.h>
#include <projectexplorer/projectexplorerconstants.h>

#include <utils/qtcassert.h>

#include <QHash>
#include <QObject>

using namespace ProjectExplorer;
using namespace Utils;

namespace Qdb::Internal {

static bool isAutodetectedQdbDevice(const IDevice::ConstPtr &device)
{
    return device && device->type() == ProjectExplorer::Constants::BOOT2QT_DEVICE_TYPE
           && device->isAutoDetected();
}

DeviceDetector::DeviceDetector()
{
}

DeviceDetector::~DeviceDetector()
{
    stop();
}

void DeviceDetector::start()
{
    QTC_ASSERT(m_state == Inactive, return);

    connect(&m_deviceTracker, &QdbDeviceTracker::deviceEvent,
            this, &DeviceDetector::handleDeviceEvent);
    connect(&m_deviceTracker, &QdbDeviceTracker::trackerError,
            this, &DeviceDetector::handleTrackerError);

    resetDevices();
    m_state = WaitingForDeviceUpdates;
    m_deviceTracker.start();
    m_messageTracker.start();
}

void DeviceDetector::stop()
{
    m_messageTracker.stop();

    switch (m_state) {
    case WaitingForDeviceUpdates:
        m_deviceTracker.stop();
        resetDevices();
        break;
    case Inactive:
        break;
    }
    m_state = Inactive;
}

void DeviceDetector::handleDeviceEvent(QdbDeviceTracker::DeviceEventType eventType,
                                       const QMap<QString, QString> &info)
{
    const QString serial = info.value("serial");
    if (serial.isEmpty()) {
        showMessage("Error: Did not get a serial number in a device event from QDB", false);
        return;
    }

    const Utils::Id deviceId =
            Utils::Id(Constants::QdbHardwareDevicePrefix).withSuffix(':').withSuffix(serial);
    const QString messagePrefix = Tr::tr("Device \"%1\" %2").arg(serial);

    if (eventType == QdbDeviceTracker::NewDevice) {
        const QString name = Tr::tr("Boot to Qt device %1").arg(serial);
        QdbDevice::Ptr device = QdbDevice::create();
        device->setupId(IDevice::AutoDetected, deviceId);
        device->setDisplayName(name);

        const QString ipAddress = info["ipAddress"];
        device->setupDefaultNetworkSettings(ipAddress);

        if (const QdbDevice::Ptr existing = std::static_pointer_cast<QdbDevice>(
                DeviceManager::find(deviceId));
            existing && existing->sshParameters() == device->sshParameters()) {
            device = existing;
        } else {
            DeviceManager::addDevice(device);
        }

        if (ipAddress.isEmpty()) {
            device->setDeviceState(IDevice::DeviceDisconnected);
            showMessage(messagePrefix.arg("waiting for IP"), false);
        } else if (device->deviceState() != IDevice::DeviceReadyToUse) {
            device->tryToConnect(
                {this, [ipAddress, messagePrefix](const Result<> &res) {
                     if (res.has_value())
                         showMessage(
                             messagePrefix.arg("is ready to use at ").append(ipAddress), false);
                     else
                         showMessage(
                             messagePrefix.arg("failed to connect to ").append(ipAddress), true);
                 }});
        }
    } else if (eventType == QdbDeviceTracker::DisconnectedDevice) {
        if (QdbDevice::Ptr device = std::static_pointer_cast<QdbDevice>(
                DeviceManager::find(deviceId))) {
            device->closeConnection(true);
            showMessage(messagePrefix.arg("disconnected"), false);
        }
    }
}

void DeviceDetector::handleTrackerError(const QString &errorMessage)
{
    showMessage(Tr::tr("Device detection error: %1").arg(errorMessage), true);
    stop();
}

void DeviceDetector::resetDevices()
{
    for (int i = 0; i < DeviceManager::deviceCount(); ++i) {
        const IDevice::ConstPtr device = DeviceManager::deviceAt(i);
        if (isAutodetectedQdbDevice(device))
            DeviceManager::setDeviceState(device->id(), IDevice::DeviceDisconnected);
    }
}

} // Qdb::Internal
