path: root/libs/multiboot2/include/multiboot2/information.hpp

#ifndef MULTIBOOT2_INFORMATION_HPP
#define MULTIBOOT2_INFORMATION_HPP

#include "information/data.hpp"      // IWYU pragma: export
#include "information/iterator.hpp"  // IWYU pragma: export
#include "information/tag.hpp"       // IWYU pragma: export

#include <kstd/units>

#include <elf/format.hpp>
#include <elf/section_header.hpp>

#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <optional>
#include <ranges>
#include <span>
#include <string_view>

namespace multiboot2
{

  /**
   * @copydoc multiboot2::data::basic_memory
   */
  struct basic_memory : tag<data::basic_memory>
  {
    using tag::tag;
  };

  /**
   * @copydoc multiboot2::data::bios_boot_device
   */
  struct bios_boot_device : tag<data::bios_boot_device>
  {
    using tag::tag;
  };

  /**
   * @copydoc multiboot2::data::command_line
   */
  struct command_line : vla_tag<data::command_line, char, std::basic_string_view>
  {
    using vla_tag::vla_tag;

    /**
     * @brief The command line string
     */
    [[nodiscard]] auto string() const noexcept -> range_type
    {
      return {data(), size()};
    }
  };

  /**
   * @copydoc multiboot2::data::elf_symbols
   */
  template<elf::format Format>
  struct elf_symbols : vla_tag<data::elf_symbols, elf::section_header<Format> const, std::span>
  {
    using base = vla_tag<data::elf_symbols, elf::section_header<Format> const, std::span>;
    using base::base;

    [[nodiscard]] auto name(elf::section_header<Format> const & section) const noexcept -> std::string_view
    {
      if (!this->string_table_index)
      {
        std::abort();
      }

      auto string_table = this->begin()[this->string_table_index];
      auto name_offset = section.name_offset;
      auto name_array = std::bit_cast<char const *>(string_table.virtual_load_address);
      return name_array + name_offset;
    }
  };

  /**
   * @copydoc multiboot2::data::loader_name
   */
  struct loader_name : vla_tag<data::loader_name, char, std::basic_string_view>
  {
    using vla_tag::vla_tag;

    /**
     * @brief The name of the bootloader
     */
    [[nodiscard]] auto string() const noexcept -> std::string_view
    {
      return {data(), size()};
    }
  };

  /**
   * @copydoc multiboot2::data::memory_map
   */
  struct memory_map : vla_tag<data::memory_map, data::memory_map::region, std::span>
  {
    using vla_tag::vla_tag;

    /**
     * @brief The available memory regions
     */
    [[nodiscard]] auto regions() const noexcept -> range_type
    {
      return {data(), size()};
    }
  };

  /**
   * @copydoc multiboot2::data::module
   */
  struct module : vla_tag<data::module, char, std::basic_string_view>
  {
    using vla_tag::vla_tag;

    /**
     * @brief The module command line or name.
     */
    [[nodiscard]] auto string() const noexcept -> std::string_view
    {
      return {data(), vla_tag::size()};
    }

    [[nodiscard]] constexpr auto size() const noexcept -> kstd::units::bytes
    {
      return kstd::units::bytes{end_address - start_address};
    }
  };
  
  struct acpi_rsdp : vla_tag<data::acpi_rsdp, std::byte, std::span>
  {
    using vla_tag::vla_tag;

    [[nodiscard]] auto pointer() const noexcept -> range_type
    {
      return {data(), size()};
    }
  };

  struct acpi_xsdp : vla_tag<data::acpi_xsdp, std::byte, std::span>
  {
    using vla_tag::vla_tag;

    [[nodiscard]] auto pointer() const noexcept -> range_type
    {
      return {data(), size()};
    }
  };

  struct information_view
  {
    using iterator = iterator;
    using value_type = iterator::value_type;
    using pointer = iterator::pointer;
    using reference = iterator::reference;

    [[nodiscard]] auto size() const noexcept -> kstd::units::bytes
    {
      return kstd::units::bytes{m_size};
    }

