#include <kernel/filesystem/vfs.hpp>

#include <kernel/filesystem/constants.hpp>
#include <kernel/filesystem/dentry.hpp>
#include <kernel/filesystem/devfs/filesystem.hpp>
#include <kernel/filesystem/filesystem.hpp>
#include <kernel/filesystem/mount.hpp>
#include <kernel/filesystem/mount_table.hpp>
#include <kernel/filesystem/path.hpp>
#include <kernel/filesystem/rootfs/filesystem.hpp>

#include <kapi/system.hpp>

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

#include <algorithm>
#include <cstdint>
#include <optional>
#include <ranges>
#include <string_view>

namespace
{
  constinit auto static active_vfs = std::optional<kernel::filesystem::vfs>{};
}  // namespace

namespace kernel::filesystem
{
  auto vfs::init() -> void
  {
    if (active_vfs)
    {
      kapi::system::panic("[FILESYSTEM] vfs has already been initialized.");
    }

    active_vfs.emplace(vfs{});
    active_vfs->init_internal();
  }

  auto vfs::init_internal() -> void
  {
    auto root_fs = kstd::make_shared<rootfs::filesystem>();
    root_fs->mount(nullptr);

    auto root_fs_root_dentry = kstd::make_shared<dentry>(nullptr, root_fs->root_inode(), "/");
    m_mount_table.add_mount(kstd::make_shared<mount>(nullptr, root_fs_root_dentry, root_fs, nullptr));

    // Mount devfs at /dev in rootfs (temporary, will be shadowed)
    auto device_fs = kstd::make_shared<devfs::filesystem>();
    device_fs->mount(nullptr);
    auto dev_mount_point_dentry = resolve_path("/dev");
    if (!dev_mount_point_dentry)
    {
      kapi::system::panic("[FILESYSTEM] failed to resolve /dev for initial devfs mount.");
    }
    do_mount_internal(dev_mount_point_dentry, device_fs);

    // Mount boot filesystem at / (will shadow rootfs)
    if (auto boot_device_dentry = resolve_path("/dev/ram0"))
    {
      if (auto boot_root_fs = kernel::filesystem::filesystem::probe_and_mount(boot_device_dentry->get_inode()))
      {
        do_mount_internal(root_fs_root_dentry, boot_root_fs);

        // Resolve / to get the boot root dentry
        if (auto boot_root_dentry = resolve_path("/"))
        {
          auto dev_dentry = kstd::make_shared<dentry>(boot_root_dentry, device_fs->root_inode(), "dev");
          boot_root_dentry->add_child(dev_dentry);

          do_mount_internal(dev_dentry, device_fs);
        }
      }
    }
  }

  auto vfs::get() -> vfs &
  {
    if (!active_vfs)
    {
      kapi::system::panic("[FILESYSTEM] vfs has not been initialized.");
    }

    return *active_vfs;
  }

  auto vfs::open(std::string_view path) -> kstd::shared_ptr<dentry>
  {
    return resolve_path(path);
  }

  auto vfs::do_mount(std::string_view source, std::string_view target) -> operation_result
  {
    if (!path::is_valid_path(source) || !path::is_valid_path(target))
    {
      return operation_result::invalid_path;
    }

    if (auto mount_point_dentry = resolve_path(target))
    {
      if (auto source_dentry = resolve_path(source))
      {
        if (auto fs = kernel::filesystem::filesystem::probe_and_mount(source_dentry->get_inode()))
        {
          do_mount_internal(mount_point_dentry, fs);
          return operation_result::success;
        }
        return operation_result::invalid_filesystem;
      }
      return operation_result::non_existent_path;
    }
    return operation_result::mount_point_not_found;
  }

  auto vfs::unmount(std::string_view path) -> operation_result
  {
    if (!path::is_valid_path(path))
    {
      return operation_result::invalid_path;
    }

    auto remove_result = m_mount_table.remove_mount(path);
    if (remove_result == mount_table::operation_result::removed)
    {
      return operation_result::success;
    }

    if (remove_result == mount_table::operation_result::has_child_mounts)
    {
      return operation_result::unmount_failed;
    }

    return operation_result::mount_point_not_found;
  }

