// 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 <filesystem>
#include <fstream>
#include <functional>
#include <iostream>
#include <sstream>
#include <string>

extern SensorSnapshot* g_sensor_snapshot;
extern DBusConnectionSnapshot* g_connection_snapshot;
extern sd_bus* g_bus;
extern SensorDetailView* g_sensor_detail_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(
    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(
                g_bus, &m, service.c_str(), obj_path.c_str(),
                "org.freedesktop.DBus.Introspectable", "Introspect");
            if (r < 0)
            {
                printf("Oh! Cannot create new method call. r=%d, strerror=%s\n",
                       r, strerror(-r));
                continue;
            }
            r = sd_bus_call(g_bus, m, 0, &err, &reply);
            if (r < 0)
            {
                printf("Could not execute method call, r=%d, strerror=%s\n", r,
                       strerror(-r));
            }
            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);
                std::string s1(s);
                if (r < 0)
                {
                    printf("Could not read string payload, r=%d, strerror=%s\n",
                           r, strerror(-r));
                }
                else
                {
                    XMLNode* t = ParseXML(s1);
                    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()
{
    g_connection_snapshot = new DBusConnectionSnapshot();
    printf("1. Getting names\n");
    char** names;
    int r = sd_bus_list_names(g_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);
    printf("2. Getting creds of each name\n");
    for (int i = 0; i < static_cast<int>(services.size()); i++)
    {
        const std::string& service = services[i];
        sd_bus_creds* creds = nullptr;
        r = sd_bus_get_name_creds(g_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)
        {
            printf("Oh! Cannot get creds for %s\n", services[i].c_str());
        }
        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;
        }
        else
        {
            printf("Oh! Could not get unique name for %s\n", service.c_str());
        }
        std::string unit;
        r = sd_bus_creds_get_unit(creds, &u);
        if (r >= 0)
        {
            unit = u;
        }
        else
        {
            printf("Oh! Could not get unit name for %s\n", unit.c_str());
        }
        printf("AddConnection    %s    %s    %s    %s    %d\n", service.c_str(),
               connection.c_str(), comm.c_str(), unit.c_str(), pid);
        g_connection_snapshot->AddConnection(service, connection, comm, unit,
                                             pid);
    }
    printf("There are %d DBus names.\n", int(services.size()));
    for (int i = 0; i < int(services.size()); i++)
    {
        printf("    %d: %s [%s]\n", i, services[i].c_str(), comms[i].c_str());
    }
    g_sensor_snapshot = new SensorSnapshot(g_connection_snapshot);
    // busctl call xyz.openbmc_project.ObjectMapper /
    // org.freedesktop.DBus.Introspectable Introspect
    printf("3. See which sensors are visible from Object Mapper\n");
    printf("3.1. Introspect Object Mapper for object paths\n");
    std::vector<std::string> all_obj_paths = FindAllObjectPathsForService(
        "xyz.openbmc_project.ObjectMapper", nullptr);
    sd_bus_error err = SD_BUS_ERROR_NULL;
    sd_bus_message *m, *reply;
    printf("%d paths found while introspecting ObjectMapper.\n",
           int(all_obj_paths.size()));
    printf("3.2. Call ObjectMapper's GetObject method against the sensor "
           "object paths that represent sensors\n");
    for (const std::string& p : all_obj_paths)
    {
        if (IsSensorObjectPath(p))
        {
            err = SD_BUS_ERROR_NULL;
            r = sd_bus_message_new_method_call(
                g_bus, &m, "xyz.openbmc_project.ObjectMapper",
                "/xyz/openbmc_project/object_mapper",
                "xyz.openbmc_project.ObjectMapper", "GetObject");
            if (r < 0)
            {
                printf("Cannot create new method call. r=%d, strerror=%s\n", r,
                       strerror(-r));
                continue;
            }
            r = sd_bus_message_append_basic(m, 's', p.c_str());
            if (r < 0)
            {
                printf("Could not append a string parameter to m\n");
                continue;
            }
            // empty array
            r = sd_bus_message_open_container(m, 'a', "s");
            if (r < 0)
            {
                printf("Could not open a container for m\n");
                continue;
            }
            r = sd_bus_message_close_container(m);
            if (r < 0)
            {
                printf("Could not close container for m\n");
                continue;
            }
            r = sd_bus_call(g_bus, m, 0, &err, &reply);
            if (r < 0)
            {
                printf("Error performing dbus method call\n");
            }
            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)
                {
                    printf("Could not enter the level 0 array container\n");
                    continue;
                }
                while (true)
                {
                    r = sd_bus_message_enter_container(
                        reply, SD_BUS_TYPE_DICT_ENTRY, "sas");
                    if (r < 0)
                    {
                        // printf("Could not enter the level 1 dict
                        // container\n");
                        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)
                        {
                            printf("Could not read interface_map_first\n");
                            goto DONE;
                        }
                        r = sd_bus_message_enter_container(reply, 'a', "s");
                        if (r < 0)
                        {
                            printf("Could not enter the level 2 array "
                                   "container\n");
                            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)
                            {
                                printf("Could not read interface_map_second\n");
                            }
                            else if (r == 0)
                                break;
                            else
                            {
                                // printf("    %s\n", interface_map_second);
                                if (!strcmp(interface_map_second,
                                            "xyz.openbmc_project.Sensor.Value"))
                                {
                                    has_value_interface = true;
                                }
                            }
                        }
                        if (has_value_interface)
                        {
                            g_sensor_snapshot->SerSensorVisibleFromObjectMapper(
                                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:
        {}
        }
    }
    printf("4. Check Hwmon's DBus objects\n");
    for (int i = 0; i < int(comms.size()); i++)
    {
        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(service, nullptr);
            for (const std::string& op : objpaths)
            {
                if (IsSensorObjectPath(op))
                {
                    g_sensor_snapshot->SetSensorVisibleFromHwmon(service, op);
                }
            }
        }
    }
    // Call `ipmitool sdr list` and see which sensors exist.
    printf("5. Checking ipmitool SDR List\n");
    std::string out;
    bool skip_sdr_list = false;
    if (getenv("SKIP"))
    {
        skip_sdr_list = true;
    }
    if (!skip_sdr_list)
    {
        constexpr int MAX_BUFFER = 255;
        char buffer[MAX_BUFFER];
        FILE* stream = popen("ipmitool sdr list", "r");
        while (fgets(buffer, MAX_BUFFER, stream) != NULL)
        {
            out.append(buffer);
        }
        pclose(stream);
    }
    std::stringstream ss(out);
    while (true)
    {
        std::string sensor_id, reading, status;
        std::getline(ss, sensor_id, '|');
        std::getline(ss, reading, '|');
        std::getline(ss, status);
        // printf("%s %s %s\n", sensor_id.c_str(), reading.c_str(),
        // status.c_str());
        if (sensor_id.size() > 0 && reading.size() > 0 && status.size() > 0)
        {
            g_sensor_snapshot->SetSensorVisibleFromIpmitoolSdr(Trim(sensor_id));
        }
        else
            break;
    }
    printf("=== Sensors snapshot summary: ===\n");
    g_sensor_snapshot->PrintSummary();
}
} // 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;
    }
}