#include <kapi/devices/facet_registry.hpp>

#include <kapi/devices.hpp>
#include <kapi/system.hpp>
#include <kapi/test_support/devices.hpp>

#include <kstd/memory.hpp>
#include <kstd/mutex.hpp>
#include <kstd/result.hpp>
#include <kstd/string.hpp>
#include <kstd/system_error.hpp>
#include <kstd/vector.hpp>

#include <algorithm>
#include <optional>
#include <string_view>
#include <utility>

namespace kapi::devices
{

  namespace
  {
    constinit auto static registry = std::optional<facet_registry>{};
  }

  auto facet_registry::init() -> void
  {
    if (registry.has_value())
    {
      system::panic("[kernel] Device facet registry has already been initialized.");
    }

    registry.emplace();
  }

  auto facet_registry::get() -> facet_registry &
  {
    if (!registry)
    {
      system::panic("[kernel] Device facet registry has not been initialized.");
    }

    return *registry;
  }

  auto facet_registry::do_publish(kstd::shared_ptr<device> device, kstd::string name, kapi::capabilities::facet_id id,
                                  void * facet) -> kstd::result<void>
  {
    auto published = std::optional<entry>{};

    {
      auto guard = kstd::lock_guard{m_lock};

      erase_if(m_entries, [id](auto e) { return e.id() == id && !e.device(); });

      if (!device || !facet || name.empty())
      {
        return kstd::failure(make_error_code(kstd::errc::invalid_argument));
      }

      auto already_published = std::ranges::any_of(
          m_entries, [&](auto const & entry) { return entry.id() == id && entry.device().get() == device.get(); });

      if (already_published)
      {
        return kstd::failure(make_error_code(kstd::errc::file_exists));
      }

      published = m_entries.emplace_back(device, std::move(name), id, facet);
    }

    do_notify_published(id, *published);

    return kstd::success();
  }

  auto facet_registry::do_notify_published(kapi::capabilities::facet_id id, entry const & published) -> void
  {
    auto observers = kstd::vector<kstd::weak_ptr<facet_registry_observer>>{};
    auto static_observers = kstd::vector<facet_registry_observer *>{};
    {
      auto guard = kstd::lock_guard{m_lock};
      observers = m_observers;
      static_observers = m_static_observers;
    }

    std::ranges::for_each(observers, [&](auto observer) {
      if (auto locked_observer = observer.lock())
      {
        locked_observer->on_facet_published(id, published);
      }
    });

    std::ranges::for_each(static_observers, [&](auto observer) { observer->on_facet_published(id, published); });
  }

  auto facet_registry::do_notify_withdrawn(kapi::capabilities::facet_id id, device const & device) -> void
  {
    auto observers = kstd::vector<kstd::weak_ptr<facet_registry_observer>>{};
    auto static_observers = kstd::vector<facet_registry_observer *>{};
    {
      auto guard = kstd::lock_guard{m_lock};
      observers = m_observers;
      static_observers = m_static_observers;
    }

    std::ranges::for_each(observers, [&](auto observer) {
      if (auto locked_observer = observer.lock())
      {
        locked_observer->on_facet_withdrawn(id, const_cast<devices::device &>(device));
      }
    });

    std::ranges::for_each(static_observers, [&](auto observer) {
      observer->on_facet_withdrawn(id, const_cast<devices::device &>(device));
    });
  }

  auto facet_registry::withdraw(device const & device, kapi::capabilities::facet_id id) -> void
  {
    auto did_remove = false;

    {
      auto guard = kstd::lock_guard{m_lock};
      did_remove = erase_if(m_entries, [&](auto e) {
                     auto locked_device = e.device();
                     return e.id() == id && locked_device && locked_device.get() == &device;
                   }) != 0;
    }

    if (did_remove)
    {
      do_notify_withdrawn(id, device);
    }
  }

  auto facet_registry::withdraw_all_for(device const & device) -> void
  {
    auto withdrawn_facets = kstd::vector<kapi::capabilities::facet_id>{};

    {
      auto guard = kstd::lock_guard{m_lock};

      erase_if(m_entries, [&](auto e) {
        auto locked_device = e.device();
        auto do_erase = locked_device && locked_device.get() == &device;
        if (do_erase)
        {
          withdrawn_facets.push_back(e.id());
        }
        return do_erase;
      });
    }

    std::ranges::for_each(withdrawn_facets, [&](auto facet) { do_notify_withdrawn(facet, device); });
  }

  auto facet_registry::all(kapi::capabilities::facet_id id) const -> kstd::vector<entry>
  {
    auto guard = kstd::lock_guard{m_lock};

    auto filtered = m_entries;
    erase_if(filtered, [&](auto e) {
      auto locked_device = e.device();
      return !(e.id() == id && locked_device);
    });
    return filtered;
  }

  auto facet_registry::resolve(kapi::capabilities::facet_id facet, std::string_view name) -> void *
  {
    auto found_device = kstd::shared_ptr<device>{};
    {
      auto guard = kstd::lock_guard{m_lock};

      auto found = std::ranges::find_if(m_entries, [&](auto e) { return e.name() == name && e.device(); });

      if (found == m_entries.cend())
      {
        return nullptr;
      }

      found_device = found->device();
    }

    if (!found_device)
    {
      return nullptr;
    }

    return resolve(facet, *found_device);
  }

  auto facet_registry::resolve(kapi::capabilities::facet_id id, device & device) -> void *
  {
    if (auto by_device = device.facet(id))
    {
      return by_device;
    }

    auto guard = kstd::lock_guard{m_lock};

    auto found = std::ranges::find_if(m_entries, [&](auto e) {
      auto locked_device = e.device();
      return e.id() == id && locked_device && locked_device.get() == &device;
    });

    if (found == m_entries.cend())
    {
      return nullptr;
    }

    return found->untyped_facet();
  }

  auto facet_registry::subscribe(kstd::weak_ptr<facet_registry_observer> observer) -> void
  {
    auto guard = kstd::lock_guard{m_lock};

    erase_if(m_observers, [](auto const & observer) { return observer.expired(); });
    m_observers.push_back(observer);
  }

  auto facet_registry::subscribe(facet_registry_observer & observer) -> void
  {
    auto guard = kstd::lock_guard{m_lock};

    m_static_observers.push_back(&observer);
  }

  auto facet_registry::unsubscribe(facet_registry_observer & observer) -> void
  {
    auto guard = kstd::lock_guard{m_lock};

    erase_if(m_observers, [&](auto const & subscribed) { return subscribed.lock().get() == &observer; });
    erase(m_static_observers, &observer);
  }

}  // namespace kapi::devices

namespace kapi::test_support::devices
{
  auto deinit_facet_registry() -> void
  {
    kapi::devices::registry.reset();
  }
}  // namespace kapi::test_support::devices