  auto vfs::do_mount_internal(kstd::shared_ptr<dentry> const & mount_point_dentry,
                              kstd::shared_ptr<filesystem> const & fs) -> void
  {
    auto mount_path = mount_point_dentry->get_absolute_path();
    // TODO BA-FS26 refactoring, implement dentry lookup to get the parent mount...
    auto parent_mount = m_mount_table.find_longest_prefix_mount(mount_path.view());

    // auto parent_mount_dentry = mount_point_dentry->get_parent_mounted_dentry();
    // auto parent_mount = m_mount_table.find_exact_mount(parent_mount_dentry->get_full_path());

    auto new_fs_root =
        kstd::make_shared<dentry>(mount_point_dentry->get_parent(), fs->root_inode(), mount_point_dentry->get_name());
    auto new_mount = kstd::make_shared<mount>(mount_point_dentry, new_fs_root, fs, parent_mount);
    m_mount_table.add_mount(new_mount);
  }

  auto vfs::resolve_path(std::string_view path) -> kstd::shared_ptr<dentry>
  {
    if (!path::is_valid_absolute_path(path))
    {
      return nullptr;
    }

    auto current_mount = m_mount_table.find_exact_mount("/");
    if (!current_mount)
    {
      kapi::system::panic("[FILESYSTEM] no root mount found.");
    }

    auto current_dentry = current_mount->root_dentry();

    auto path_parts = path::split(path);
    kstd::vector path_parts_vector(path_parts.begin(), path_parts.end());
    std::ranges::reverse(path_parts_vector);

    auto symlink_counter = 0uz;

    while (!path_parts_vector.empty())
    {
      auto part = path_parts_vector.back();
      path_parts_vector.pop_back();

      if (part == ".")
      {
        continue;
      }

      if (part == "..")
      {
        auto parent_dentry = current_dentry->get_parent();

        if (current_dentry == current_mount->root_dentry())
        {
          if (current_mount->get_mount_path() == "/")
          {
            continue;
          }

          if (auto parent_mount = current_mount->get_parent_mount())
          {
            current_mount = parent_mount;
            current_dentry = parent_dentry;
          }
        }

        current_dentry = parent_dentry;
        continue;
      }

      auto next_dentry = current_dentry->find_child(part.view());
      if (!next_dentry)
      {
        auto current_fs = current_mount->get_filesystem();
        auto found_inode = current_fs->lookup(current_dentry->get_inode(), part.view());
        if (!found_inode)
        {
          return nullptr;
        }

        next_dentry = kstd::make_shared<dentry>(current_dentry, found_inode, part.view());
        current_dentry->add_child(next_dentry);
      }
      else if (next_dentry->has_flag(dentry::dentry_flags::mounted))
      {
        current_mount = m_mount_table.find_exact_mount(next_dentry->get_absolute_path().view());
        if (!current_mount)
        {
          kapi::system::panic("[FILESYSTEM] mount for dentry with mounted flag not found.");
        }

        next_dentry = current_mount->root_dentry();
      }

      if (next_dentry->get_inode()->is_symbolic_link())
      {
        if (symlink_counter++ > constants::symloop_max)
        {
          return nullptr;
        }

        kstd::vector<uint8_t> buffer(constants::symlink_max_path_length);
        auto const bytes_read = next_dentry->get_inode()->read(buffer.data(), 0, buffer.size());
        auto const symbolic_link_path = std::string_view{reinterpret_cast<char const *>(buffer.data()), bytes_read};

        auto symbolic_link_parts = path::split(symbolic_link_path);
        kstd::vector symbolic_link_parts_vector(symbolic_link_parts.begin(), symbolic_link_parts.end());
        std::ranges::reverse(symbolic_link_parts_vector);

        path_parts_vector.insert_range(path_parts_vector.end(), symbolic_link_parts_vector);

        if (path::is_valid_absolute_path(symbolic_link_path))
        {
          current_mount = m_mount_table.find_exact_mount("/");
          current_dentry = current_mount->root_dentry();
        }
        continue;
      }

      current_dentry = next_dentry;
    }

    return current_dentry;
  }
}  // namespace kernel::filesystem

namespace kernel::tests::filesystem::vfs
{
  auto deinit() -> void
  {
    active_vfs.reset();
  }
}  // namespace kernel::tests::filesystem::vfs