// Copyright 2021 Google LLC
//
// 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 "analyzer.hpp"

#include "histogram.hpp"
#include "main.hpp"
#include "sensorhelper.hpp"
#include "views.hpp"
#include "xmlparse.hpp"

#include <unistd.h>

#include <atomic>
#include <cassert>
#include <filesystem>
#include <fstream>
#include <functional>
#include <iostream>
#include <sstream>
#include <string>

int AcquireBus(sd_bus** ret);

extern SensorSnapshot* g_sensor_snapshot;
extern DBusConnectionSnapshot* g_connection_snapshot;
extern sd_bus* g_bus;
extern SensorDetailView* g_sensor_detail_view;
extern FooterView* g_footer_view;

static std::unordered_map<uint64_t, uint64_t>
    in_flight_methodcalls; // serial => microseconds
uint64_t Microseconds()
{
    long us;  // usec
    time_t s; // Seconds
    struct timespec spec;
    clock_gettime(CLOCK_REALTIME, &spec);
    s = spec.tv_sec;
    us = round(spec.tv_nsec / 1000); // Convert nanoseconds to milliseconds
    if (us > 999999)
    {
        s++;
        us = 0;
    }
    return s * 1000000 + us;
}

int g_update_interval_millises = 2000;
int GetSummaryIntervalInMillises()
{
    return g_update_interval_millises;
}

bool DBusTopSortFieldIsNumeric(DBusTopSortField field)
{
    switch (field)
    {
        case kSender:
        case kDestination:
        case kInterface:
        case kPath:
        case kMember:
        case kSenderCMD:
            return false;
        case kSenderPID:
        case kMsgPerSec:
        case kAverageLatency:
            return true;
    }
    return false;
}

