#include "kernel/devices/storage/management.hpp"

#include "kapi/boot_modules.hpp"
#include "kapi/devices/device.hpp"
#include "kapi/system.hpp"

#include "kernel/devices/storage/controller.hpp"
#include "kernel/devices/storage/ram_disk/controller.hpp"

#include <kstd/memory>
#include <kstd/vector>

#include <algorithm>
#include <cstddef>
#include <optional>

namespace
{
  constexpr size_t static MINORS_PER_DEVICE = 16;
  constexpr size_t static START_MAJOR = 1;
  constinit size_t static next_free_major = START_MAJOR;

  constinit auto static active_storage_management = std::optional<kernel::devices::storage::management>{};
}  // namespace

namespace kernel::devices::storage
{
  auto management::init() -> void
  {
    if (active_storage_management)
    {
      kapi::system::panic("[DEVICES] Storage management has already been initialized.");
    }
    active_storage_management.emplace(management{});

    auto current_ram_disk_controller =
        kstd::make_shared<ram_disk::controller>(&kapi::boot_modules::get_boot_module_registry());
    active_storage_management->add_controller(current_ram_disk_controller);

    std::ranges::for_each(active_storage_management->m_controllers, [](auto controller) { controller->probe(); });
  }

  auto management::get() -> management &
  {
    if (!active_storage_management)
    {
      kapi::system::panic("[DEVICES] Storage management has not been initialized.");
    }

    return *active_storage_management;
  }

  auto management::add_controller(kstd::shared_ptr<controller> const & controller) -> void
  {
    controller->set_ids(next_free_major++, MINORS_PER_DEVICE);
    m_controllers.push_back(controller);
  }

  auto management::all_controllers() const -> kstd::vector<kstd::shared_ptr<controller>> const &
  {
    return m_controllers;
  }

  auto management::device_by_major_minor(size_t major, size_t minor) -> kstd::shared_ptr<kapi::devices::device>
  {
    kstd::shared_ptr<kapi::devices::device> found = nullptr;

    std::ranges::find_if(m_controllers, [&](auto const & controller) {
      if (controller != nullptr && controller->major() == major)
      {
        found = controller->device_by_minor(minor);
        return found != nullptr;
      }
      return false;
    });

    return found;
  }

  auto management::determine_boot_device() -> kstd::shared_ptr<kapi::devices::device>
  {
    return device_by_major_minor(START_MAJOR, 0);
  }
}  // namespace kernel::devices::storage

namespace kernel::tests::devices::storage::management
{
  auto deinit() -> void
  {
    active_storage_management.reset();
    next_free_major = START_MAJOR;
  }
}  // namespace kernel::tests::devices::storage::management