nixos/flake.nix

{
  description = "Malte Tammena's system configuration";

  inputs = {
    nixpkgs.url = "nixpkgs/nixos-unstable";
    nixos-hardware.url = "github:NixOS/nixos-hardware";
    utils.url = "github:gytis-ivaskevicius/flake-utils-plus";
    custom-udev-rules.url = "github:MalteT/custom-udev-rules";
    nix-colors.url = "github:Misterio77/nix-colors";

    nixpkgs-wayland = {
      url = "github:nix-community/nixpkgs-wayland";
    };
    emulator-2a = {
      url = "github:MalteT/2a-emulator/main";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    mensa = {
      url = "github:MalteT/mensa/main";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    fenix = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    colmena = {
      url = "github:zhaofengli/colmena";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    sops-nix = {
      url = "github:Mic92/sops-nix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    home-manager = {
      url = "github:nix-community/home-manager";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    fend = {
      url = "github:MalteT/fend/flake";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    hydra = {
      url = "github:NixOS/hydra";
      inputs.nixpkgs.follows = "nixForHydra/nixpkgs";
      inputs.nix.follows = "nixForHydra";
    };
    nixForHydra = {
      url = "github:nixos/nix/4acc684ef7b3117c6d6ac12837398a0008a53d85";
      inputs.nixpkgs.follows = "nixpkgsForNixForHydra";
    };
    nixpkgsForNixForHydra = {
      url = "github:NixOS/nixpkgs/04a75b2eecc0acf6239acf9dd04485ff8d14f425";
    };
    hyprland = {
      url = "github:hyprwm/Hyprland";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    xdg-desktop-portal-hyprland = {
      url = "github:hyprwm/xdg-desktop-portal-hyprland";
    };

    rip = {
      url = "github:nivekuil/rip";
      flake = false;
    };
    "2i-emulator" = {
      url = "github:klemens/2i-emulator";
      flake = false;
    };
    "cataclysm-dda" = {
      url = "github:CleverRaven/Cataclysm-DDA";
      flake = false;
    };
    radicale_infcloud = {
      url = "github:Unrud/RadicaleInfCloud";
      flake = false;
    };
    qmk-udev-rules = {
      url = "github:qmk/qmk_firmware";
      flake = false;
    };
    jovian-nixos = {
      url = "github:Jovian-Experiments/Jovian-NixOS";
      flake = false;
    };
  };

  nixConfig = {
    extra-substituters = ["http://cache.home"];
  };

  outputs = {
    self,
    utils,
    nixpkgs,
    nixos-hardware,
    ...
  } @ inputs: let
    pkgs = self.pkgs.x86_64-linux.nixpkgs;

    hosts = [
      "helix-texta"
      "murex-pecten"
      "cornu-aspersum"
      "granodomus-lima"
      "trochulus-hispidus"
      "radix-balthica"
      "faunus-ater"
      "polymita-picta"
    ];

    defaultModules = [
      inputs.home-manager.nixosModules.home-manager
      self.nixosModules.home-manager-config
      inputs.custom-udev-rules.nixosModule
      inputs.sops-nix.nixosModules.sops
      self.nixosModules.nixUnstable
      ./modules/base-system.nix
      {config._module.args.flake = self;}
    ];
  in
    utils.lib.mkFlake {
      inherit self inputs;

      supportedSystems = ["x86_64-linux"];
      nix.generateRegistryFromInputs = true;
      nix.linkInputs = true;

      sharedOverlays = [
        inputs.fenix.overlays.default
        inputs.colmena.overlay
        inputs.xdg-desktop-portal-hyprland.overlays.default
        utils.overlay
        (self: super: {
          # Add fonts
          hackNerdLigatures = super.callPackage ./pkgs/hack.nix {};
          # Add the emulator
          "2a-emulator" =
            inputs.emulator-2a.packages.x86_64-linux."2a-emulator";
          # Add my mensa tool
          inherit (inputs.mensa.packages.x86_64-linux) mensa;
          darkman = super.callPackage ./pkgs/darkman.nix {};
          # TODO: Replace with upstream
          inherit (inputs.fend.packages.x86_64-linux) fend;
          hydra = inputs.hydra.packages.x86_64-linux.default;
          # TODO: Remove once hydra fixes these removed aliases
          inherit (super.perlPackages) buildPerlPackage;
          netcat-openbsd = super.libressl.nc;
        })
        # Override cataclysm to use git
        (import ./overlays/cataclysm-dda.nix)
        (import ./overlays/qmk-udev-rules.nix)
        (import ./overlays/sane-backends.nix)
        (import ./overlays/logisim.nix)
        (import ./overlays/fzf-kak.nix)
        (import ./overlays/prometheus-fritzbox-exporter.nix)
        (import ./overlays/waybar-hypr.nix)
      ];

      hostDefaults.system = "x86_64-linux";
      hostDefaults.modules = defaultModules;

      hosts = builtins.listToAttrs (map (host: {
          name = host;
          value = {modules = [self.nixosModules.${host}];};
        })
        hosts);

      nixosModules = {
        home-manager-config = _: {
          home-manager.verbose = true;
          home-manager.useGlobalPkgs = true;
          home-manager.useUserPackages = true;
          home-manager.extraSpecialArgs = {inherit (inputs) nix-colors;};
        };

        nixUnstable = {pkgs, ...}: {
          nix.registry.nixpkgs.flake = nixpkgs;
          nix.package = pkgs.nixUnstable;
          nix.extraOptions = ''
            experimental-features = nix-command flakes
          '';
        };

        helix-texta = {
          pkgs,
          config,
          ...
        }: {
          imports = [
            ./hosts/helix-texta.nix
            ./modules/light-actkbd.nix
            self.nixosModules.thinkpad-p1-gen3
          ];
        };
        murex-pecten = {...}: {
          imports = [
            nixos-hardware.nixosModules.common-pc
            nixos-hardware.nixosModules.common-pc-ssd
            nixos-hardware.nixosModules.common-cpu-amd
            nixos-hardware.nixosModules.common-gpu-amd
            ./hosts/murex-pecten.nix
            ./hardware/aorus.nix
          ];
        };
        cornu-aspersum = {...}: {
          imports = [
            ./hosts/cornu-aspersum.nix
            ./hardware/netcup-rs-2000-g9.nix
            ./modules/nginx-reverse-proxy.nix
          ];
        };
        granodomus-lima = {...}: {
          imports = [
            ./hosts/granodomus-lima.nix
            ./hardware/netcup-vps-200-g10.nix
            ./modules/nginx-reverse-proxy.nix
          ];
        };
        trochulus-hispidus = {pkgs, ...}: {
          imports = [
            ./hosts/trochulus-hispidus.nix
            ./hardware/latitude-e7440.nix
            nixos-hardware.nixosModules.common-cpu-intel
            nixos-hardware.nixosModules.common-pc-laptop
            nixos-hardware.nixosModules.common-pc-laptop-ssd
          ];
        };
        thinkpad-p1-gen3 = {...}: {
          imports = [
            nixos-hardware.nixosModules.common-cpu-intel
            nixos-hardware.nixosModules.common-gpu-nvidia
            nixos-hardware.nixosModules.common-pc-laptop
            nixos-hardware.nixosModules.common-pc-laptop-ssd
            nixos-hardware.nixosModules.common-pc-laptop-acpi_call
            ./hardware/thinkpad-p1-gen3.nix
          ];
        };
        radix-balthica = {...}: {
          imports = [
            ./hosts/radix-balthica.nix
          ];
        };
        faunus-ater = {...}: {
          imports = [
            nixos-hardware.nixosModules.common-cpu-intel #-cpu-only
            ./modules/nginx-reverse-proxy.nix
            ./hosts/faunus-ater.nix
            ./hardware/asrock-z370-i3-black-box.nix
          ];
        };
        polymita-picta = {...}: {
          imports = [
            ./hosts/polymita-picta.nix
            ./hardware/steam-deck.nix
            (inputs.jovian-nixos + "/modules")
          ];
        };
      };

      colmena =
        {
          meta = {nixpkgs = pkgs;};
          defaults = {...}: {imports = defaultModules;};
        }
        // (builtins.listToAttrs (map (
            host: {
              name = host;
              value = {
                imports = [self.nixosModules.${host}];
                config.deployment = {
                  targetHost = host;
                  targetUser = "root";
                };
              };
            }
          )
          hosts));

      hydraJobs = {
        shell.x86_64-linux = self.devShell.x86_64-linux;
        packages = self.packages;
        nixosConfigurations.x86_64-linux = builtins.listToAttrs (map (host: {
            name = host;
            value = self.nixosConfigurations.${host}.config.system.build.toplevel;
          })
          hosts);
      };

      packages.x86_64-linux.iso = self.nixosConfigurations.radix-balthica.config.system.build.isoImage;
      packages.x86_64-linux.vm = self.nixosConfigurations.radix-balthica.config.system.build.vm;

      outputsBuilder = channels: {
        devShell = channels.nixpkgs.mkShell {
          name = "system config devshell";
          packages = let
            personalCache = pkgs.writeShellApplication {
              name = "personal-cache";
              runtimeInputs = with pkgs; [
                coreutils
                nix
              ];
              text = builtins.readFile ./scripts/personal-cache.sh;
            };

            rebuild = pkgs.writeShellApplication {
              name = "rebuild";
              runtimeInputs = with pkgs; [
                coreutils
                git
                personalCache
                nixos-rebuild
              ];
              text = builtins.readFile ./scripts/rebuild.sh;
            };

            allHosts = pkgs.writeShellApplication {
              name = "all-hosts";
              runtimeInputs = with pkgs; [
                jq
                nix
              ];
              text = ''
                nix eval --json .#nixosConfigurations --apply builtins.attrNames 2>/dev/null | jq -r .[]
              '';
            };

            option = pkgs.writeShellApplication {
              name = "option";
              runtimeInputs = with pkgs; [
                coreutils
                nix
              ];
              text = builtins.readFile ./scripts/option.sh;
            };

            testConfig = pkgs.writeShellApplication {
              name = "test-config";
              runtimeInputs = with pkgs; [
                coreutils
                nix
                allHosts
                nixos-rebuild
                bat
              ];
              text = builtins.readFile ./scripts/test-config.sh;
            };

            git = "${pkgs.git}/bin/git";
            nixos-rebuild = "${pkgs.nixos-rebuild}/bin/nixos-rebuild";
            bat = "${pkgs.bat}/bin/bat";
          in
            with pkgs; [
              rebuild
              personalCache
              allHosts
              option
              testConfig
              inputs.colmena.packages.x86_64-linux.colmena
              fup-repl
              alejandra
              nil
            ];
        };
      };
    };
}