namespace dbus_top_analyzer
{
DBusTopStatistics g_dbus_statistics;
Histogram<float> g_mc_time_histogram;
std::unordered_map<uint32_t, uint64_t> in_flight_methodcalls;
std::atomic<bool> g_program_done = false;
std::chrono::time_point<std::chrono::steady_clock> g_last_update;
DBusTopStatisticsCallback g_callback;
void SetDBusTopStatisticsCallback(DBusTopStatisticsCallback cb)
{
    g_callback = cb;
}

int UserInputThread()
{
    return 0;
}

std::string g_dbus_top_conn = " ";
void SetDBusTopConnectionForMonitoring(const std::string& conn)
{
    g_dbus_top_conn = conn;
}

// Performs one step of analysis
void Process()
{
    std::chrono::time_point<std::chrono::steady_clock> t =
        std::chrono::steady_clock::now();
    std::chrono::time_point<std::chrono::steady_clock> next_update =
        g_last_update + std::chrono::milliseconds(g_update_interval_millises);
    if (t >= next_update)
    {
        float seconds_since_last_sample =
            std::chrono::duration_cast<std::chrono::microseconds>(t -
                                                                  g_last_update)
                .count() /
            1000000.0f;
        g_dbus_statistics.seconds_since_last_sample_ =
            seconds_since_last_sample;
        // Update snapshot
        if (g_callback)
        {
            g_callback(&g_dbus_statistics, &g_mc_time_histogram);
        }
        g_dbus_statistics.Reset();
        g_last_update = t;
    }
}

void Finish()
{
    g_program_done = true;
}

std::vector<std::string> FindAllObjectPathsForService(
    sd_bus* bus, const std::string& service,
    std::function<void(const std::string&, const std::vector<std::string>&)>
        on_interface_cb)
{
    sd_bus_error err = SD_BUS_ERROR_NULL;
    sd_bus_message *m, *reply;
    std::vector<std::string> paths; // Current iteration
    std::vector<std::string>
        all_obj_paths; // All object paths under the supervision of ObjectMapper
    paths.push_back("/");
    // busctl call xyz.openbmc_project.ObjectMapper        /
    // org.freedesktop.DBus.Introspectable        Introspect
    while (!paths.empty())
    {
        // printf("%d paths to explore, total %d paths so far\n",
        // int(paths.size()), int(all_obj_paths.size()));
        std::vector<std::string> new_paths;
        for (const std::string& obj_path : paths)
        {
            all_obj_paths.push_back(obj_path);
            int r = sd_bus_message_new_method_call(
                bus, &m, service.c_str(), obj_path.c_str(),
                "org.freedesktop.DBus.Introspectable", "Introspect");
            if (r < 0)
            {
                continue;
            }
            r = sd_bus_call(bus, m, 0, &err, &reply);
            if (r < 0)
            {
                continue;
            }
            const char* sig = sd_bus_message_get_signature(reply, 0);
            if (!strcmp(sig, "s"))
            {
                const char* s;
                int r = sd_bus_message_read(reply, "s", &s);
                if (r < 0)
                {
                    continue;
                }
                else
                {
                    XMLNode* t = ParseXML(std::string(s));
                    std::vector<std::string> ch = t->GetChildNodeNames();
                    if (on_interface_cb != nullptr)
                    {
                        on_interface_cb(obj_path, t->GetInterfaceNames());
                    }
                    DeleteTree(t);
                    for (const std::string& cn : ch)
                    {
                        std::string ch_path = obj_path;
                        if (obj_path.back() == '/')
                        {}
                        else
                            ch_path.push_back('/');
                        ch_path += cn;
                        new_paths.push_back(ch_path);
                    }
                }
            }
        }
        paths = new_paths;
    }
    return all_obj_paths;
}

void ListAllSensors(sd_bus* bus, DBusConnectionSnapshot** cxn_snapshot,
                    SensorSnapshot** sensor_snapshot)
{
    // Craete new snapshots
    (*cxn_snapshot) = new DBusConnectionSnapshot();
    (*sensor_snapshot) = new SensorSnapshot(*cxn_snapshot);

    g_footer_view->SetStatusString("1. Listing DBus Names");
    DBusTopUpdateFooterView();
    char** names;
    int r = sd_bus_list_names(bus, &names, nullptr);
    std::vector<std::string> services;
    std::vector<int> pids;
    std::vector<std::string> comms;
    for (char** ptr = names; ptr && *ptr; ++ptr)
    {
        services.push_back(*ptr);
        free(*ptr);
    }
    free(names);

    g_footer_view->SetStatusString("2. Getting Creds");
    DBusTopUpdateFooterView();
    size_t N = services.size();
    for (size_t i = 0; i < N; i++)
    {
        if (i == N - 1 || (i % 100) == 99)
        {
            g_footer_view->SetStatusString("2. Getting Creds " +
                                           std::to_string(i + 1) + "/" +
                                           std::to_string(N));
            DBusTopUpdateFooterView();
        }
        const std::string& service = services[i];
        sd_bus_creds* creds = nullptr;
        r = sd_bus_get_name_creds(bus, services[i].c_str(),
                                  SD_BUS_CREDS_AUGMENT | SD_BUS_CREDS_EUID |
                                      SD_BUS_CREDS_PID | SD_BUS_CREDS_COMM |
                                      SD_BUS_CREDS_UNIQUE_NAME |
                                      SD_BUS_CREDS_UNIT | SD_BUS_CREDS_SESSION |
                                      SD_BUS_CREDS_DESCRIPTION,
                                  &creds);
        // PID
        int pid = INVALID;
        if (r < 0)
        {}
        else
        {
            r = sd_bus_creds_get_pid(creds, &pid);
        }
        pids.push_back(pid);
        // comm
        std::string comm;
        if (pid != INVALID)
        {
            std::ifstream ifs("/proc/" + std::to_string(pid) + "/cmdline");
            std::string line;
            std::getline(ifs, line);
            for (char c : line)
            {
                if (c < 32 || c >= 127)
                    c = ' ';
                comm.push_back(c);
            }
        }
        comms.push_back(comm);
        // unique name, also known as "Connection"
        std::string connection;
        const char* u;
        r = sd_bus_creds_get_unique_name(creds, &u);
        if (r >= 0)
        {
            connection = u;
        }
        std::string unit;
        r = sd_bus_creds_get_unit(creds, &u);
        if (r >= 0)
        {
            unit = u;
        }
        (*cxn_snapshot)->AddConnection(service, connection, comm, unit, pid);
    }
    // busctl call xyz.openbmc_project.ObjectMapper /
    // org.freedesktop.DBus.Introspectable Introspect

    g_footer_view->SetStatusString("3. Examine objects in ObjectMapper");
    std::vector<std::string> all_obj_paths = FindAllObjectPathsForService(
        bus, "xyz.openbmc_project.ObjectMapper", nullptr);
    N = all_obj_paths.size();
    sd_bus_error err = SD_BUS_ERROR_NULL;
    sd_bus_message *m, *reply;
    for (size_t i = 0; i < N; i++)
    {
        if (i % 100 == 99 || i == N - 1)
        {
            g_footer_view->SetStatusString(
                "3. Examine objects in ObjectMapper " + std::to_string(i + 1) +
                "/" + std::to_string(N));
            DBusTopUpdateFooterView();
        }

        const std::string& p = all_obj_paths[i];
        if (IsSensorObjectPath(p))
        {
            err = SD_BUS_ERROR_NULL;
            r = sd_bus_message_new_method_call(
                bus, &m, "xyz.openbmc_project.ObjectMapper",
                "/xyz/openbmc_project/object_mapper",
                "xyz.openbmc_project.ObjectMapper", "GetObject");
            if (r < 0)
            {
                continue;
            }
            r = sd_bus_message_append_basic(m, 's', p.c_str());
            if (r < 0)
            {
                continue;
            }
            // empty array
            r = sd_bus_message_open_container(m, 'a', "s");
            if (r < 0)
            {
                continue;
            }
            r = sd_bus_message_close_container(m);
            if (r < 0)
            {
                continue;
            }
            r = sd_bus_call(bus, m, 0, &err, &reply);
            if (r < 0)
            {}
            const char* sig = sd_bus_message_get_signature(reply, 0);
            if (!strcmp(sig, "a{sas}"))
            {
                r = sd_bus_message_enter_container(reply, 'a', "{sas}");
                if (r < 0)
                {
                    continue;
                }
                while (true)
                {
                    r = sd_bus_message_enter_container(
                        reply, SD_BUS_TYPE_DICT_ENTRY, "sas");
                    if (r < 0)
                    {
                        goto DONE;
                    }
                    else if (r == 0)
                    {}
                    else
                    {
                        // The following 2 correspond to `interface_map` in
                        // phosphor-mapper
                        const char* interface_map_first;
                        r = sd_bus_message_read_basic(reply, 's',
                                                      &interface_map_first);
                        if (r < 0)
                        {
                            goto DONE;
                        }
                        r = sd_bus_message_enter_container(reply, 'a', "s");
                        if (r < 0)
                        {
                            goto DONE;
                        }
                        bool has_value_interface = false;
                        while (true)
                        {
                            const char* interface_map_second;
                            r = sd_bus_message_read_basic(
                                reply, 's', &interface_map_second);
                            if (r < 0)
                            {}
                            else if (r == 0)
                                break;
                            else
                            {
                                if (!strcmp(interface_map_second,
                                            "xyz.openbmc_project.Sensor.Value"))
                                {
                                    has_value_interface = true;
                                }
                            }
                        }
                        if (has_value_interface)
                        {
                            (*sensor_snapshot)
                                ->SetSensorVisibleFromObjectMapper(
                                    std::string(interface_map_first), p);
                        }
                        r = sd_bus_message_exit_container(reply);
                    }
                    r = sd_bus_message_exit_container(reply);
                }
                r = sd_bus_message_exit_container(reply);
            }
        DONE:
        {}
        }
    }

    g_footer_view->SetStatusString("4. List Associations in ObjectMapper");
    DBusTopUpdateFooterView();
    err = SD_BUS_ERROR_NULL;
    r = sd_bus_message_new_method_call(
        bus, &m, "xyz.openbmc_project.ObjectMapper",
        "/xyz/openbmc_project/object_mapper",
        "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths");
    if (r < 0)
    {
        assert(0);
    }
    r = sd_bus_message_append_basic(m, 's', "/");
    if (r < 0)
    {
        assert(0);
    }
    const int zero = 0;
    r = sd_bus_message_append_basic(m, 'i', &zero);
    if (r < 0)
    {
        assert(0);
    }
    r = sd_bus_message_open_container(m, 'a', "s");
    if (r < 0)
    {
        assert(0);
    }
    r = sd_bus_message_append_basic(m, 's', "xyz.openbmc_project.Association");
    if (r < 0)
    {
        assert(0);
    }
    r = sd_bus_message_close_container(m);
    if (r < 0)
    {
        assert(0);
    }
    r = sd_bus_call(bus, m, 0, &err, &reply);
    if (r < 0)
    {
        assert(0);
    }
    const char* sig = sd_bus_message_get_signature(reply, 0);
    if (strcmp(sig, "as"))
    {
        assert(0);
    }
    r = sd_bus_message_enter_container(reply, 'a', "s");
    if (r < 0)
    {
        assert(0);
    }
    std::set<std::string> assoc_paths;
    while (true)
    {
        const char* p;
        r = sd_bus_message_read_basic(reply, 's', &p);
        if (r <= 0)
            break;
        else
        {
            assoc_paths.insert(p);
        }
    }
    r = sd_bus_message_exit_container(reply);
    if (r < 0)
    {
        assert(0);
    }

    size_t idx = 0;
    for (const std::string& assoc_path : assoc_paths)
    {
        if (idx % 100 == 99 || idx == N - 1)
        {
            g_footer_view->SetStatusString(
                "4. List Associations in ObjectMapper " +
                std::to_string(idx + 1) + "/" + std::to_string(N));
            DBusTopUpdateFooterView();
        }
        ++idx;
        err = SD_BUS_ERROR_NULL;
        r = sd_bus_message_new_method_call(
            bus, &m, "xyz.openbmc_project.ObjectMapper", assoc_path.c_str(),
            "org.freedesktop.DBus.Properties", "Get");
        r = sd_bus_message_append_basic(m, 's',
                                        "xyz.openbmc_project.Association");
        if (r < 0)
        {
            assert(0);
        }
        r = sd_bus_message_append_basic(m, 's', "endpoints");
        if (r < 0)
        {
            assert(0);
        }
        r = sd_bus_call(bus, m, 0, &err, &reply);
        if (r < 0)
        {
            // The object may not have any endpoints
            continue;
        }
        const char* sig = sd_bus_message_get_signature(reply, 0);
        if (strcmp(sig, "v"))
        {
            assert(0);
        }
        r = sd_bus_message_enter_container(reply, 'v', "as");
        if (r < 0)
        {
            assert(0);
        }
        r = sd_bus_message_enter_container(reply, 'a', "s");
        if (r < 0)
        {
            assert(0);
        }
        std::set<std::string> entries;
        while (true)
        {
            const char* p;
            r = sd_bus_message_read_basic(reply, 's', &p);
            if (r <= 0)
                break;
            entries.insert(p);
        }
        r = sd_bus_message_exit_container(reply);
        if (r < 0)
        {
            assert(0);
        }
        r = sd_bus_message_exit_container(reply);
        if (r < 0)
        {
            assert(0);
        }

        (*sensor_snapshot)->AddAssociationEndpoints(assoc_path, entries);
    }

    g_footer_view->SetStatusString("5. Find Association Definitions");
    DBusTopUpdateFooterView();

    err = SD_BUS_ERROR_NULL;
    r = sd_bus_message_new_method_call(
        bus, &m, "xyz.openbmc_project.ObjectMapper",
        "/xyz/openbmc_project/object_mapper",
        "xyz.openbmc_project.ObjectMapper", "GetSubTree");
    std::vector<std::pair<std::string, std::string>>
        services_and_objects; // Record the Associations from those pairs
    r = sd_bus_message_append_basic(m, 's', "/");
    if (r < 0)
    {
        assert(0);
    }
    r = sd_bus_message_append_basic(m, 'i', &zero);
    if (r < 0)
    {
        assert(0);
    }
    r = sd_bus_message_open_container(m, 'a', "s");
    if (r < 0)
    {
        assert(0);
    }
    r = sd_bus_message_append_basic(
        m, 's', "xyz.openbmc_project.Association.Definitions");
    if (r < 0)
    {
        assert(0);
    }
    r = sd_bus_message_close_container(m);
    if (r < 0)
    {
        assert(0);
    }
    r = sd_bus_call(bus, m, 0, &err, &reply);
    if (r < 0)
    {
        assert(0);
    }
    sig = sd_bus_message_get_signature(reply, 0);
    if (strcmp(sig, "a{sa{sas}}"))
    {
        assert(0);
    }
    r = sd_bus_message_enter_container(reply, 'a', "{sa{sas}}");
    if (r <= 0)
    {
        assert(0);
    }

    idx = 0;
    N = services_and_objects.size();
    while (true)
    {
        if (idx % 100 == 99 || idx == N - 1)
        {
            g_footer_view->SetStatusString("5. Find Association Definitions " +
                                           std::to_string(idx + 1) + "/" +
                                           std::to_string(N));
            DBusTopUpdateFooterView();
        }
        r = sd_bus_message_enter_container(reply, 'e', "sa{sas}");
        if (r <= 0)
        {
            break;
        }              // e denotes 'dict entry'
        const char* p; // path
        r = sd_bus_message_read_basic(reply, 's', &p);
        if (r <= 0)
            break;
        r = sd_bus_message_enter_container(reply, 'a', "{sas}");
        if (r <= 0)
        {
            assert(0);
        }
        while (true)
        {
            const char* service; // service
            r = sd_bus_message_enter_container(reply, 'e', "sas");
            if (r <= 0)
            {
                break;
            }
            r = sd_bus_message_read_basic(reply, 's', &service);
            if (r < 0)
            {
                assert(0);
            }
            services_and_objects.emplace_back(std::string(service),
                                              std::string(p));
            r = sd_bus_message_enter_container(reply, 'a', "s");
            if (r <= 0)
            {
                assert(0);
            }
            while (true)
            {
                const char* iface;
                r = sd_bus_message_read_basic(reply, 's', &iface);
                if (r <= 0)
                {
                    break;
                }
            }
            r = sd_bus_message_exit_container(reply);
            if (r < 0)
            {
                assert(0);
            } // exit a
            r = sd_bus_message_exit_container(reply);
            if (r < 0)
            {
                assert(0);
            } // exit e
        }
        r = sd_bus_message_exit_container(reply);
        if (r < 0)
        {
            assert(0);
        } // exit a
        r = sd_bus_message_exit_container(reply);
        if (r < 0)
        {
            assert(0);
        } // exit e
    }
    r = sd_bus_message_exit_container(reply);
    if (r < 0)
    {
        assert(0);
    } // exit a

    idx = 0;
    N = services_and_objects.size();
    for (const std::pair<std::string, std::string>& serv_and_obj :
         services_and_objects)
    {
        if (idx % 100 == 99 || idx == N - 1)
        {
            g_footer_view->SetStatusString(
                "6. Find Associations of Endpoints " + std::to_string(idx + 1) +
                "/" + std::to_string(N));
            DBusTopUpdateFooterView();
        }
        ++idx;
        err = SD_BUS_ERROR_NULL;
        r = sd_bus_message_new_method_call(
            bus, &m, serv_and_obj.first.c_str(), serv_and_obj.second.c_str(),
            "org.freedesktop.DBus.Properties", "Get");
        if (r < 0)
        {
            assert(0);
        }
        r = sd_bus_message_append_basic(
            m, 's', "xyz.openbmc_project.Association.Definitions");
        if (r < 0)
        {
            assert(0);
        }
        r = sd_bus_message_append_basic(m, 's', "Associations");
        if (r < 0)
        {
            assert(0);
        }
        r = sd_bus_call(bus, m, 0, &err, &reply);
        if (r <= 0)
        {
            continue;
        }
        sig = sd_bus_message_get_signature(reply, 0);
        if (strcmp(sig, "v"))
        {
            assert(0);
        }
        r = sd_bus_message_enter_container(reply, 'v', "a(sss)");
        if (r <= 0)
        {
            continue;
        }
        r = sd_bus_message_enter_container(reply, 'a', "(sss)");
        if (r <= 0)
        {
            continue;
        }
        while (true)
        {
            r = sd_bus_message_enter_container(reply, 'r', "sss");
            if (r <= 0)
            {
                break;
            } // struct
            const char *forward, *reverse, *endpoint;
            r = sd_bus_message_read_basic(reply, 's', &forward);
            if (r < 0)
            {
                break;
            }
            r = sd_bus_message_read_basic(reply, 's', &reverse);
            if (r < 0)
            {
                assert(0);
            }
            r = sd_bus_message_read_basic(reply, 's', &endpoint);
            if (r < 0)
            {
                assert(0);
            }
            (*sensor_snapshot)
                ->AddAssociationDefinition(
                    serv_and_obj.second, std::string(forward),
                    std::string(reverse), std::string(endpoint));
            r = sd_bus_message_exit_container(reply);
            if (r < 0)
            {
                assert(0);
            } // exit struct
        }
        r = sd_bus_message_exit_container(reply);
        if (r < 0)
        {
            assert(0);
        } // exit a
        r = sd_bus_message_exit_container(reply);
        if (r < 0)
        {
            assert(0);
        } // exit v
    }

    g_footer_view->SetStatusString("7. Check HWMon DBus objects");
    DBusTopUpdateFooterView();
    for (size_t i = 0; i < comms.size(); i++)
    {
        if (i % 100 == 99 || i == N - 1)
        {
            g_footer_view->SetStatusString("7. Check HWMon DBus objects " +
                                           std::to_string(i + 1) + "/" +
                                           std::to_string(N));
            DBusTopUpdateFooterView();
        }
        const std::string& comm = comms[i];
        const std::string& service = services[i];
        if (comm.find("phosphor-hwmon-readd") != std::string::npos &&
            !IsUniqueName(service))
        {
            // printf("Should introspect %s\n", service.c_str());
            std::vector<std::string> objpaths =
                FindAllObjectPathsForService(bus, service, nullptr);
            for (const std::string& op : objpaths)
            {
                if (IsSensorObjectPath(op))
                {
                    (*sensor_snapshot)->SetSensorVisibleFromHwmon(service, op);
                }
            }
        }
    }

    g_footer_view->SetStatusString("DBus object scan complete");
    DBusTopUpdateFooterView();
}
} // namespace dbus_top_analyzer

