flake.nix

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

    catppuccin = {
      url = "github:catppuccin/nix";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    darwin = {
      url = "github:lnl7/nix-darwin/master";
      inputs.nixpkgs.follows = "nixpkgs";
    };

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

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

    agenix = {
      url = "github:ryantm/agenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    nixvim = {
      url = "github:nix-community/nixvim";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };
  outputs = {
    self,
    nixpkgs,
    darwin,
    home-manager,
    disko,
    agenix,
    ...
  } @ inputs:
    {
      darwinConfigurations = {
        "toaster" = darwin.lib.darwinSystem {
          system = "x86_64-darwin";
          modules = [
            self.darwinModules.default
            home-manager.darwinModules.home-manager
          ];
          specialArgs = {inherit inputs;};
        };
        "heater" = darwin.lib.darwinSystem {
          system = "aarch64-darwin";
          modules = [
            ./hosts/heater/configuration.nix
            self.darwinModules.default
            self.darwinModules.work
            home-manager.darwinModules.home-manager
          ];
          specialArgs = {inherit inputs;};
        };
        "lamp" = darwin.lib.darwinSystem {
          system = "aarch64-darwin";
          modules = [
            ./hosts/lamp/configuration.nix
            self.darwinModules.default
            self.darwinModules.work
            self.darwinModules.linux-builder
            home-manager.darwinModules.home-manager
          ];
          specialArgs = {inherit inputs;};
        };
      };

      nixosConfigurations = {
        "blender" = nixpkgs.lib.nixosSystem {
          system = "x86_64-linux";
          modules = [
            ./hosts/blender/configuration.nix
            self.nixosModules.default
            disko.nixosModules.disko
            agenix.nixosModules.default
          ];
          specialArgs = {inherit inputs;};
        };

        "qraspi" = nixpkgs.lib.nixosSystem {
          system = "aarch64-linux";
          modules = [
            ./hosts/qraspi/configuration.nix
            ./modules/nixos/adguard-home.nix
            self.nixosModules.minimal
            agenix.nixosModules.default
          ];
          specialArgs = {inherit inputs;};
        };

        "wraspi" = nixpkgs.lib.nixosSystem {
          system = "aarch64-linux";
          modules = [
            ./hosts/wraspi/configuration.nix
            ./modules/nixos/adguard-home.nix
            self.nixosModules.minimal
            agenix.nixosModules.default
          ];
          specialArgs = {inherit inputs;};
        };

        "mixer" = nixpkgs.lib.nixosSystem {
          system = "x86_64-linux";
          modules = [
            disko.nixosModules.disko
            agenix.nixosModules.default
            self.nixosModules.minimal
            ./hosts/mixer/configuration.nix
          ];
          specialArgs = {inherit inputs;};
        };

        "k8s-lab" = nixpkgs.lib.nixosSystem {
          system = "x86_64-linux";
          modules = [
            disko.nixosModules.disko
            agenix.nixosModules.default
            self.nixosModules.minimal
            ./hosts/k8s-lab/configuration.nix
          ];
          specialArgs = {inherit inputs;};
        };

        "github-runner" = nixpkgs.lib.nixosSystem {
          system = "x86_64-linux";
          modules = [
            disko.nixosModules.disko
            agenix.nixosModules.default
            self.nixosModules.minimal
            ./hosts/github-runner/configuration.nix
          ];
          specialArgs = {inherit inputs;};
        };

        "fridge" = nixpkgs.lib.nixosSystem {
          system = "x86_64-linux";
          modules = [
            disko.nixosModules.disko
            agenix.nixosModules.default
            self.nixosModules.minimal
            ./hosts/fridge/configuration.nix
          ];
          specialArgs = {inherit inputs;};
        };

        "db-1" = nixpkgs.lib.nixosSystem {
          system = "x86_64-linux";
          modules = [
            disko.nixosModules.disko
            agenix.nixosModules.default
            self.nixosModules.minimal
            ./hosts/db-1/configuration.nix
          ];
          specialArgs = {inherit inputs;};
        };

        "wooper" = nixpkgs.lib.nixosSystem {
          system = "aarch64-linux";
          modules = [
            disko.nixosModules.disko
            agenix.nixosModules.default
            self.nixosModules.default
            ./hosts/wooper/configuration.nix
          ];
          specialArgs = {inherit inputs;};
        };

        "swayvm" = nixpkgs.lib.nixosSystem {
          system = "aarch64-linux";
          modules = [
            ./hosts/swayvm/configuration.nix
            ./modules/nixos/home-manager.nix
            self.nixosModules.minimal
          ];
          specialArgs = {inherit inputs;};
        };

        "headlessvm" = nixpkgs.lib.nixosSystem {
          system = "aarch64-linux";
          modules = [
            ./hosts/headlessvm/configuration.nix
            ./modules/nixos/home-manager.nix
            self.nixosModules.minimal
          ];
          specialArgs = {inherit inputs;};
        };

        "live" = nixpkgs.lib.nixosSystem {
          system = "x86_64-linux";
          modules = [
            "${nixpkgs}/nixos/modules/installer/cd-dvd/installation-cd-minimal.nix"
            {
              users.users.root.openssh.authorizedKeys.keys = self.users.marco.ssh.publicKeys;
            }
          ];
          # specialArgs = { inherit inputs; };
        };
      };

      nixosModules = {
        default = ./modules/nixos/base/default.nix;
        minimal = ./modules/nixos/base/minimal.nix;
        sdImage = {lib, ...}: {
          imports = ["${nixpkgs}/nixos/modules/installer/sd-card/sd-image-aarch64.nix"];
          boot.supportedFilesystems.zfs = lib.mkForce false;
        };
      };

      darwinModules = {
        default = ./modules/darwin/base/default.nix;
        work = ./modules/darwin/work/default.nix;
        linux-builder = ./modules/darwin/linux-builder.nix;
      };

      homeConfigurations = let
        codebergMirrors = final: prev: {
          vimPlugins =
            prev.vimPlugins
            // nixpkgs.lib.genAttrs ["nvim-lint" "nvim-dap" "nvim-dap-python"] (name:
              prev.vimPlugins.${name}.overrideAttrs (old: {
                src = old.src.overrideAttrs (_: {
                  url = "https://github.com/mfussenegger/${name}";
                });
              }));
        };
      in
        nixpkgs.lib.genAttrs ["x86_64-linux" "aarch64-linux"] (system: {
          default = home-manager.lib.homeManagerConfiguration {
            pkgs = import nixpkgs {
              inherit system;
              config.allowUnfree = true;
              overlays = [codebergMirrors];
            };
            extraSpecialArgs = {inherit inputs;};
            modules = [
              ./modules/home-manager/base/default.nix
              ({pkgs, ...}: {
                home.username = "dev";
                home.homeDirectory = "/home/dev";
                nix.package = pkgs.nix;
                nix.settings.sandbox = false;
                programs.bash.enable = true;
              })
            ];
          };
        });

      images = {
        qraspi =
          (self.nixosConfigurations.qraspi.extendModules {
            modules = [self.nixosModules.sdImage];
          }).config.system.build.sdImage;

        wraspi =
          (self.nixosConfigurations.wraspi.extendModules {
            modules = [self.nixosModules.sdImage];
          }).config.system.build.sdImage;

        live = self.nixosConfigurations.live.config.system.build.isoImage;
      };

      users = import ./users.nix;
    }
    // (
      let
        systems = [
          "x86_64-linux"
          "aarch64-linux"
          "x86_64-darwin"
          "aarch64-darwin"
        ];
      in {
        formatter = nixpkgs.lib.genAttrs systems (
          system:
            nixpkgs.legacyPackages.${system}.alejandra
        );

        packages = nixpkgs.lib.genAttrs systems (system:
          {
            docs = import ./lib/docs {
              pkgs = nixpkgs.legacyPackages.${system};
              inherit (nixpkgs) lib;
              inherit inputs;
            };
          }
          // nixpkgs.lib.optionalAttrs (system == "aarch64-darwin") {
            swayvm = self.nixosConfigurations.swayvm.config.system.build.vm;
            headlessvm = self.nixosConfigurations.headlessvm.config.system.build.vm;
          });

        apps = nixpkgs.lib.genAttrs systems (system: let
          pkgs = nixpkgs.legacyPackages.${system};
        in {
          docs = {
            type = "app";
            meta.description = "Regenerate docs/ from the flake";
            program = nixpkgs.lib.getExe (pkgs.writeShellApplication {
              name = "docs";
              runtimeInputs = [pkgs.git];
              text = ''
                root=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
                mkdir -p "$root/docs"
                for f in ${self.packages.${system}.docs}/*; do
                  install -m 644 "$f" "$root/docs/$(basename "$f")"
                  echo "wrote docs/$(basename "$f")"
                done
              '';
            });
          };
        });
      }
    );
}