/*
 * Copyright (C) 2017 Igalia S.L.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``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 APPLE COMPUTER, INC. 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.
 */

#include "config.h"
#include "RemoteInspectorServer.h"

#if ENABLE(REMOTE_INSPECTOR)

#include "RemoteInspectorUtils.h"
#include <gio/gio.h>
#include <wtf/Vector.h>
#include <wtf/glib/GUniquePtr.h>

#define INSPECTOR_DBUS_INTERFACE "org.webkit.Inspector"
#define INSPECTOR_DBUS_OBJECT_PATH "/org/webkit/Inspector"
#define REMOTE_INSPECTOR_DBUS_INTERFACE "org.webkit.RemoteInspector"
#define REMOTE_INSPECTOR_DBUS_OBJECT_PATH "/org/webkit/RemoteInspector"
#define REMOTE_INSPECTOR_CLIENT_DBUS_INTERFACE "org.webkit.RemoteInspectorClient"
#define REMOTE_INSPECTOR_CLIENT_OBJECT_PATH "/org/webkit/RemoteInspectorClient"

namespace Inspector {

static uint64_t generateConnectionID()
{
    static uint64_t connectionID = 0;
    return ++connectionID;
}

namespace RemoteInspectorServerInternal {
static const char introspectionXML[] =
    "<node>"
    "  <interface name='" INSPECTOR_DBUS_INTERFACE "'>"
    "    <method name='SetTargetList'>"
    "      <arg type='a(tsssb)' name='list' direction='in'/>"
    "      <arg type='b' name='remoteAutomationEnabled' direction='in'/>"
    "    </method>"
    "    <method name='SetupInspectorClient'>"
    "      <arg type='ay' name='backendCommandsHash' direction='in'/>"
    "      <arg type='ay' name='backendCommands' direction='out'/>"
    "    </method>"
    "    <method name='Setup'>"
    "      <arg type='t' name='connection' direction='in'/>"
    "      <arg type='t' name='target' direction='in'/>"
    "    </method>"
    "    <method name='FrontendDidClose'>"
    "      <arg type='t' name='connection' direction='in'/>"
    "      <arg type='t' name='target' direction='in'/>"
    "    </method>"
    "    <method name='SendMessageToFrontend'>"
    "      <arg type='t' name='target' direction='in'/>"
    "      <arg type='s' name='message' direction='in'/>"
    "    </method>"
    "    <method name='SendMessageToBackend'>"
    "      <arg type='t' name='connection' direction='in'/>"
    "      <arg type='t' name='target' direction='in'/>"
    "      <arg type='s' name='message' direction='in'/>"
    "    </method>"
    "    <method name='StartAutomationSession'>"
    "      <arg type='s' name='sessionID' direction='in'/>"
    "      <arg type='a{sv}' name='capabilities' direction='in'/>"
    "      <arg type='s' name='browserName' direction='out'/>"
    "      <arg type='s' name='browserVersion' direction='out'/>"
    "    </method>"
    "  </interface>"
    "</node>";
}

static RemoteInspector::Client::SessionCapabilities processSessionCapabilities(GVariant* sessionCapabilities)
{
    RemoteInspector::Client::SessionCapabilities capabilities;

    gboolean acceptInsecureCerts;
    if (g_variant_lookup(sessionCapabilities, "acceptInsecureCerts", "b", &acceptInsecureCerts))
        capabilities.acceptInsecureCertificates = acceptInsecureCerts;

    if (GRefPtr<GVariant> certificates = g_variant_lookup_value(sessionCapabilities, "certificates",  G_VARIANT_TYPE("a(ss)"))) {
        GVariantIter iter;
        auto childCount = g_variant_iter_init(&iter, certificates.get());
        capabilities.certificates.reserveCapacity(childCount);
        const char* host;
        const char* certificateFile;
        while (g_variant_iter_loop(&iter, "(&s&s)", &host, &certificateFile))
            capabilities.certificates.uncheckedAppend({ String::fromUTF8(host), String::fromUTF8(certificateFile) });
    }

    return capabilities;
}
const GDBusInterfaceVTable RemoteInspectorServer::s_interfaceVTable = {
    // method_call
    [] (GDBusConnection* connection, const gchar* /*sender*/, const gchar* /*objectPath*/, const gchar* /*interfaceName*/, const gchar* methodName, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer userData) {
        auto* inspectorServer = static_cast<RemoteInspectorServer*>(userData);
        if (!g_strcmp0(methodName, "SetTargetList")) {
            inspectorServer->setTargetList(connection, parameters);
            g_dbus_method_invocation_return_value(invocation, nullptr);
        } else if (!g_strcmp0(methodName, "SetupInspectorClient")) {
            GRefPtr<GVariant> backendCommandsHash;
            g_variant_get(parameters, "(@ay)", &backendCommandsHash.outPtr());
            auto* backendCommands = inspectorServer->setupInspectorClient(connection, g_variant_get_bytestring(backendCommandsHash.get()));
            g_dbus_method_invocation_return_value(invocation, g_variant_new("(@ay)", backendCommands));
        } else if (!g_strcmp0(methodName, "Setup")) {
            guint64 connectionID, targetID;
            g_variant_get(parameters, "(tt)", &connectionID, &targetID);
            inspectorServer->setup(connection, connectionID, targetID);
            g_dbus_method_invocation_return_value(invocation, nullptr);
        } else if (!g_strcmp0(methodName, "FrontendDidClose")) {
            guint64 connectionID, targetID;
            g_variant_get(parameters, "(tt)", &connectionID, &targetID);
            inspectorServer->close(connection, connectionID, targetID);
            g_dbus_method_invocation_return_value(invocation, nullptr);
        } else if (!g_strcmp0(methodName, "SendMessageToFrontend")) {
            guint64 targetID;
            const char* message;
            g_variant_get(parameters, "(t&s)", &targetID, &message);
            inspectorServer->sendMessageToFrontend(connection, targetID, message);
            g_dbus_method_invocation_return_value(invocation, nullptr);
        } else if (!g_strcmp0(methodName, "SendMessageToBackend")) {
            guint64 connectionID, targetID;
            const char* message;
            g_variant_get(parameters, "(tt&s)", &connectionID, &targetID, &message);
            inspectorServer->sendMessageToBackend(connection, connectionID, targetID, message);
            g_dbus_method_invocation_return_value(invocation, nullptr);
        } else if (!g_strcmp0(methodName, "StartAutomationSession")) {
            const char* sessionID;
            GRefPtr<GVariant> sessionCapabilities;
            g_variant_get(parameters, "(&s@a{sv})", &sessionID, &sessionCapabilities.outPtr());
            auto capabilities = processSessionCapabilities(sessionCapabilities.get());
            inspectorServer->startAutomationSession(connection, sessionID, capabilities);
            auto clientCapabilities = RemoteInspector::singleton().clientCapabilities();
            g_dbus_method_invocation_return_value(invocation, g_variant_new("(ss)",
                clientCapabilities ? clientCapabilities->browserName.utf8().data() : "",
                clientCapabilities ? clientCapabilities->browserVersion.utf8().data() : ""));
        } else
            g_dbus_method_invocation_return_value(invocation, nullptr);
    },
    // get_property
    nullptr,
    // set_property
    nullptr,
    // padding
    { 0 }
};

RemoteInspectorServer& RemoteInspectorServer::singleton()
{
    static RemoteInspectorServer server;
    return server;
}

RemoteInspectorServer::~RemoteInspectorServer()
{
    g_cancellable_cancel(m_cancellable.get());
    if (m_dbusServer)
        g_dbus_server_stop(m_dbusServer.get());
    if (m_introspectionData)
        g_dbus_node_info_unref(m_introspectionData);
}

GDBusInterfaceInfo* RemoteInspectorServer::interfaceInfo()
{
    if (!m_introspectionData) {
        m_introspectionData = g_dbus_node_info_new_for_xml(RemoteInspectorServerInternal::introspectionXML, nullptr);
        ASSERT(m_introspectionData);
    }
    return m_introspectionData->interfaces[0];
}

bool RemoteInspectorServer::start(const char* address, unsigned port)
{
    GUniquePtr<char> dbusAddress(g_strdup_printf("tcp:host=%s,port=%u", address, port));
    GUniquePtr<char> uid(g_dbus_generate_guid());

    m_cancellable = adoptGRef(g_cancellable_new());

    GUniqueOutPtr<GError> error;
    m_dbusServer = adoptGRef(g_dbus_server_new_sync(dbusAddress.get(), G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS, uid.get(), nullptr, m_cancellable.get(), &error.outPtr()));
    if (!m_dbusServer) {
        if (!g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED))
            g_warning("Failed to start remote inspector server on %s: %s\n", dbusAddress.get(), error->message);
        return false;
    }

