/*
 *
 *    Copyright (c) 2024 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

#include "BluezObjectManager.h"

#include <algorithm>
#include <memory>
#include <string>
#include <string_view>

#include <gio/gio.h>
#include <glib-object.h>
#include <glib.h>

#include <ble/Ble.h>
#include <lib/support/CodeUtils.h>
#include <lib/support/logging/CHIPLogging.h>
#include <platform/ConfigurationManager.h>
#include <platform/GLibTypeDeleter.h>
#include <platform/Linux/dbus/bluez/DbusBluez.h>
#include <platform/PlatformManager.h>

#include "Types.h"

namespace chip {
namespace DeviceLayer {
namespace Internal {

namespace {

const char * GetAdapterObjectPath(BluezAdapter1 * aAdapter)
{
    return g_dbus_proxy_get_object_path(reinterpret_cast<GDBusProxy *>(aAdapter));
}

} // namespace

CHIP_ERROR BluezObjectManager::Init()
{
    return PlatformMgrImpl().GLibMatterContextInvokeSync(
        +[](BluezObjectManager * self) {
            ReturnErrorOnFailure(self->SetupDBusConnection());
            ReturnErrorOnFailure(self->SetupObjectManager());
            return CHIP_NO_ERROR;
        },
        this);
}

void BluezObjectManager::Shutdown()
{
    // Run endpoint cleanup on the CHIPoBluez thread. This is necessary because the
    // cleanup function releases the D-Bus manager client object, which handles D-Bus
    // signals. Otherwise, we will face race condition when the D-Bus signal is in
    // the middle of being processed when the cleanup function is called.
    PlatformMgrImpl().GLibMatterContextInvokeSync(
        +[](BluezObjectManager * self) {
            self->mConnection.reset();
            self->mObjectManager.reset();
            return CHIP_NO_ERROR;
        },
        this);
}

BluezAdapter1 * BluezObjectManager::GetAdapter(unsigned int aAdapterId)
{
    char expectedPath[32];
    snprintf(expectedPath, sizeof(expectedPath), BLUEZ_PATH "/hci%u", aAdapterId);

    for (BluezObject & object : GetObjects())
    {
        GAutoPtr<BluezAdapter1> adapter(bluez_object_get_adapter1(&object));
        if (adapter && strcmp(g_dbus_proxy_get_object_path(reinterpret_cast<GDBusProxy *>(adapter.get())), expectedPath) == 0)
        {
            SetupAdapter(adapter.get());
            return adapter.release();
        }
    }

    return nullptr;
}

BluezAdapter1 * BluezObjectManager::GetAdapter(const char * aAdapterAddress)
{
    for (BluezObject & object : GetObjects())
    {
        GAutoPtr<BluezAdapter1> adapter(bluez_object_get_adapter1(&object));
        if (adapter && strcmp(bluez_adapter1_get_address(adapter.get()), aAdapterAddress) == 0)
        {
            SetupAdapter(adapter.get());
            return adapter.release();
        }
    }

    return nullptr;
}

CHIP_ERROR BluezObjectManager::SubscribeDeviceNotifications(BluezAdapter1 * aAdapter,
                                                            BluezObjectManagerAdapterNotificationsDelegate * aDelegate)
{
    std::lock_guard<std::mutex> lock(mSubscriptionsMutex);
    mSubscriptions.emplace_back(GetAdapterObjectPath(aAdapter), aDelegate);
    return CHIP_NO_ERROR;
}

CHIP_ERROR BluezObjectManager::UnsubscribeDeviceNotifications(BluezAdapter1 * aAdapter,
                                                              BluezObjectManagerAdapterNotificationsDelegate * aDelegate)
{
    std::lock_guard<std::mutex> lock(mSubscriptionsMutex);
    const auto item = std::make_pair(std::string(GetAdapterObjectPath(aAdapter)), aDelegate);
    mSubscriptions.erase(std::remove(mSubscriptions.begin(), mSubscriptions.end(), item), mSubscriptions.end());
    return CHIP_NO_ERROR;
}

CHIP_ERROR BluezObjectManager::SetupAdapter(BluezAdapter1 * aAdapter)
{
    // Make sure the adapter is powered on.
    bluez_adapter1_set_powered(aAdapter, TRUE);
    // Setting "Discoverable" to False on the adapter and to True on the advertisement convinces
    // BlueZ to set "BR/EDR Not Supported" flag. BlueZ doesn't provide API to do that explicitly
    // and the flag is necessary to force using LE transport.
    bluez_adapter1_set_discoverable(aAdapter, FALSE);
    return CHIP_NO_ERROR;
}

void BluezObjectManager::NotifyAdapterAdded(BluezAdapter1 * aAdapter)
{
    unsigned int adapterId = 0;
    sscanf(GetAdapterObjectPath(aAdapter), BLUEZ_PATH "/hci%u", &adapterId);
    // Notify the application that new adapter has been just added
    BLEManagerImpl::NotifyBLEAdapterAdded(adapterId, bluez_adapter1_get_address(aAdapter));
}

void BluezObjectManager::NotifyAdapterRemoved(BluezAdapter1 * aAdapter)
{
    unsigned int adapterId = 0;
    sscanf(GetAdapterObjectPath(aAdapter), BLUEZ_PATH "/hci%u", &adapterId);
    // Notify the application that the adapter is no longer available
    BLEManagerImpl::NotifyBLEAdapterRemoved(adapterId, bluez_adapter1_get_address(aAdapter));
}

void BluezObjectManager::RemoveAdapterSubscriptions(BluezAdapter1 * aAdapter)
{
    std::lock_guard<std::mutex> lock(mSubscriptionsMutex);
    const auto adapterPath = GetAdapterObjectPath(aAdapter);
    // Remove all device notification subscriptions for the given adapter
    mSubscriptions.erase(std::remove_if(mSubscriptions.begin(), mSubscriptions.end(),
                                        [adapterPath](const auto & subscription) { return subscription.first == adapterPath; }),
                         mSubscriptions.end());
}

CHIP_ERROR BluezObjectManager::SetupDBusConnection()
{
    GAutoPtr<GError> err;
    mConnection.reset(g_bus_get_sync(G_BUS_TYPE_SYSTEM, nullptr, &err.GetReceiver()));
    VerifyOrReturnError(mConnection != nullptr, CHIP_ERROR_INTERNAL,
                        ChipLogError(DeviceLayer, "FAIL: Get D-Bus system bus: %s", err->message));
    return CHIP_NO_ERROR;
}

BluezObjectManager::NotificationsDelegates BluezObjectManager::GetDeviceNotificationsDelegates(BluezDevice1 * device)
{
    const char * deviceAdapterPath = bluez_device1_get_adapter(device);
    NotificationsDelegates delegates;

    std::lock_guard<std::mutex> lock(mSubscriptionsMutex);
    for (auto & [adapterPath, delegate] : mSubscriptions)
    {
        if (adapterPath == deviceAdapterPath)
        {
            delegates.push_back(delegate);
        }
    }

    return delegates;
}

void BluezObjectManager::OnObjectAdded(GDBusObjectManager * aMgr, BluezObject * aObj)
{
    GAutoPtr<BluezAdapter1> adapter(bluez_object_get_adapter1(aObj));
    // Verify that the adapter is properly initialized - the class property must be set.
    // BlueZ can export adapter objects on the bus before it is fully initialized. Such
    // adapter objects are not usable and must be ignored.
    //
    // TODO: Find a better way to determine whether the adapter interface exposed by
    //       BlueZ D-Bus service is fully functional. The current approach is based on
    //       the assumption that the class property is non-zero, which is true only
    //       for BR/EDR + LE adapters. LE-only adapters do not have HCI command to read
    //       the class property and BlueZ sets it to 0 as a default value.
    if (adapter && bluez_adapter1_get_class(adapter.get()) != 0)
    {
        NotifyAdapterAdded(adapter.get());
        return;
    }

    GAutoPtr<BluezDevice1> device(bluez_object_get_device1(aObj));
    if (device)
    {
        for (auto delegate : GetDeviceNotificationsDelegates(device.get()))
        {
            delegate->OnDeviceAdded(*device.get());
        }
    }
}

void BluezObjectManager::OnObjectRemoved(GDBusObjectManager * aMgr, BluezObject * aObj)
{
    GAutoPtr<BluezAdapter1> adapter(bluez_object_get_adapter1(aObj));
    if (adapter)
    {
        RemoveAdapterSubscriptions(adapter.get());
        NotifyAdapterRemoved(adapter.get());
        return;
    }

    GAutoPtr<BluezDevice1> device(bluez_object_get_device1(aObj));
    if (device)
    {
        for (auto delegate : GetDeviceNotificationsDelegates(device.get()))
        {
            delegate->OnDeviceRemoved(*device.get());
        }
    }
}

void BluezObjectManager::OnInterfacePropertiesChanged(GDBusObjectManagerClient * aMgr, BluezObject * aObj, GDBusProxy * aIface,
                                                      GVariant * aChangedProps, const char * const * aInvalidatedProps)
{
    uint32_t classValue = 0;
    GAutoPtr<BluezAdapter1> adapter(bluez_object_get_adapter1(aObj));
    // When the adapter's readonly class property is set, it means that the adapter has been
    // fully initialized and is ready to be used. It's most likely that the adapter has been
    // previously ignored in the OnObjectAdded callback, so now we can notify the application
    // about the new adapter.
    if (adapter && g_variant_lookup(aChangedProps, "Class", "u", &classValue) && classValue != 0)
    {
        NotifyAdapterAdded(adapter.get());
        return;
    }

    GAutoPtr<BluezDevice1> device(bluez_object_get_device1(aObj));
    if (device)
    {
        for (auto delegate : GetDeviceNotificationsDelegates(device.get()))
        {
            delegate->OnDevicePropertyChanged(*device.get(), aChangedProps, aInvalidatedProps);
        }
    }
}

CHIP_ERROR BluezObjectManager::SetupObjectManager()
{
    // When connecting to signals, the thread default context must be initialized. Otherwise,
    // all D-Bus signals will be delivered to the GLib global default main context.
    VerifyOrDie(g_main_context_get_thread_default() != nullptr);

    GAutoPtr<GError> err;
    mObjectManager.reset(g_dbus_object_manager_client_new_sync(
        mConnection.get(), G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE, BLUEZ_INTERFACE, "/",
        bluez_object_manager_client_get_proxy_type, nullptr /* unused user data in the proxy type func */,
        nullptr /* destroy notify */, nullptr /* cancellable */, &err.GetReceiver()));
    VerifyOrReturnError(mObjectManager, CHIP_ERROR_INTERNAL,
                        ChipLogError(DeviceLayer, "FAIL: Get D-Bus object manager client: %s", err->message));

    g_signal_connect(mObjectManager.get(), "object-added",
                     G_CALLBACK(+[](GDBusObjectManager * mgr, GDBusObject * obj, BluezObjectManager * self) {
                         return self->OnObjectAdded(mgr, reinterpret_cast<BluezObject *>(obj));
                     }),
                     this);
    g_signal_connect(mObjectManager.get(), "object-removed",
                     G_CALLBACK(+[](GDBusObjectManager * mgr, GDBusObject * obj, BluezObjectManager * self) {
                         return self->OnObjectRemoved(mgr, reinterpret_cast<BluezObject *>(obj));
                     }),
                     this);
    g_signal_connect(mObjectManager.get(), "interface-proxy-properties-changed",
                     G_CALLBACK(+[](GDBusObjectManagerClient * mgr, GDBusObjectProxy * obj, GDBusProxy * iface, GVariant * changed,
                                    const char * const * invalidated, BluezObjectManager * self) {
                         return self->OnInterfacePropertiesChanged(mgr, reinterpret_cast<BluezObject *>(obj), iface, changed,
                                                                   invalidated);
                     }),
                     this);

    return CHIP_NO_ERROR;
}

CHIP_ERROR BluezCallToChipError(const GError * aError)
{
    switch (aError->code)
    {
    // BlueZ crashed or the D-Bus connection is broken in both cases adapter is not available.
    case G_DBUS_ERROR_NO_REPLY:
    // BlueZ service is not available on the bus, hence the adapter is not available too.
    case G_DBUS_ERROR_SERVICE_UNKNOWN:
    // Requested D-Bus object is not available on the given path. This happens when the adapter
    // was unplugged and unregistered from the BlueZ object manager.
    case G_DBUS_ERROR_UNKNOWN_OBJECT:
        return BLE_ERROR_ADAPTER_UNAVAILABLE;
    default:
        return CHIP_ERROR_INTERNAL;
    }
}

} // namespace Internal
} // namespace DeviceLayer
} // namespace chip