{ config, lib, pkgs, ... } @ inputs: {

    imports = let 
        dir = builtins.readDir ./.;
    in builtins.map (x: ./${x}) (builtins.filter 
        (file: (dir.${file} == "directory"))
        (builtins.attrNames dir)
    );
    
    options.sysconfig = with lib; {
        
        sshHostKeys = lib.mkOption {
            type = with lib.types; attrsOf str;
            default = {};
        };

        users = let 

            userType = types.submodule ({ name, ... }: {
                options = with lib; {
                    name = mkOption {
                        type = with types; passwdEntry str;
                        default = name;
                    };

                    home-manager = {
                        enable = mkOption {
                            type = with types; bool;
                            default = false;
                        };

                        standalone = mkOption {
                            type = with types; bool;
                            default = true;
                            description = "is this home-manager standalone?";
                        };

                        extraModules = mkOption {
                            type = with types; listOf raw;
                            default = [];
                        };
                    };

                    isSuperuser = mkOption {
                        type = with types; bool;
                        default = false;
                        description = "sudo?";
                    };
                    
                    usePresets = mkOption {
                        type = with types; bool;
                        default = true;
                        description = "search for predefined settings?";
                    };

                    ssh = {
                        keys = mkOption {
                            type = with types; listOf str;
                            default = [];
                            description = "public keys used to login as this user";
                        };
                        
                        hosts = mkOption {
                            type = with types; listOf str;
                            default = [];
                            description = "user@host's used to login as this user";
                        };
                    };


                    uid = mkOption {
                        type = with types; nullOr int;
                        default = null;
                    };

                    hashedPasswordFile = mkOption {
                        type = with types; nullOr str;
                        default = null;
                    };

                    extraGroups = mkOption {
                        type = with types; listOf str;
                        default = [];
                    };

                    shell = mkOption {
                        type = with types; package;
                        default = pkgs.shadow;
                    };
                };
            });

        in lib.mkOption {
            type = with lib.types; attrsOf userType;
            default = {};
        };
    };


    config = lib.mkIf (config.sysconfig.host != "android") {
        users.users = builtins.mapAttrs (x: y: let
            cfg = config.sysconfig.users.${x};
        in {
            name = cfg.name;
            isNormalUser = true;
            uid = cfg.uid;
            hashedPasswordFile = lib.mkIf (cfg.hashedPasswordFile != null) cfg.hashedPasswordFile;
            shell = cfg.shell;
            extraGroups = cfg.extraGroups ++ (if cfg.isSuperuser then [ "wheel" ] else []);
            openssh.authorizedKeys.keys = lib.mkIf config.sysconfig.services.openssh.enable (cfg.ssh.keys ++ (map (z: config.sysconfig.sshHostKeys.${z}) cfg.ssh.hosts));
            packages = with pkgs; lib.mkIf (cfg.home-manager.enable && cfg.home-manager.standalone) [ home-manager ];
        }) config.sysconfig.users;
  
        programs.fuse.userAllowOther = true;

        home-manager = {
            backupFileExtension = "backup";
            extraSpecialArgs = { inherit inputs; };
            useUserPackages = true;
            sharedModules = [
                inputs.sops-nix.homeManagerModules.sops 
            ];
            users = builtins.listToAttrs (builtins.map 
                (x: { 
                    name = x; 
                    value = (lib.mkMerge ([

                        (if let 
                            dir = builtins.readDir ./.; 
                        in dir ? ${x} && dir.${x} == "directory" then 
                            import ./${x}/home-manager 
                        else {})

                        (if inputs ? ${x} then inputs.${x} else {})

                    ] ++ config.sysconfig.users.${x}.home-manager.extraModules));
                })
                (builtins.filter 
                    (y: (config.sysconfig.users.${y}.home-manager.enable && !config.sysconfig.users.${y}.home-manager.standalone))
                    (builtins.attrNames config.sysconfig.users)
                )
            );
    
        };
    };
}