    // Range access

    [[nodiscard]] auto begin() const noexcept -> iterator
    {
      return iterator{&m_tags};
    }

    [[nodiscard]] auto end() const noexcept -> iterator
    {
      return iterator{};
    }

    // Tag access

    template<typename Tag>
    [[nodiscard]] auto has() const noexcept -> bool
    {
      return get<Tag>().has_value();
    }

    [[nodiscard]] auto maybe_basic_memory() const noexcept -> std::optional<basic_memory>
    {
      return get<multiboot2::basic_memory>();
    }

    [[nodiscard]] auto basic_memory() const -> basic_memory
    {
      return maybe_basic_memory().value();
    }

    [[nodiscard]] auto maybe_bios_boot_device() const noexcept -> std::optional<bios_boot_device>
    {
      return get<multiboot2::bios_boot_device>();
    }

    [[nodiscard]] auto bios_boot_device() const -> bios_boot_device
    {
      return maybe_bios_boot_device().value();
    }

    [[nodiscard]] auto maybe_command_line() const noexcept -> std::optional<command_line>
    {
      return get<multiboot2::command_line>();
    }

    [[nodiscard]] auto command_line() const -> command_line
    {
      return maybe_command_line().value();
    }

    template<elf::format Format>
    [[nodiscard]] auto maybe_elf_symbols() const noexcept -> std::optional<elf_symbols<Format>>
    {
      return get<multiboot2::elf_symbols<Format>>().and_then(
          [](auto x) -> std::optional<multiboot2::elf_symbols<Format>> {
            if (x.entry_size_in_B == elf::section_header_size<Format>)
            {
              return std::optional{x};
            }
            else
            {
              return std::nullopt;
            }
          });
    }

    template<elf::format Format>
    [[nodiscard]] auto elf_symbols() const -> elf_symbols<Format>
    {
      return maybe_elf_symbols<Format>().value();
    }

    [[nodiscard]] auto maybe_loader_name() const noexcept -> std::optional<loader_name>
    {
      return get<multiboot2::loader_name>();
    }

    [[nodiscard]] auto loader_name() const -> loader_name
    {
      return maybe_loader_name().value();
    }

    [[nodiscard]] auto maybe_memory_map() const noexcept -> std::optional<memory_map>
    {
      return get<multiboot2::memory_map>();
    }

    [[nodiscard]] auto memory_map() const -> memory_map
    {
      return maybe_memory_map().value();
    }

    [[nodiscard]] auto modules() const noexcept
    {
      auto filter_modules = [](auto const & tag) {
        return tag.information_id() == module::id;
      };
      auto transform_module = [](auto const & tag) {
        return module{&tag};
      };
      return std::ranges::subrange(begin(), end()) | std::views::filter(filter_modules) |
             std::views::transform(transform_module);
    }

    [[nodiscard]] auto maybe_acpi_rsdp() const noexcept -> std::optional<acpi_rsdp>
    {
      return get<multiboot2::acpi_rsdp>();
    }

    [[nodiscard]] auto acpi_rsdp() const noexcept -> acpi_rsdp
    {
      return maybe_acpi_rsdp().value();
    }

    [[nodiscard]] auto maybe_acpi_xsdp() const noexcept -> std::optional<acpi_xsdp>
    {
      return get<multiboot2::acpi_xsdp>();
    }

    [[nodiscard]] auto acpi_xsdp() const noexcept -> acpi_xsdp
    {
      return maybe_acpi_xsdp().value();
    }

  private:
    template<typename Tag>
    [[nodiscard]] constexpr auto get() const noexcept -> std::optional<Tag>
    {
      if (auto found = std::ranges::find_if(*this, [](auto tag) { return tag.information_id() == Tag::id; });
          found != end())
      {
        return Tag{&*found};
      }
      return std::nullopt;
    }

    uint32_t m_size{};
    uint32_t : 32;
    tag_header m_tags{};
  };

}  // namespace multiboot2

#endif