samey/default.nix

let
  inherit (import ./npins)
    nixpkgs
    rust-overlay
    ;
  currentPkgs = import nixpkgs {
    overlays = [ (import rust-overlay) ];
  };
  inherit (currentPkgs) lib stdenv;

  crate-info = fromTOML (builtins.readFile ./Cargo.toml);
  pname = crate-info.package.name;
  version = crate-info.package.version;

  docker-image = "badmanners/${pname}";
  cargo-deps-hash = "sha256-PD/ZR/sdmqA18xcOi9AnwQtDYVyELPS6GBF/pzcJzkE=";
  cargo-src = lib.fileset.toSource {
    root = ./.;
    fileset = lib.fileset.unions [
      ./Cargo.toml
      ./Cargo.lock
    ];
  };
  src = lib.fileset.toSource {
    root = ./.;
    fileset = lib.fileset.unions [
      ./Cargo.toml
      ./Cargo.lock
      ./src
      ./migration/Cargo.toml
      ./migration/src
      ./static
      ./templates
    ];
  };

  archs = {
    amd64 = {
      system = "x86_64-linux";
      pkgs = import nixpkgs {
        localSystem = "x86_64-linux";
      };
      tag = "latest-amd64";
      targetTriple = "x86_64-unknown-linux-musl";
    };
    arm64 = {
      system = "aarch64-linux";
      pkgs = import nixpkgs {
        localSystem = "aarch64-linux";
      };
      tag = "latest-arm64";
      targetTriple = "aarch64-unknown-linux-musl";
    };
  };

  rust-bin = currentPkgs.rust-bin.stable.latest.default.override {
    targets = [
      "x86_64-unknown-linux-musl"
      "aarch64-unknown-linux-musl"
    ];
  };

  mkRustPkg =
    targetTriple:
    stdenv.mkDerivation {
      inherit
        pname
        version
        src
        ;

      cargoDeps = currentPkgs.rustPlatform.fetchCargoVendor {
        src = cargo-src;
        hash = cargo-deps-hash;
      };

      nativeBuildInputs = [
        currentPkgs.rustPlatform.cargoSetupHook
        currentPkgs.zig
        rust-bin
      ];

      buildPhase = ''
        export HOME=$(mktemp -d)
        ${currentPkgs.cargo-zigbuild}/bin/cargo-zigbuild zigbuild --release --target ${targetTriple}
      '';

      installPhase = ''
        mkdir -p $out/bin
        cp ./target/${targetTriple}/release/${pname} $out/bin/
      '';
    };

  mkDocker =
    {
      system,
      pkgs,
      tag,
      targetTriple,
    }:
    let
      pkgs-cross =
        if system == builtins.currentSystem then
          currentPkgs
        else
          (import nixpkgs {
            crossSystem = system;
          });
      rust-package = mkRustPkg targetTriple;
    in
    pkgs-cross.dockerTools.buildLayeredImage {
      name = docker-image;
      inherit tag;
      contents = [
        pkgs.ffmpeg-headless
      ];
      config.Entrypoint = [
        "${rust-package}/bin/${pname}"
      ];
    };

  currentTargetTriple =
    (lib.lists.findFirst (arch: arch.system == builtins.currentSystem) {
      targetTriple = throw "Unknown current system ${builtins.currentSystem}";
    } (lib.attrValues archs)).targetTriple;
in
{
  samey = mkRustPkg currentTargetTriple;
  docker-amd64 = mkDocker archs.amd64;
  docker-arm64 = mkDocker archs.arm64;
}