Hierarchical Registries

// The .eth registry
IRegistry ethRegistry = rootRegistry.getSubregistry("eth");

// It can register vitalik.eth
ethRegistry.register("vitalik", owner, subregistry, resolver, roles, expiry);

// But it has NO control over sub.vitalik.eth
// That's controlled by vitalik.eth's subregistry

                    Root Registry ("")
                    |
         +----------+----------+
         |                    |
    .eth Registry        .box Registry
         |
    +----+----+
    |         |
vitalik   nick       
  Registry  Registry
    |         |
  sub     www

// Start at root
IRegistry current = rootRegistry;

// Traverse to .eth
current = current.getSubregistry("eth");  // Returns .eth registry

// Traverse to vitalik.eth
current = current.getSubregistry("vitalik");  // Returns vitalik registry

// Get resolver for sub.vitalik.eth
address resolver = current.getResolver("sub");  // Returns resolver or address(0)

// The subregistry should know its parent location
subRegistry.setParent(parentRegistry, "sub");

// Now it can report its canonical name
(IRegistry parent, string memory label) = subRegistry.getParent();
// parent = parentRegistry
// label = "sub"

// Level 1: example.eth has a registry
IRegistry level1 = new PermissionedRegistry(...);
ethRegistry.register("example", owner1, level1, resolver1, roles1, expiry1);

// Level 2: sub.example.eth has a registry
IRegistry level2 = new PermissionedRegistry(...);
level1.register("sub", owner2, level2, resolver2, roles2, expiry2);

// Level 3: deep.sub.example.eth has a registry
IRegistry level3 = new PermissionedRegistry(...);
level2.register("deep", owner3, level3, resolver3, roles3, expiry3);

// And so on...

// .eth uses PermissionedRegistry with expiry
PermissionedRegistry ethRegistry = new PermissionedRegistry(...);

// vitalik.eth uses a custom registry with different rules
CustomRegistry customRegistry = new CustomRegistry(...);
ethRegistry.register("vitalik", owner, customRegistry, resolver, roles, expiry);

// As long as it implements IRegistry, it works!

// Register example.eth with resolver but NO subregistry
ethRegistry.register(
    "example",
    owner,
    IRegistry(address(0)),  // No subregistry
    wildcardResolver,       // This resolver handles *.example.eth
    roles,
    expiry
);

// Now ANY subdomain of example.eth will use wildcardResolver
// - sub.example.eth → wildcardResolver
// - www.example.eth → wildcardResolver
// - anything.example.eth → wildcardResolver

IRegistry sub = parentRegistry.getSubregistry("nonexistent");
// sub == IRegistry(address(0))
// No one has registered this name yet

IRegistry sub = parentRegistry.getSubregistry("exists");
// sub == IRegistry(address(0))

address resolver = parentRegistry.getResolver("exists");
// resolver != address(0)
// Name exists but has no subregistry (leaf node)

IRegistry sub = parentRegistry.getSubregistry("exists");
// sub != IRegistry(address(0))
// Name exists and can have children

// Name was registered but expired
IRegistry sub = parentRegistry.getSubregistry("expired");
// sub == IRegistry(address(0))  (treated as non-existent)

uint64 expiry = parentRegistry.getExpiry(tokenId);
// expiry < block.timestamp

// Check if a registry is canonical
function isCanonical(IRegistry rootRegistry, IRegistry registry) 
    public view returns (bool) 
{
    bytes memory constructedName = LibRegistry.findCanonicalName(
        rootRegistry, 
        registry
    );
    return constructedName.length > 0;
}

// Original registry
IRegistry oldRegistry = parentRegistry.getSubregistry("sub");

// Parent changes the pointer
parentRegistry.setSubregistry(tokenId, newRegistry);

// oldRegistry is now non-canonical
// It still exists but is disconnected from the hierarchy

// Deploy one registry contract
PermissionedRegistry sharedRegistry = new PermissionedRegistry(...);

// Use it for multiple names
ethRegistry.register("alice", owner1, sharedRegistry, resolver1, roles1, expiry1);
ethRegistry.register("bob", owner2, sharedRegistry, resolver2, roles2, expiry2);

// ⚠️ WARNING: This is usually NOT what you want!
// Both names would share the same subdomain namespace

// Initially register without subregistry
registry.register("name", owner, IRegistry(address(0)), resolver, roles, expiry);

// Later, if subdomains are needed:
IRegistry newSubregistry = new PermissionedRegistry(...);
registry.setSubregistry(tokenId, newSubregistry);

interface IRegistryFactory {
    function createRegistry(
        address owner,
        uint256 roles
    ) external returns (IRegistry);
}

// Predictable registry creation
IRegistry registry = factory.createRegistry(owner, roles);

function getFullPath(IRegistry registry, IRegistry root) 
    public view returns (string[] memory) 
{
    string[] memory labels = new string[](10);  // Max depth
    uint256 count = 0;
    
    IRegistry current = registry;
    while (address(current) != address(0) && address(current) != address(root)) {
        (IRegistry parent, string memory label) = current.getParent();
        labels[count++] = label;
        current = parent;
    }
    
    // Reverse and trim array
    return _reverseAndTrim(labels, count);
}

function resolveToRegistry(IRegistry root, string[] memory labels) 
    public view returns (IRegistry) 
{
    IRegistry current = root;
    
    for (uint256 i = labels.length; i > 0; i--) {
        current = current.getSubregistry(labels[i - 1]);
        if (address(current) == address(0)) {
            return IRegistry(address(0));  // Path doesn't exist
        }
    }
    
    return current;
}