#include "NamespaceReferenceManager.h"
#include "Merkle.h"
namespace nt
{
NamespaceReferenceManager::NamespaceReferenceManager(ObjectManager& objects,
IStorageBackend& storage)
: objects_(objects), storage_(storage)
{}
// Resolves the multigroup hash that `mg_name` currently maps to inside the
// branch-tree rooted at `branch_tree_root`. Returns the empty string when
// the branch is unborn (empty root) or the multigroup is absent.
static std::string lookup_mg_hash(IStorageBackend& storage,
const std::string& branch_tree_root,
const std::string& mg_name)
{
if (branch_tree_root.empty()) return "";
auto found = Merkle<std::string>::Get(storage, branch_tree_root, mg_name);
if (!found) return "";
// All-zero payload = "no snapshot bound" sentinel matching MultigroupCodec.
static const Hash32 zero{};
if (*found == zero) return "";
return bin_to_hex(*found);
}
std::vector<std::string> NamespaceReferenceManager::Resolve(
std::vector<std::string> path) const
{
constexpr int kMaxReparseDepth = 30;
for (int depth = 0; depth < kMaxReparseDepth; ++depth)
{
// /system/sessions/<X>/branches/<name>/multigroups/<mg>/<sub>...
// — per-session override takes precedence; absent override falls
// back to the global branch. Requires at minimum the literal
// "multigroups" qualifier and an mg name.
if (path.size() > 6
&& path[0] == "system"
&& path[1] == "sessions"
&& path[3] == "branches"
&& path[5] == "multigroups")
{
const std::vector<std::string> session_path{
"system", "sessions", path[2]
};
auto* session_entry = objects_.Find(session_path);
std::string branch_tree_root;
if (session_entry && session_entry->object)
{
auto* session = dynamic_cast<ObjectManager::Session*>(
session_entry->object.get());
if (session)
{
auto it = session->branch_overrides.find(path[4]);
if (it != session->branch_overrides.end())
branch_tree_root = it->second;
}
}
// No session-level override — defer to the global branch's HEAD.
if (branch_tree_root.empty())
{
const std::vector<std::string> branch_path{
"system", "branches", path[4]
};
auto* bentry = objects_.Find(branch_path);
if (bentry && bentry->object)
{
auto* branch = dynamic_cast<ObjectManager::Branch*>(
bentry->object.get());
if (branch) branch_tree_root = branch->target_hash;
}
}
const std::string mg_hash =
lookup_mg_hash(storage_, branch_tree_root, path[6]);
if (mg_hash.empty()) return path;
std::vector<std::string> rewritten{
"system", "snapshots", mg_hash
};
for (size_t i = 7; i < path.size(); ++i)
rewritten.push_back(path[i]);
path = std::move(rewritten);
continue;
}
// /system/branches/<name>/multigroups/<mg>/<sub>... →
// /system/snapshots/<mg_hash>/<sub>...
// Requires the literal "multigroups" qualifier and an mg name. A
// bare /system/branches/<name> path opens the branch object itself
// and is returned unchanged.
if (path.size() > 4
&& path[0] == "system"
&& path[1] == "branches"
&& path[3] == "multigroups")
{
const std::vector<std::string> branch_path{
"system", "branches", path[2]
};
auto* entry = objects_.Find(branch_path);
if (!entry || !entry->object) return path;
auto* branch =
dynamic_cast<ObjectManager::Branch*>(entry->object.get());
if (!branch) return path;
const std::string mg_hash =
lookup_mg_hash(storage_, branch->target_hash, path[4]);
if (mg_hash.empty()) return path;
std::vector<std::string> rewritten{
"system", "snapshots", mg_hash
};
for (size_t i = 5; i < path.size(); ++i)
rewritten.push_back(path[i]);
path = std::move(rewritten);
continue;
}
return path;
}
// Cycle guard tripped — surface as a lookup miss.
return {};
}
}
