let
  sources = import ../npins;
  inherit (import ../default.nix { }) pkgs inputs;
  inherit (pkgs) lib;
  inherit (lib) mkOption types;
  eval =
    module:
    (lib.evalModules {
      specialArgs = {
        inherit inputs;
      };
      modules = [
        module
        ./data-model.nix
      ];
    }).config;
  nixops4Deployment = inputs.nixops4.modules.nixops4Deployment.default;
  contracts = pkgs.callPackage "${sources.selfhostblocks}/modules/contracts" { };
  inherit (inputs.nixops4.lib) mkDeployment;
in
{
  _class = "nix-unit";

  test-eval = {
    expr =
      let
        fediversity = eval (
          { config, ... }:
          {
            config = {
              resources.backup = {
                description = "handle SelfHostBlocks backup requests";
                request =
                  { ... }:
                  {
                    _class = "fediversity-resource-request";
                    options = {
                      req = mkOption {
                        type = contracts.backup.contract.request;
                      };
                    };
                  };
                policy =
                  { config, ... }:
                  {
                    _class = "fediversity-resource-policy";
                    options = {
                      block = mkOption {
                        description = ''
                          the environment's SHB implementation handling back-up requests,
                          using any of: https://shb.skarabox.com/contracts-backup.html#contract-backup-providers.
                          takes the form of a function from a request to NixOS configuration handling the back-up request.
                        '';
                        type = types.functionTo types.raw;
                      };
                    };
                    config = {
                      resource-type = types.raw; # TODO: splice out the user type from NixOS
                      apply =
                        requests:
                        lib.mkMerge (
                          lib.mapAttrsToList (name: request: config.block { inherit name request; }) requests.resources
                        );
                    };
                  };
              };
              applications.bar =
                { ... }:
                {
                  description = "application to test SHB backups";
                  module =
                    { ... }:
                    {
                      options = {
                        enable = lib.mkEnableOption "shb test";
                        backup = mkOption {
                          default = { };
                          type = lib.types.submodule {
                            options = contracts.backup.mkRequester {
                              sourceDirectories = [
                                "/var/lock" # some small dir
                              ];
                            };
                          };
                        };
                        # };
                      };
                    };
                  implementation = cfg: {
                    input = cfg;
                    output = lib.optionalAttrs cfg.enable {
                      resources.hello.req = {
                        inherit (cfg) backup;
                      };
                    };
                  };
                };
              environments.single-nixos-vm =
                { config, ... }:
                {
                  resources.operator-environment.backup.block =
                    { name, request }:
                    {
                      imports = [
                        "${sources.selfhostblocks}/modules/blocks/restic.nix"
                      ];
                      shb.restic.instances.${name} = {
                        inherit request;
                        settings = {
                          enable = true;
                          repository.path = "/srv/backup/restic/fediversity-test/${name}";
                        };
                      };
                    };
                  implementation = requests: {
                    input = requests;
                    output =
                      { providers, ... }:
                      {
                        providers = {
                          inherit (inputs.nixops4.modules.nixops4Provider) local;
                        };
                        resources.the-machine = {
                          type = providers.local.exec;
                          imports = [
                            inputs.nixops4-nixos.modules.nixops4Resource.nixos
                          ];
                          nixos.module = { ... }: config.resources.baz.backup.apply requests;
                        };
                      };
                  };
                };
            };
            options = {
              example-configuration = mkOption {
                type = config.configuration;
                readOnly = true;
                default = {
                  enable = true;
                  applications = {
                    bar = {
                      enable = true;
                    };
                  };
                };
              };
              example-deployment = mkOption {
                type = types.submodule nixops4Deployment;
                readOnly = true;
                default = config.environments.single-nixos-vm.deployment config.example-configuration;
              };
            };
          }
        );
        result = mkDeployment {
          modules = [
            (fediversity.environments.single-nixos-vm.deployment fediversity.example-configuration)
          ];
        };

      in
      {
        deployment = {
          inherit (result) _type;
          deploymentFunction = lib.isFunction result.deploymentFunction;
          getProviders = lib.isFunction result.getProviders;
        };
      };
    expected = {
      deployment = {
        _type = "nixops4Deployment";
        deploymentFunction = true;
        getProviders = true;
      };
    };
  };
}