system/flake.nix

{
  inputs = {
    flake-utils.url = "github:numtide/flake-utils";
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.11";
    nixpkgs-unstable.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
    hardware.url = "github:NixOS/nixos-hardware/master";
    impermanence.url = "github:nix-community/impermanence";
    disko = {
      url = "github:nix-community/disko";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    firefox-addons.url = "github:nix-community/nur-combined/master?dir=repos/rycee/pkgs/firefox-addons";

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

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

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

    wired = {
      url = "github:Toqozz/wired-notify";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    lan-mouse = {
      url = "github:feschber/lan-mouse";
      inputs.nixpkgs.follows = "nixpkgs-unstable";
    };

    # nix lsp
    nil = {
      url = "github:oxalica/nil";
      inputs.nixpkgs.follows = "nixpkgs";
      inputs.flake-utils.follows = "flake-utils";
    };

    # my neovim configuration
    nixeovim = {
      url = "git+https://git.pleshevski.ru/pleshevskiy/nixeovim";
      inputs.nixpkgs.follows = "nixpkgs-unstable";
      inputs.flake-utils.follows = "flake-utils";
    };
  };

  outputs = { self, flake-utils, nixpkgs, nixeovim, ... } @ inputs:
    let
      inherit (nixpkgs) lib;

      inherit (flake-utils.lib) eachSystem;
      inherit (flake-utils.lib.system) x86_64-linux x86_64-darwin;

      hosts = (import ./hosts inputs);
      linuxMachines = lib.filterAttrs
        (hostname: { system, ... }: system == x86_64-linux)
        hosts;

      darwinMachines = lib.filterAttrs
        (hostname: { system, ... }: system == x86_64-darwin)
        hosts;

      baseSpecialArgs = {
        inherit inputs;
        globalData = import ./data.nix;
        usersPath = ./users;
        hostsPath = ./hosts;
        packagesPath = ./packages;
        sharedPath = ./shared;
      };

      mkDeploymentModule = { targetHost, system, ... }: ({ lib, ... }: {
        options.deployment = with lib; {
          system = mkOption {
            type = types.str;
            readOnly = true;
            internal = true;
          };
          targetHost = mkOption {
            type = types.nullOr types.str;
            readOnly = true;
            internal = true;
          };
        };
        config.deployment = { inherit targetHost system; };
      });

      baseHomeManagerModule = ({ ... }: {
        home-manager.backupFileExtension = "backup";
        home-manager.useGlobalPkgs = true;
        home-manager.useUserPackages = true;
        home-manager.extraSpecialArgs = baseSpecialArgs;
        home-manager.sharedModules = [
          {
            imports = [
              ./modules/home-manager
              inputs.wired.homeManagerModules.default
              inputs.lan-mouse.homeManagerModules.default
            ];
          }
        ];
      });

      baseDarwinModule = system: ({ ... }: {
        system.stateVersion = 5;
        system.configurationRevision = self.rev or self.dirtyRev or null;
        nixpkgs.hostPlatform = system;
      });
    in
    eachSystem [ x86_64-linux x86_64-darwin ]
      (system:
        let
          pkgs = import nixpkgs { inherit system; };

          machineRebuild = machine:
            if machine.config.deployment.system == x86_64-linux
            then pkgs.nixos-rebuild
            else inputs.nix-darwin.packages.${x86_64-darwin}.darwin-rebuild;

          nixeovimPackage = config: nixeovim.lib.mkNixeovimPackage { inherit system config; };

          localMachines = lib.filterAttrs
            (h: m: m.config.deployment.targetHost == null)
            (self.nixosConfigurations // self.darwinConfigurations);
          vpsMachines = lib.filterAttrs
            (h: m: m.config.deployment.targetHost != null)
            self.nixosConfigurations;
        in
        {
          packages = {
            neovim-dev = nixeovimPackage ./neovim/dev.nix;
          };

          apps = lib.mapAttrs
            (name: program: { type = "app"; program = toString program; })
            (flake-utils.lib.flattenTree {
              deploy = lib.recurseIntoAttrs (lib.mapAttrs
                (hostname: machine: pkgs.writeShellScript "deploy/${hostname}" ''
                  ${lib.getExe (machineRebuild machine)} switch \
                    --flake .#${hostname} \
                    ${lib.optionalString (system != machine.system) ''--build-host root@${machine.config.deployment.targetHost} \''}
                    --target-host root@${machine.config.deployment.targetHost} \
                    $@
                '')
                vpsMachines);

              switch = lib.recurseIntoAttrs (lib.mapAttrs
                (hostname: machine:
                  pkgs.writeShellScript "switch/${hostname}" ''
                    set -e
                    ${lib.getExe (machineRebuild machine)} switch --flake .#${hostname} $@
                  '')
                localMachines);
            });

          devShells = {
            default = pkgs.mkShell {
              packages = with pkgs; [
                stylua # lua formatter
                ormolu # haskell formatter
                inputs.agenix.packages.${system}.agenix
              ];

              # Path to the agenix configuration file
              RULES = "./.agenix_config.nix";
            };
            disk = pkgs.mkShell {
              packages = [
                inputs.disko.packages.${system}.disko
              ];
            };
            tools = pkgs.mkShell {
              packages = with pkgs; [
                mkpasswd
                gucharmap
                wireguard-tools
              ];
            };
          };
        })
    // {
      nixosConfigurations =
        lib.mapAttrs
          (hostname: { system
                     , specialArgs ? { }
                     , extraModules ? [ ]
                     , targetHost ? null
                     , nixpkgs ? inputs.nixpkgs
                     }:
            nixpkgs.lib.nixosSystem {
              inherit system;

              specialArgs = baseSpecialArgs // specialArgs;

              modules =
                (with inputs; [
                  agenix.nixosModules.default
                  home-manager.nixosModules.default
                  disko.nixosModules.disko
                  impermanence.nixosModules.impermanence
                ])
                ++ [
                  (mkDeploymentModule { inherit system targetHost; })
                  baseHomeManagerModule
                ]
                ++ extraModules
                ++ [ ./modules/nixos ]
                ++ [ ./hosts/${hostname}/configuration.nix ];
            })
          linuxMachines;

      darwinConfigurations =
        lib.mapAttrs
          (hostname: { system
                     , specialArgs ? { }
                     , extraModules ? [ ]
                     , targetHost ? null
                     }:
            inputs.nix-darwin.lib.darwinSystem {
              specialArgs = baseSpecialArgs // specialArgs;

              modules =
                (with inputs; [
                  agenix.darwinModules.default
                  home-manager.darwinModules.default
                ])
                ++ [
                  (baseDarwinModule system)
                  (mkDeploymentModule { inherit system targetHost; })
                  baseHomeManagerModule
                ]
                ++ extraModules
                ++ [ ./hosts/${hostname}/configuration.nix ];
            })
          darwinMachines;

      diskoConfigurations = {
        asus-gl553vd = import ./hosts/asus-gl553vd/disk-config.nix;
        home = import ./hosts/home/disk-config.nix;
      };
    };
}