lib.nix

{lib}: rec {
  # Take an attrset of arbitrary nesting and make it flat
  # by concatenating the nested names with the given separator.
  flattenAttrs = separator: let
    f = path: lib.concatMapAttrs (flatten path);
    flatten = path: name: value:
      if lib.isAttrs value
      then f (path + name + separator) value
      else {${path + name} = value;};
  in
    f "";

  /*
    *
  Convert number of seconds in the Unix epoch to a Gregorian calendar date and time

  This does not take into account leap seconds, which would require a table lookup.
  */
  datetime-from-timestamp = timestamp: let
    remainder = x: y: x - x / y * y;
    seconds-per-day = 86400;
    day-of-epoch = timestamp / seconds-per-day;
    seconds-of-day = remainder timestamp seconds-per-day;
    hours = seconds-of-day / 3600;
    minutes = (remainder seconds-of-day 3600) / 60;
    seconds = remainder timestamp 60;

    # Courtesy of http://howardhinnant.github.io/date_algorithms.html via https://stackoverflow.com/a/32158604
    day' = day-of-epoch + 719468; # internal representation of days, based on number of days between 0000-03-01 and 1970-01-01
    days-per-era = 146097;
    era =
      # 400-year interval of the Gregorian calendar
      (
        if day' >= 0
        then day'
        else day' - (days-per-era - 1)
      )
      / days-per-era;
    day-of-era = day' - era * days-per-era;
    year-of-era = (day-of-era - day-of-era / 1460 + day-of-era / 36524 - day-of-era / (days-per-era - 1)) / 365;
    year' = year-of-era + era * 400; # internal representation of years
    day-of-year = day-of-era - (365 * year-of-era + year-of-era / 4 - year-of-era / 100);
    month' = (5 * day-of-year + 2) / 153; # internal representation of months
    day = day-of-year - (153 * month' + 2) / 5 + 1;
    month =
      month'
      + (
        if month' < 10
        then 3
        else -9
      );
    year =
      year'
      + (
        if month <= 2
        then 1
        else 0
      );
  in {
    inherit year month day hours minutes seconds;
  };

  # Format number of seconds in the Unix epoch as %Y%m%d%H%M%S.
  format-timestamp = timestamp: let
    pad = n: s: let
      str = toString s;
    in
      with builtins; concatStringsSep "" (genList (_: "0") (n - stringLength str)) + str;
  in
    with builtins.mapAttrs
    (name: s:
      if name == "year"
      then pad 4 s
      else pad 2 s)
    (datetime-from-timestamp timestamp); "${year}${month}${day}${hours}${minutes}${seconds}";

  /*
    *
  Polyfill for the experimental `builtins.fetchTree`

  https://nix.dev/manual/nix/latest/language/builtins#builtins-fetchTree
  */
  fetchTree = info:
    if info.type == "github"
    then {
      outPath = fetchTarball (
        {url = "https://api.${info.host or "github.com"}/repos/${info.owner}/${info.repo}/tarball/${info.rev}";}
        // (
          if info ? narHash
          then {sha256 = info.narHash;}
          else {}
        )
      );
      rev = info.rev;
      shortRev = builtins.substring 0 7 info.rev;
      lastModified = info.lastModified;
      lastModifiedDate = format-timestamp info.lastModified;
      narHash = info.narHash;
    }
    else if info.type == "git"
    then
      {
        outPath = builtins.fetchGit (
          {
            url = info.url;
            shallow = true;
            allRefs = true;
          }
          // (
            if info ? rev
            then {inherit (info) rev;}
            else {}
          )
          // (
            if info ? submodules
            then {inherit (info) submodules;}
            else {}
          )
        );
        lastModified = info.lastModified;
        lastModifiedDate = format-timestamp info.lastModified;
        narHash = info.narHash;
      }
      // (
        if info ? rev
        then {
          rev = info.rev;
          shortRev = builtins.substring 0 7 info.rev;
        }
        else {}
      )
    else if info.type == "path"
    then {
      outPath = builtins.path {
        path =
          if builtins.substring 0 1 info.path != "/"
          # XXX: relative paths require an additional `root` attribute!
          #      this is supplied by our own flake-inputs, but may not work elsewhere
          then "${info.root}/${info.path}"
          else info.path;
      };
      narHash = info.narHash;
    }
    else if info.type == "tarball"
    then {
      outPath = fetchTarball (
        {inherit (info) url;}
        // (
          if info ? narHash
          then {sha256 = info.narHash;}
          else {}
        )
      );
    }
    else if info.type == "gitlab"
    then {
      inherit (info) rev narHash lastModified;
      outPath = fetchTarball (
        {url = "https://${info.host or "gitlab.com"}/api/v4/projects/${info.owner}%2F${info.repo}/repository/archive.tar.gz?sha=${info.rev}";}
        // (
          if info ? narHash
          then {sha256 = info.narHash;}
          else {}
        )
      );
      shortRev = builtins.substring 0 7 info.rev;
    }
    # TODO: Mercurial, tarball inputs, ...
    else throw "flake input has unsupported input type '${info.type}'";

  /*
  *
  Compatibility layer to allow `flake.lock` files to be used with stable Nix.

  Modified from https://github.com/nix-community/dream2nix/blob/main/dev-flake/flake-compat.nix
  https://github.com/nix-community/flake-compat is not actively maintained
  */
  flake-inputs = {
    root,
    overrides ? {},
  }: let
    lockFilePath = root + "/flake.lock";
    lockFile = builtins.fromJSON (builtins.readFile lockFilePath);

    tree = let
      # Try to clean the source tree by using fetchGit, if this source
      # tree is a valid git repository.
      tryFetchGit = src:
        if isGit && !isShallow
        then let
          res = builtins.fetchGit src;
        in
          if res.rev == "0000000000000000000000000000000000000000"
          then removeAttrs res ["rev" "shortRev"]
          else res
        else {outPath = src;};
      # NB git worktrees have a file for .git, so we don't check the type of .git
      isGit = builtins.pathExists (root + "/.git");
      isShallow = builtins.pathExists (root + "/.git/shallow");
    in
      {
        lastModified = 0;
        lastModifiedDate = format-timestamp 0;
      }
      // (
        if root ? outPath
        then root
        else tryFetchGit root
      );

    # we can't import those from the Nixpkgs `lib`,
    # since flake inputs are used to fetch Nixpkgs to begin with
    nameValuePair = name: value: {inherit name value;};
    mapAttrs' = f: set:
      builtins.listToAttrs (map (attr: f attr set.${attr}) (builtins.attrNames set));

    rootOverrides =
      mapAttrs'
      (input: lockKey': let
        lockKey =
          if builtins.isList lockKey'
          then builtins.concatStringsSep "/" lockKey'
          else lockKey';
      in
        nameValuePair lockKey (overrides.${input} or null))
      lockFile.nodes.${lockFile.root}.inputs;

    allNodes =
      builtins.mapAttrs
      (
        key: node: let
          sourceInfo =
            if key == lockFile.root
            then tree
            else if rootOverrides.${key} or null != null
            then {
              type = "path";
              outPath = rootOverrides.${key};
              narHash = throw "flake-inputs: overriding narHash not implemented";
            }
            else fetchTree (node.info or {} // removeAttrs node.locked ["dir"] // {inherit root;});

          inputs =
            builtins.mapAttrs
            (_inputName: inputSpec: allNodes.${resolveInput inputSpec})
            (node.inputs or {});

          # Resolve a input spec into a node name.
          # An input spec is either a node name, or a 'follows' path from the root node.
          resolveInput = inputSpec:
            if builtins.isList inputSpec
            then getInputByPath lockFile.root inputSpec
            else inputSpec;

          # Follow an input path (e.g. ["dwarffs" "nixpkgs"]) from the root node, returning the final node.
          getInputByPath = nodeName: path:
            if path == []
            then nodeName
            else
              getInputByPath
              # Since this could be a 'follows' input, call resolveInput.
              (resolveInput lockFile.nodes.${nodeName}.inputs.${builtins.head path})
              (builtins.tail path);
        in
          sourceInfo
          // {
            inherit inputs;
            inherit sourceInfo;
            _type = "flake";
          }
      )
      lockFile.nodes;
  in
    if lockFile.version >= 5 && lockFile.version <= 7
    then
      allNodes.${lockFile.root}
      // {
        overrideInputs = ov:
          flake-inputs {
            inherit root;
            overrides = ov;
          };
      }
    else throw "flake-inputs: lock file '${lockFilePath}' has unsupported version ${toString lockFile.version}";
}