# An aspect is a collection of many
# Nix configuration modules, each having
# a different `class`.
den.aspects.my-laptop = {
  nixos  = { };
  darwin = { };
  homeManager = { };
  nixVim = { };
  nixDroid = { };

  # aspects can be nested via `provides`
  # forming a tree structure.
  provides.gaming = {
    nixos = { };
    nixDroid = { };

    # aspects can also `include` others
    # forming a graph of dependencies
    includes = [
      # gaming.nixos module will mixin
      # nvidia-gpu.nixos module if any.
      den.aspects.nvidia-gpu
    ];
  };

};

# The convention is to always use named args.
# These required args is the **context** the
# aspect needs to provide configuration.
hostParametric = { host }: {
  nixos.networking.hostName = host.hostName;

  # A parametric aspect can also ask other
  # aspects for context-aware configurations.
  # Here, we ask two other parametric aspects
  # given the `{ host, gaming }` context.
  includes = let 
    context.host = host;
    context.gaming.emulators = [ "nes" ];
  in map (f: f context) [
    den.default
    den.aspects.gaming-platform
  ];
};

{
  # you can assign static values directly.
  den.default.nixos = {
    system.stateVersion = "25.11";
  };

  # you can also include other aspects
  den.default.includes = [
    { darwin.system.stateVersion = 6; }
  ]
}

# This example is split to aid reading.
let
  hasOneUser = host:
    length (attrNames host.users) == 1;
  hasUser = host: user:
    hasAttr user.name host.users;
  makeAdmin = user: {
    nixos.users.users.${user.name} = {
      extraGroups = [ "wheel" ]; 
    };
  };

  # IFF host has ONE user, make it admin
  single-user-is-admin = { host, user }: 
    if hasOneUser host && hasUser host user
    then makeAdmin user else { };
in
{
  den.default.includes = [
    # will be called *ONLY* on when the
    # `{ host, user }` context is used.
    single-user-is-admin
  ];
}

{ den, ... }: {
  den.default.__functor = den.lib.parametric true;
}

{ den, ...}: {
  den.aspects.gaming.__functor = den.lib.parametric true;

  # any other file can register gaming aspects
  den.aspects.gaming.include = [
    ({ emulation }: {
      nixos = ...;
      includes = [ den.aspects.steam ];
    })

    { nixos = ...; } # always included
    ({ gpu }: { }) # non-match on my-laptop
  ];

  # then you can depend on the gaming aspect:
  den.aspects.my-laptop.includes = [ 
    (den.aspects.gaming { emulation = "neogeo"; })
  ];

}

# modules/namespace.nix
{ config, ... }:
{
  den.aspects.vix.provides = { };
  _module.args.vix = # up to provides
    config.den.aspects.vix.provides;
}

# modules/my-laptop.nix
{ vix, ... }:
{
  vix.gaming = {
    _.steam.includes = [ 
      vix.gpu 
      vix.performance-profile 
    ];
  };
}

# modules/routes.nix
{ den, ... }:
let
  noop = _: { };

  by-platform-config = { host }:
    vix.${host.system} or noop;

  user-provides-host-config = { user, host }:
    vix.${user.aspect}._.${host.aspect} or noop;

  host-provides-user-config = { user, host }:
    vix.${host.aspect}._.${user.aspect} or noop;

  route = locator: { user, host }@ctx: 
    (locator ctx) ctx;
in 
{
  den.aspects.routes.__functor = 
    den.lib.parametric true;
  den.aspects.routes.includes = 
    map route [
      user-provides-host-config
      host-provides-user-config
      by-platform-config
    ];
}

{
  # for all darwin hardware
  vix.aarch64-darwin = { host }: {
    darwin = ...; 
  };

  # config bound to vic user 
  # on my-laptop host.
  vix.vic.provides.my-laptop = 
    { host, user }: {
      nixos = ...;
    };
}