    g_signal_connect(m_dbusServer.get(), "new-connection", G_CALLBACK(newConnectionCallback), this);
    g_dbus_server_start(m_dbusServer.get());

    return true;
}

gboolean RemoteInspectorServer::newConnectionCallback(GDBusServer*, GDBusConnection* connection, RemoteInspectorServer* inspectorServer)
{
    inspectorServer->newConnection(connection);
    return TRUE;
}

void RemoteInspectorServer::connectionClosedCallback(GDBusConnection* connection, gboolean /*remotePeerVanished*/, GError*, RemoteInspectorServer* server)
{
    server->connectionClosed(connection);
}

void RemoteInspectorServer::newConnection(GDBusConnection* connection)
{
    ASSERT(!m_connections.contains(connection));
    m_connections.add(connection);
    g_signal_connect(connection, "closed", G_CALLBACK(connectionClosedCallback), this);

    g_dbus_connection_register_object(connection, INSPECTOR_DBUS_OBJECT_PATH, interfaceInfo(), &s_interfaceVTable, this, nullptr, nullptr);
}

namespace RemoteInspectorServerInternal {
static void dbusConnectionCallAsyncReadyCallback(GObject* source, GAsyncResult* result, gpointer)
{
    GUniqueOutPtr<GError> error;
    GRefPtr<GVariant> resultVariant = adoptGRef(g_dbus_connection_call_finish(G_DBUS_CONNECTION(source), result, &error.outPtr()));
    if (!resultVariant && !g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED))
        WTFLogAlways("RemoteInspectorServer failed to send DBus message: %s", error->message);
}
}

