#include "devices/storage/RAMDisk/RAMDiskController.hpp"

#include "kapi/boot_module/boot_module.hpp"
#include "kapi/boot_module/boot_module_registry.hpp"

#include "devices/BlockDevice.hpp"
#include "devices/storage/RAMDisk/RAMDiskDevice.hpp"

#include <kstd/print>

#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>

namespace devices::storage::ram_disk
{
  ram_disk_controller::ram_disk_controller(kapi::boot_modules::boot_module_registry const * registry)
      : m_boot_module_registry(registry)
  {}

  auto ram_disk_controller::probe() -> void
  {
    size_t current_device_index = 0;  // Starte bei 0

    std::ranges::for_each(*m_boot_module_registry, [this, &current_device_index](auto const & module) {
      auto const minor = current_device_index * m_minors_per_device;

      // TODO BA-FS26 use push_back from kstd::vector when available
      m_devices.at(0) = ram_disk_device{module, m_major, minor};

      current_device_index++;
    });

    std::ranges::for_each(*m_boot_module_registry,
                          [this](auto const & module) { create_device_from_boot_module(module); });
  }

  auto ram_disk_controller::create_device_from_boot_module(kapi::boot_modules::boot_module const & module) -> void
  {
    m_devices.at(0) = ram_disk_device{module};
  }

  auto ram_disk_controller::device_by_major_minor(size_t major, size_t minor) -> block_device *
  {
    auto it = std::ranges::find_if(
        m_devices, [major, minor](auto const & device) { return device.major() == major && device.minor() == minor; });

    if (it != m_devices.end())
    {
      return &(*it);
    }
    return nullptr;
  }

  auto ram_disk_controller::devices_count() -> size_t
  {
    return m_devices.size();
  }
}  // namespace devices::storage::ram_disk