nixos-config/flake.nix

{
  description = "System config";

  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";

    home-manager = {
      url = "github:nix-community/home-manager";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    flake-utils.url = "github:numtide/flake-utils";

    nixos-generators = {
      url = "github:nix-community/nixos-generators";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    naersk = {
      url = "github:nix-community/naersk";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    rust-overlay = {
      url = "github:oxalica/rust-overlay";
      inputs.nixpkgs.follows = "nixpkgs";
      inputs.flake-utils.follows = "flake-utils";
    };

    sops = {
      url = "github:Mic92/sops-nix";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    emacs-overlay = {
      url = "github:nix-community/emacs-overlay";
      inputs.nixpkgs.follows = "nixpkgs";
      inputs.flake-utils.follows = "flake-utils";
    };

    cq-flake = {
      url = "github:marcus7070/cq-flake";
      inputs.nixpkgs.follows = "nixpkgs";
      inputs.flake-utils.follows = "flake-utils";
    };

    ha-now-playing = {
      url = "git+https://git.datarift.nl/erwin/ha-now-playing.git?ref=main";
      inputs.nixpkgs.follows = "nixpkgs";
      inputs.utils.follows = "flake-utils";
      inputs.naersk.follows = "naersk";
      inputs.rust-overlay.follows = "rust-overlay";
    };

    pamedia = {
      url = "git+https://git.datarift.nl/erwin/pamedia-rs.git?ref=main";
      inputs.nixpkgs.follows = "nixpkgs";
      inputs.utils.follows = "flake-utils";
      inputs.naersk.follows = "naersk";
    };
  };

  outputs =
    { self
    , sops
    , ha-now-playing
    , pamedia
    , ...
    } @ inputs:
      with inputs; let
        defSystem = system: baseConfig:
          nixpkgs.lib.nixosSystem {
            system = "${system}";
            modules = [
              { _module.args.inputs = inputs; }
              { _module.args.self-overlay = self.overlays.default; }
              ({ ... }: {
                imports =
                  builtins.attrValues self.nixosModules
                  ++ [
                    {
                      nix.nixPath = [ "nixpkgs=${nixpkgs}" ];
                      nixpkgs.overlays = [
                        self.overlays.default
                        ha-now-playing.overlays.${system}
                        pamedia.overlays.${system}
                      ];
                    }

                    baseConfig
                    home-manager.nixosModules.home-manager
                    { home-manager.useUserPackages = true; }
                  ];

                system.configurationRevision = nixpkgs.lib.mkIf (self ? rev) self.rev;
                nix.registry.nixpkgs.flake = nixpkgs;
              })
              sops.nixosModules.sops
            ];
          };

        defContainer = system: baseConfig:
          nixos-generators.nixosGenerate {
            pkgs = nixpkgs.legacyPackages.${system};
            format = "proxmox-lxc";
            modules = [
              { _module.args.inputs = inputs; }
              { _module.args.self-overlay = self.overlay; }
              ({ ... }: {
                imports =
                  builtins.attrValues self.nixosModules
                  ++ [
                    {
                      nix.nixPath = [ "nixpkgs=${nixpkgs}" ];
                      nixpkgs.overlays = [
                        self.overlay
                        ha-now-playing.overlays.${system}
                        pamedia.overlays.${system}
                      ];
                    }

                    baseConfig
                    home-manager.nixosModules.home-manager
                    { home-manager.useUserPackages = true; }
                  ];

                system.configurationRevision = nixpkgs.lib.mkIf (self ? rev) self.rev;
                nix.registry.nixpkgs.flake = nixpkgs;
              })
              sops.nixosModules.sops
            ];
          };
      in
      {
        overlays.default = import ./overlays;
        # overlay = final: prev: {
        #   unstable = import nixpkgs {
        #     system = "x86_64-linux";
        #     config.allowUnfree = true;
        #   };
        # };

        nixosModules = builtins.listToAttrs (map
          (x: {
            name = x;
            value = import (./modules + "/${x}");
          })
          (builtins.attrNames (builtins.readDir ./modules)));

        nixosConfigurations = {
          vm1 = defSystem "x86_64-linux" {
            imports = [
              (import ./machines/vm1/configuration.nix { inherit self; })
            ];
          };
          vm2 = defSystem "x86_64-linux" {
            imports = [
              (import ./machines/vm2/configuration.nix { inherit self; })
            ];
          };

          loki = defSystem "x86_64-linux" {
            imports = [
              (import ./machines/loki/configuration.nix { inherit self nixpkgs; })
            ];
          };

          drone = defSystem "x86_64-linux" {
            imports = [
              (import ./machines/drone/configuration.nix { inherit self; })
            ];
          };

          proxy = defSystem "x86_64-linux" {
            imports = [
              (import ./machines/proxy/configuration.nix { inherit self; })
            ];
          };

          gitea = defSystem "x86_64-linux" {
            imports = [
              (import ./machines/gitea/configuration.nix { inherit self; })
            ];
          };
        };

        nixosContainers = {
          drone = defContainer "x86_64-linux" {
            imports = [
              (import ./machines/drone/configuration.nix { inherit self; })
            ];
          };

          proxy = defContainer "x86_64-linux" {
            imports = [
              (import ./machines/proxy/configuration.nix { inherit self; })
            ];
          };

          gitea = defContainer "x86_64-linux" {
            imports = [
              (import ./machines/gitea/configuration.nix { inherit self; })
            ];
          };
        };
      }
      // (flake-utils.lib.eachSystem [ "aarch64-linux" "x86_64-linux" ])
        (
          system:
          let
            pkgs = import nixpkgs {
              inherit system;
              overlays = [
                self.overlays.default
                ha-now-playing.overlays.${system}
                pamedia.overlays.${system}
              ];
              config = {
                allowUnsupportedSystem = true;
                allowUnfree = true;
              };
            };
          in
          rec {
            packages = flake-utils.lib.flattenTree {
              rofi-wayland = pkgs.rofi-wayland;
              nix-plugins = pkgs.nix-plugins;
              backscrub = pkgs.backscrub;
            };

            apps = {
              rofi-wayland = flake-utils.lib.mkApp { drv = packages.rofi-wayland; };
              nix-plugins = flake-utils.lib.mkApp { drv = packages.nix-plugins; };
              backscrub = flake-utils.lib.mkApp { drv = packages.backscrub; };
            };

            devShells.default = with pkgs;
              mkShell {
                nativeBuildInputs = [
                  pkgs.sops
                  ssh-to-pgp
                ];
              };

            formatter = pkgs.nixpkgs-fmt;
          }
        );
}