void DBusTopStatistics::OnNewDBusMessage(const char* sender,
                                         const char* destination,
                                         const char* interface,
                                         const char* path, const char* member,
                                         const char type, sd_bus_message* m)
{
    num_messages_++;
    std::vector<std::string> keys;

    std::string sender_orig = CheckAndFixNullString(sender);
    std::string dest_orig = CheckAndFixNullString(destination);
    // For method return messages, we actually want to show the sender
    // and destination of the original method call, so we swap the
    // sender and destination
    if (type == 2)
    { // DBUS_MESSAGE_TYPE_METHOD_METHOD_RETURN
        std::swap(sender_orig, dest_orig);
    }

    // Special case: when PID == 1 (init), the DBus unit would be systemd.
    // It seems it was not possible to obtain the connection name of systemd
    // so we manually set it here.
    const int sender_orig_pid =
        g_connection_snapshot->GetConnectionPIDFromNameOrUniqueName(
            sender_orig);

    if (sender_orig_pid == 1)
    {
        sender_orig = "systemd";
    }
    const int dest_orig_pid =
        g_connection_snapshot->GetConnectionPIDFromNameOrUniqueName(dest_orig);
    if (dest_orig_pid == 1)
    {
        dest_orig = "systemd";
    }

    for (DBusTopSortField field : fields_)
    {
        switch (field)
        {
            case kSender:
                keys.push_back(sender_orig);
                break;
            case kDestination:
                keys.push_back(dest_orig);
                break;
            case kInterface:
                keys.push_back(CheckAndFixNullString(interface));
                break;
            case kPath:
                keys.push_back(CheckAndFixNullString(path));
                break;
            case kMember:
                keys.push_back(CheckAndFixNullString(member));
                break;
            case kSenderPID:
            {
                if (sender_orig_pid != INVALID)
                {
                    keys.push_back(std::to_string(sender_orig_pid));
                }
                else
                {
                    keys.push_back("(unknown)");
                }
                break;
            }
            case kSenderCMD:
            {
                keys.push_back(
                    g_connection_snapshot->GetConnectionCMDFromNameOrUniqueName(
                        sender_orig));
                break;
            }
            case kMsgPerSec:
            case kAverageLatency:
                break; // Don't populate "keys" using these 2 fields
        }
    }
    // keys = combination of fields of user's choice

    if (stats_.count(keys) == 0)
    {
        stats_[keys] = DBusTopComputedMetrics();
    }
    // Need to update msg/s regardless
    switch (type)
    {
        case 1: // DBUS_MESSAGE_TYPE_METHOD_CALL
            stats_[keys].num_method_calls++;
            break;
        case 2: // DBUS_MESSAGE_TYPE_METHOD_METHOD_RETURN
            stats_[keys].num_method_returns++;
            break;
        case 3: // DBUS_MESSAGE_TYPE_ERROR
            stats_[keys].num_errors++;
            break;
        case 4: // DBUS_MESSAGE_TYPE_SIGNAL
            stats_[keys].num_signals++;
            break;
    }
    // Update global latency histogram
    // For method call latency
    if (type == 1)       // DBUS_MESSAGE_TYPE_METHOD_CALL
    {
        uint64_t serial; // serial == cookie
        sd_bus_message_get_cookie(m, &serial);
        in_flight_methodcalls[serial] = Microseconds();
    }
    else if (type == 2)            // DBUS_MESSAGE_TYPE_MEHOTD_RETURN
    {
        uint64_t reply_serial = 0; // serial == cookie
        sd_bus_message_get_reply_cookie(m, &reply_serial);
        if (in_flight_methodcalls.count(reply_serial) > 0)
        {
            float dt_usec = Microseconds() -
                            in_flight_methodcalls[reply_serial];
            in_flight_methodcalls.erase(reply_serial);
            dbus_top_analyzer::g_mc_time_histogram.AddSample(dt_usec);

            // Add method call count and total latency to the corresponding key
            stats_[keys].total_latency_usec += dt_usec;
        }
    }
    // For meaning of type see here
    // https://dbus.freedesktop.org/doc/api/html/group__DBusProtocol.html#ga4a9012edd7f22342f845e98150aeb858
    switch (type)
    {
        case 1:
            num_mc_++;
            break;
        case 2:
            num_mr_++;
            break;
        case 3:
            num_error_++;
            break;
        case 4:
            num_sig_++;
            break;
    }
}