void RemoteInspectorServer::setTargetList(GDBusConnection* remoteInspectorConnection, GVariant* parameters)
{
    ASSERT(m_connections.contains(remoteInspectorConnection));
    auto addResult = m_remoteInspectorConnectionToIDMap.add(remoteInspectorConnection, 0);
    if (addResult.isNewEntry) {
        addResult.iterator->value = generateConnectionID();
        m_idToRemoteInspectorConnectionMap.add(addResult.iterator->value, remoteInspectorConnection);
    }

    gboolean remoteAutomationEnabled;
    GRefPtr<GVariant> targetList;
    g_variant_get(parameters, "(@a(tsssb)b)", &targetList.outPtr(), &remoteAutomationEnabled);
    GDBusConnection* clientConnection = remoteAutomationEnabled && m_automationConnection ? m_automationConnection.get() : m_clientConnection.get();
    if (!clientConnection)
        return;

    g_dbus_connection_call(clientConnection, nullptr,
        REMOTE_INSPECTOR_CLIENT_OBJECT_PATH,
        REMOTE_INSPECTOR_CLIENT_DBUS_INTERFACE,
        "SetTargetList",
        g_variant_new("(t@a(tsssb))", m_remoteInspectorConnectionToIDMap.get(remoteInspectorConnection), targetList.get()),
        nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
        -1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
}

void RemoteInspectorServer::clientConnectionClosedCallback(GDBusConnection* connection, gboolean /*remotePeerVanished*/, GError*, RemoteInspectorServer* server)
{
    server->clientConnectionClosed(connection);
}

GVariant* RemoteInspectorServer::setupInspectorClient(GDBusConnection* clientConnection, const char* clientBackendCommandsHash)
{
    ASSERT(!m_clientConnection);
    m_clientConnection = clientConnection;
    g_signal_connect(m_clientConnection.get(), "closed", G_CALLBACK(clientConnectionClosedCallback), this);

    GVariant* backendCommands;
    if (strcmp(clientBackendCommandsHash, backendCommandsHash().data())) {
        auto bytes = Inspector::backendCommands();
        backendCommands = g_variant_new_bytestring(static_cast<const char*>(g_bytes_get_data(bytes.get(), nullptr)));
    } else
        backendCommands = g_variant_new_bytestring("");

    // Ask all remote inspectors to push their target lists to notify the new client.
    for (auto* remoteInspectorConnection : m_remoteInspectorConnectionToIDMap.keys()) {
        g_dbus_connection_call(remoteInspectorConnection, nullptr,
            REMOTE_INSPECTOR_DBUS_OBJECT_PATH,
            REMOTE_INSPECTOR_DBUS_INTERFACE,
            "GetTargetList",
            nullptr,
            nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
            -1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
    }

    return backendCommands;
}

void RemoteInspectorServer::setup(GDBusConnection* clientConnection, uint64_t connectionID, uint64_t targetID)
{
    ASSERT(m_clientConnection.get() == clientConnection || m_automationConnection.get() == clientConnection);
    ASSERT(m_idToRemoteInspectorConnectionMap.contains(connectionID));
    if (clientConnection == m_automationConnection.get()) {
        m_automationTargets.add(std::make_pair(connectionID, targetID));
        RemoteInspector::singleton().setup(targetID);
        return;
    }

    m_inspectionTargets.add(std::make_pair(connectionID, targetID));
    auto* remoteInspectorConnection = m_idToRemoteInspectorConnectionMap.get(connectionID);
    g_dbus_connection_call(remoteInspectorConnection, nullptr,
        REMOTE_INSPECTOR_DBUS_OBJECT_PATH,
        REMOTE_INSPECTOR_DBUS_INTERFACE,
        "Setup",
        g_variant_new("(t)", targetID),
        nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
        -1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
}

void RemoteInspectorServer::close(GDBusConnection* clientConnection, uint64_t connectionID, uint64_t targetID)
{
    ASSERT(m_clientConnection.get() == clientConnection || m_automationConnection.get() == clientConnection);
    ASSERT(m_idToRemoteInspectorConnectionMap.contains(connectionID));
    if (clientConnection == m_automationConnection.get()) {
        // FIXME: automation.
        return;
    }

    ASSERT(m_inspectionTargets.contains(std::make_pair(connectionID, targetID)));
    auto* remoteInspectorConnection = m_idToRemoteInspectorConnectionMap.get(connectionID);
    g_dbus_connection_call(remoteInspectorConnection, nullptr,
        REMOTE_INSPECTOR_DBUS_OBJECT_PATH,
        REMOTE_INSPECTOR_DBUS_INTERFACE,
        "FrontendDidClose",
        g_variant_new("(t)", targetID),
        nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
        -1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
    m_inspectionTargets.remove(std::make_pair(connectionID, targetID));
}

void RemoteInspectorServer::clientConnectionClosed(GDBusConnection* clientConnection)
{
    ASSERT(m_clientConnection.get() == clientConnection || m_automationConnection.get() == clientConnection);
    if (clientConnection == m_automationConnection.get()) {
        for (auto connectionTargetPair : m_automationTargets)
            close(clientConnection, connectionTargetPair.first, connectionTargetPair.second);
        m_automationConnection = nullptr;
        return;
    }

    for (auto connectionTargetPair : m_inspectionTargets)
        close(clientConnection, connectionTargetPair.first, connectionTargetPair.second);
    m_clientConnection = nullptr;
}

void RemoteInspectorServer::connectionClosed(GDBusConnection* remoteInspectorConnection)
{
    ASSERT(m_connections.contains(remoteInspectorConnection));
    if (m_remoteInspectorConnectionToIDMap.contains(remoteInspectorConnection)) {
        uint64_t connectionID = m_remoteInspectorConnectionToIDMap.take(remoteInspectorConnection);
        m_idToRemoteInspectorConnectionMap.remove(connectionID);
        // Send an empty target list to the clients.
        Vector<GRefPtr<GDBusConnection>> clientConnections = { m_automationConnection, m_clientConnection };
        for (auto& clientConnection : clientConnections) {
            if (!clientConnection)
                continue;
            g_dbus_connection_call(clientConnection.get(), nullptr,
                REMOTE_INSPECTOR_CLIENT_OBJECT_PATH,
                REMOTE_INSPECTOR_CLIENT_DBUS_INTERFACE,
                "SetTargetList",
                g_variant_new("(t@a(tsssb))", connectionID, g_variant_new_array(G_VARIANT_TYPE("(tsssb)"), nullptr, 0)),
                nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
                -1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
        }
    }
    m_connections.remove(remoteInspectorConnection);
}

void RemoteInspectorServer::sendMessageToBackend(GDBusConnection* clientConnection, uint64_t connectionID, uint64_t targetID, const char* message)
{
    ASSERT(m_clientConnection.get() == clientConnection || m_automationConnection.get() == clientConnection);
    ASSERT(m_idToRemoteInspectorConnectionMap.contains(connectionID));
    if (clientConnection == m_automationConnection.get()) {
        RemoteInspector::singleton().sendMessageToTarget(targetID, message);
        return;
    }

    auto* remoteInspectorConnection = m_idToRemoteInspectorConnectionMap.get(connectionID);
    g_dbus_connection_call(remoteInspectorConnection, nullptr,
        REMOTE_INSPECTOR_DBUS_OBJECT_PATH,
        REMOTE_INSPECTOR_DBUS_INTERFACE,
        "SendMessageToTarget",
        g_variant_new("(t&s)", targetID, message),
        nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
        -1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
}

void RemoteInspectorServer::sendMessageToFrontend(GDBusConnection* remoteInspectorConnection, uint64_t targetID, const char* message)
{
    ASSERT(m_connections.contains(remoteInspectorConnection));
    ASSERT(m_remoteInspectorConnectionToIDMap.contains(remoteInspectorConnection));

    uint64_t connectionID = m_remoteInspectorConnectionToIDMap.get(remoteInspectorConnection);
    auto connectionTargetPair = std::make_pair(connectionID, targetID);
    ASSERT(m_automationTargets.contains(connectionTargetPair) || m_inspectionTargets.contains(connectionTargetPair));
    GDBusConnection* clientConnection = m_inspectionTargets.contains(connectionTargetPair) ? m_clientConnection.get() : m_automationConnection.get();
    ASSERT(clientConnection);

    g_dbus_connection_call(clientConnection, nullptr,
        REMOTE_INSPECTOR_CLIENT_OBJECT_PATH,
        REMOTE_INSPECTOR_CLIENT_DBUS_INTERFACE,
        "SendMessageToFrontend",
        g_variant_new("(tt&s)", m_remoteInspectorConnectionToIDMap.get(remoteInspectorConnection), targetID, message),
        nullptr, G_DBUS_CALL_FLAGS_NO_AUTO_START,
        -1, m_cancellable.get(), RemoteInspectorServerInternal::dbusConnectionCallAsyncReadyCallback, nullptr);
}

void RemoteInspectorServer::startAutomationSession(GDBusConnection* automationConnection, const char* sessionID, const RemoteInspector::Client::SessionCapabilities& capabilities)
{
    if (!m_automationConnection)
        m_automationConnection = automationConnection;
    ASSERT(m_automationConnection.get() == automationConnection);

    RemoteInspector::singleton().requestAutomationSession(sessionID, capabilities);
}

} // namespace Inspector

#endif // ENABLE(REMOTE_INSPECTOR)