// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1

#include "core/context/contextaudioproxy.h"

#include <QDBusConnection>
#include <QLatin1String>
#include <QtGlobal>

#include "core/afv/clients/afvclient.h"
#include "misc/dbus.h"
#include "misc/dbusserver.h"
#include "misc/genericdbusinterface.h"

using namespace swift::misc;
using namespace swift::misc::audio;
using namespace swift::misc::network;
using namespace swift::misc::aviation;
using namespace swift::core::afv::clients;

namespace swift::core::context
{
    CContextAudioProxy::CContextAudioProxy(const QString &serviceName, QDBusConnection &connection,
                                           CCoreFacadeConfig::ContextMode mode, CCoreFacade *runtime)
        : CContextAudioBase(mode, runtime), m_dBusInterface(nullptr)
    {
        m_dBusInterface = new CGenericDBusInterface(serviceName, IContextAudio::ObjectPath(),
                                                    IContextAudio::InterfaceName(), connection, this);
        this->relaySignals(serviceName, connection);

        connect(this, &CContextAudioProxy::changedLocalAudioDevices, this, &CContextAudioProxy::onChangedLocalDevices,
                Qt::QueuedConnection);
    }

    void CContextAudioProxy::unitTestRelaySignals()
    {
        // connect signals, asserts when failures
        QDBusConnection con = QDBusConnection::sessionBus();
        CContextAudioProxy c(CDBusServer::coreServiceName(), con, CCoreFacadeConfig::Remote, nullptr);
        Q_UNUSED(c)
    }

    void CContextAudioProxy::registerDevices(const CAudioDeviceInfoList &devices)
    {
        if (devices.isEmpty()) { return; }
        m_dBusInterface->callDBus(QLatin1String("registerDevices"), devices);
    }

    void CContextAudioProxy::unRegisterDevices(const CAudioDeviceInfoList &devices)
    {
        if (devices.isEmpty()) { return; }
        m_dBusInterface->callDBus(QLatin1String("unRegisterDevices"), devices);
    }

    void CContextAudioProxy::unRegisterDevicesFor(const CIdentifier &identifier)
    {
        m_dBusInterface->callDBus(QLatin1String("unRegisterDevicesFor"), identifier);
    }

    void CContextAudioProxy::registerAudioCallsign(const CCallsign &callsign, const CIdentifier &identifier)
    {
        m_dBusInterface->callDBus(QLatin1String("registerAudioCallsign"), callsign, identifier);
    }

    void CContextAudioProxy::unRegisterAudioCallsign(const CCallsign &callsign, const CIdentifier &identifier)
    {
        m_dBusInterface->callDBus(QLatin1String("unRegisterAudioCallsign"), callsign, identifier);
    }

    bool CContextAudioProxy::hasRegisteredAudioCallsign(const CCallsign &callsign) const
    {
        return m_dBusInterface->callDBusRet<bool>(QLatin1String("hasRegisteredAudioCallsign"), callsign);
    }

    CAudioDeviceInfoList CContextAudioProxy::getRegisteredDevices() const
    {
        return m_dBusInterface->callDBusRet<swift::misc::audio::CAudioDeviceInfoList>(
            QLatin1String("getRegisteredDevices"));
    }

    void CContextAudioProxy::relaySignals(const QString &serviceName, QDBusConnection &connection)
    {
        bool s =
            connection.connect(serviceName, IContextAudio::ObjectPath(), IContextAudio::InterfaceName(),
                               "voiceClientFailure", this, SIGNAL(voiceClientFailure(swift::misc::CStatusMessage)));
        Q_ASSERT(s);

        this->relayBaseClassSignals(serviceName, connection, IContextAudio::ObjectPath(),
                                    IContextAudio::InterfaceName());
    }

} // namespace swift::core::context