// Copyright 2024 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 "activation.hpp"
#include "asset.hpp"
#include "ec_util.hpp"
#include "firmware_mtd_updater.hpp"
#include "firmware_spi_updater.hpp"
#include "host_command.hpp"
#include "hoth.hpp"
#include "hoth_state.hpp"
#include "log_collector_util.hpp"
#include "message_file.hpp"
#include "message_intf.hpp"
#include "message_reinit.hpp"
#include "mtd_util.hpp"
#include "payload_update.hpp"
#include "sys.hpp"
#include "sys_interface.hpp"
#include "version.hpp"

#include <bits/getopt_core.h>
#include <stdlib.h>
#include <string.h>
#include <systemd/sd-daemon.h>
#include <unistd.h>

#include <boost/asio.hpp>
#include <boost/asio/io_context.hpp>
#include <sdbusplus/asio/connection.hpp>
#include <sdbusplus/asio/object_server.hpp>
#include <sdbusplus/bus.hpp>
#include <stdplus/print.hpp>

#include <exception>
#include <format>
#include <memory>
#include <string>
#include <string_view>

#ifdef HAVE_USB
#include "libhoth_usb.hpp"
#include "libusb_impl.hpp"
#include "message_hoth_usb.hpp"
#endif

#include <xyz/openbmc_project/Control/Hoth/error.hpp>

const char* HOTH_CONTROL_PATH = "/xyz/openbmc_project/Control/Hoth";
const char* HOTH_CONTROL_BUS = "xyz.openbmc_project.Control.Hoth";
const char* VERSION_BASE_PATH = "/xyz/openbmc_project/software";
const char* ASSET_BASE_PATH = "/xyz/openbmc_project/inventory";

constexpr static const char* kEmService = "xyz.openbmc_project.EntityManager";
constexpr static const char* kConfigPathPrefix =
    "xyz.openbmc_project.Configuration.Hoth";

// NOLINTNEXTLINE(google-build-using-namespace)
using namespace std::string_literals;
using sdbusplus::error::xyz::openbmc_project::control::hoth::InterfaceError;

using Value = std::variant<std::monostate>;
using ObjectType =
    std::unordered_map<std::string, std::unordered_map<std::string, Value>>;
using ManagedObjectType =
    std::vector<std::pair<sdbusplus::message::object_path, ObjectType>>;

static void usage(const char* name)
{
    stdplus::print(stderr, "\
Usage: {} [-m <MAILBOX>]\n\
Bridge commands between a D-Bus interface and Hoth's mailbox\n\n\
  -b                        Blocks the use of legacy payload verify commands.\n\
  -u <UART_CHANNEL_ID>      Collects and streams the device UART logs.\n\n\
  -m <MAILBOX>              Use the file at <MAILBOX> as the mailbox.\n\
                            If omitted, it will be located automatically.\n\n\
  -n <NAME>                 Use the name <NAME> for the hoth on DBus.\n\
                            If omitted, it will use the legacy empty name.\n\n\
  -a <ADDRESS_MODE>         SPI address mode (address can be 3 or 4 bytes) .\n\
                            If omitted, it will use 4 bytes by default.\n\n\
  -r<TYPE>                  Resets target before SPI flash. Possible types:\n\
     needed:        Default if no <TYPE> provided. Put the target into reset\n\
                    if SPS passthrough enabled or status unknown.\n\
     never:         Same as no -r. Never put the target in reset.\n\
     ignore_fail:   Put target in reset if SPS passthrough enabled, but ignore\n\
                    SPS status command failures.\n\
     needed_active: Same as \"needed\" but it tries disabling SPS passthrough\n\
                    when it is enabled.\n",
                   name);
}

static std::string findBoardObjPath(const std::string& assetObj,
                                    const std::string& objPath,
                                    const ObjectType& ifcAndProperties)
{
    for (const auto& [ifc, properties] : ifcAndProperties)
    {
        if (ifc.starts_with(kConfigPathPrefix))
        {
            /* Match the hoth name from the objPath to the hoth name
             * obtained from Configuration.Hoth interface */
            if (objPath.substr(objPath.find_last_of('/') + 1) ==
                assetObj.substr(assetObj.find_last_of('/') + 1))
            {
                return objPath.substr(0, objPath.find_last_of('/'));
            }
        }
    }

    return std::string();
}

uint32_t getUartChannelId(const std::string &uartChannelStr) {
  uint32_t uartChannelId = 0;
  for (char c : uartChannelStr) {
    uartChannelId <<= 8; // or 0x100, shifting 2 hex digits
    uartChannelId += static_cast<uint32_t>(c);
  }
  return uartChannelId;
}

using google::hoth::internal::ResetMode;

ResetMode parseReset(char* str)
{
    if (!str || "needed"s == str)
    {
        return ResetMode::needed;
    }
    if ("never"s == str)
    {
        return ResetMode::never;
    }
    if ("ignore_fail"s == str)
    {
        return ResetMode::ignore;
    }
    if ("needed_active"s == str)
    {
        return ResetMode::needed_active;
    }
    stdplus::print(stderr, "Unknown reset type {}\n", str);
    exit(EXIT_FAILURE);
}

int main(int argc, char* argv[])
{
    bool allow_legacy_verify = true;
    const char *mailbox = nullptr, *name = "", *uartChannel = "";
    uint8_t addressSize = 4;
    int opt;
    ResetMode targetReset = ResetMode::never;
    bool ignoreAddressMode = false;

    while ((opt = getopt(argc, argv, "bu:m:n:a:r::i")) != -1)
    {
        switch (opt)
        {
            case 'b':
                allow_legacy_verify = false;
                break;
            case 'u':
                uartChannel = optarg;
                break;
            case 'm':
                mailbox = optarg;
                break;
            case 'n':
                name = optarg;
                break;
            case 'a':
                addressSize = std::stoi(optarg);
                break;
            case 'r':
                targetReset = parseReset(optarg);
                break;
            case 'i':
                ignoreAddressMode = true;
                break;
            default:
                usage(argv[0]);
                exit(EXIT_FAILURE);
        }
    }

    std::unique_ptr<google::hoth::MessageIntf> msg;
    std::unique_ptr<google::hoth::internal::HostCommandImpl> hostCmd;
    std::unique_ptr<google::hoth::internal::PayloadUpdateImpl> payloadUpdate;
    std::unique_ptr<google::hoth::internal::EcUtilImpl> ecUtil;
    std::unique_ptr<google::hoth::Hoth> hoth;
    std::unique_ptr<google::hoth::HothState> hoth_state;
    std::unique_ptr<google::hoth::RoVersion> swVerRo;
    std::unique_ptr<google::hoth::RwVersion> swVerRw;
    std::unique_ptr<google::hoth::SwActivation> swActivationRo;
    std::unique_ptr<google::hoth::SwActivation> swActivationRw;
    std::unique_ptr<google::hoth::Asset> asset;
    std::unique_ptr<google::hoth::internal::FirmwareUpdater> firmwareUpdater;

    google::hoth::internal::RateLimiter rateLimiter(kRateLimiterMilliSeconds);
    std::unique_ptr<google::hoth::internal::LogCollectorUtil> logCollectorUtil =
        std::make_unique<google::hoth::internal::LogCollectorUtil>(
            rateLimiter, kAsyncWaitTimeInSeconds);

    google::hoth::internal::Mtd* mtd = &google::hoth::internal::mtdImpl;
    google::hoth::internal::Sys* sys = &google::hoth::internal::sys_impl;
    boost::asio::io_context io;

    std::shared_ptr<sdbusplus::asio::connection> systemBus =
        std::make_shared<sdbusplus::asio::connection>(io);
    sdbusplus::asio::object_server objectServer(systemBus, true);
    objectServer.add_manager("/");

    size_t max_retries = 2;

    try
    {
        constexpr std::string_view usbPrefix = "usb:";
        if (!mailbox)
        {
            msg = std::make_unique<google::hoth::MessageFile>(
                google::hoth::internal::mtdImpl.findPartition("hoth-mailbox"));
            max_retries = 1;
        }
        else if (strncmp(mailbox, usbPrefix.data(), usbPrefix.size()) == 0)
        {
#ifdef HAVE_USB
            msg = std::make_unique<google::hoth::MessageReinit<
                google::hoth::MessageHothUSB, std::string_view,
                google::hoth::LibusbIntf*, google::hoth::LibHothUsbIntf*>>(
                mailbox + usbPrefix.size(), &google::hoth::libusb_impl,
                &google::hoth::libhoth_usb);
            mtd = nullptr;
#else
            throw std::logic_error("Missing USB support");
#endif
        }
        else
        {
            msg = std::make_unique<google::hoth::MessageFile>(mailbox);
        }

        hostCmd = std::make_unique<google::hoth::internal::HostCommandImpl>(
            msg.get(), &io, logCollectorUtil.get(), name, max_retries,
            allow_legacy_verify, getUartChannelId(uartChannel));
        payloadUpdate =
            std::make_unique<google::hoth::internal::PayloadUpdateImpl>(
                hostCmd.get());
        ecUtil =
            std::make_unique<google::hoth::internal::EcUtilImpl>(hostCmd.get());
        if (mtd)
        {
            firmwareUpdater =
                std::make_unique<google::hoth::internal::FirmwareMtdUpdater>(
                    mtd, sys);
        }
        else
        {
            firmwareUpdater =
                std::make_unique<google::hoth::internal::FirmwareSpiUpdater>(
                    hostCmd.get(), addressSize, targetReset, ignoreAddressMode);
        }

        // To facilitate debugging Hoth errors, emit a snapshot of its console.
        hostCmd->collectHothLogsAsync(true);
    }
    catch (const std::exception& e)
    {
        stdplus::print(stderr, "Error setting up Hoth interface: {}\n",
                       e.what());
        exit(EXIT_FAILURE);
    }

    try
    {
        std::string obj = HOTH_CONTROL_PATH, svc = HOTH_CONTROL_BUS;
        if (name[0] != '\0')
        {
            obj += "/";
            obj += name;
            svc += ".";
            svc += name;
        }
        hoth = std::make_unique<google::hoth::Hoth>(
            *systemBus, obj.c_str(), hostCmd.get(), payloadUpdate.get(),
            ecUtil.get(), firmwareUpdater.get());
        hoth_state = std::make_unique<google::hoth::HothState>(
            *systemBus, io, obj.c_str(), hostCmd.get(), ecUtil.get());
        systemBus->request_name(svc.c_str());
    }
    catch (const std::exception& e)
    {
        stdplus::print(stderr,
                       "Error registering Hoth control object with D-Bus: {}\n",
                       e.what());
        exit(EXIT_FAILURE);
    }

    try
    {
        std::string ro_obj, rw_obj;

        std::string ver_obj =
            std::format("{}/hoth{}", VERSION_BASE_PATH,
                        name[0] != '\0' ? std::string("_") + name : "");

        ro_obj = ver_obj + "_ro";
        rw_obj = ver_obj + "_rw";

        swVerRo = std::make_unique<google::hoth::RoVersion>(
            *systemBus, ro_obj.c_str(), hostCmd.get());
        swVerRw = std::make_unique<google::hoth::RwVersion>(
            *systemBus, rw_obj.c_str(), hostCmd.get());
        swActivationRo = std::make_unique<google::hoth::SwActivation>(
            *systemBus, ro_obj.c_str());
        swActivationRw = std::make_unique<google::hoth::SwActivation>(
            *systemBus, rw_obj.c_str());
    }
    catch (const std::exception& e)
    {
      stdplus::print(stderr,
                     "Error registering Software Version or Activation objects "
                     "with D-Bus: {}\n",
                     e.what());
      exit(EXIT_FAILURE);
    }
    sd_notify(0, "READY=1");

    std::string assetObj =
        std::format("{}/hoth{}", ASSET_BASE_PATH,
                    name[0] != '\0' ? std::string("_") + name : "");
    std::string board_obj;

    ManagedObjectType managedObjs;
    try
    {
        auto method = systemBus->new_method_call(
            kEmService, "/xyz/openbmc_project/inventory",
            "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
        systemBus->call(method).read(managedObjs);
    }
    catch (const sdbusplus::exception::SdBusError& e)
    {
        stdplus::print(
            stderr, "Failed to get managed objects from entity manager: {}\n",
            e.what());
    }

    /* Find the board object path */
    for (const auto& [path, ifcToProperties] : managedObjs)
    {
        board_obj = findBoardObjPath(assetObj, path.str, ifcToProperties);
        if (!board_obj.empty())
        {
            try
            {
                asset = std::make_unique<google::hoth::Asset>(
                    *systemBus, assetObj, board_obj, hostCmd.get());
            }
            catch (const std::exception& e)
            {
                stdplus::print(
                    stderr, "Error registering Asset Object with D-Bus: {}\n",
                    e.what());
                exit(EXIT_FAILURE);
            }

            break;
        }
    }

    auto ifcAddedMatch = std::make_unique<sdbusplus::bus::match_t>(
        *systemBus,
        sdbusplus::bus::match::rules::interfacesAdded() +
            sdbusplus::bus::match::rules::sender(kEmService),
        [&systemBus, &hostCmd, &asset, &assetObj](sdbusplus::message_t& msg) {
            sdbusplus::message::object_path objPath;
            ObjectType ifcAndProperties;
            try
            {
                msg.read(objPath, ifcAndProperties);
            }
            catch (const std::exception& e)
            {
                stdplus::print(stderr,
                               "Error reading objects from EM service: {}\n",
                               e.what());
                return;
            }

            std::string boardObj =
                findBoardObjPath(assetObj, objPath.str, ifcAndProperties);
            if (!boardObj.empty())
            {
                try
                {
                    if (asset)
                    {
                        asset.reset();
                    }
                    asset = std::make_unique<google::hoth::Asset>(
                        *systemBus, assetObj, boardObj, hostCmd.get());
                }
                catch (const std::exception& e)
                {
                    stdplus::print(
                        stderr,
                        "Error registering Asset Object with D-Bus: {}\n",
                        e.what());
                    exit(EXIT_FAILURE);
                }
            }
        });

    try
    {
        io.run();
    }
    catch (const InterfaceError& e)
    {
        stdplus::print(stderr,
                       "Lost connection with Hoth. Shutting down. e={}\n",
                       e.what());
        return EXIT_FAILURE;
    }
    return 0;
}