checks.nix

{
  pkgs,
  version,
}:
{
  github-actions = pkgs.stdenv.mkDerivation {
    pname = "scip-github-actions";
    inherit version;
    src = ./.;
    nativeBuildInputs = [
      pkgs.action-validator
      pkgs.git
    ];
    buildPhase = ''
      # action-validator >=0.7 calls `git ls-files` to discover workflows;
      # initialise a throwaway repo so it works inside the Nix sandbox.
      git init -q
      git add -A
      for f in .github/workflows/*.yml .github/workflows/*.yaml; do
        [ -e "$f" ] && action-validator -v "$f"
      done
    '';
    installPhase = "touch $out";
  };

  formatting = pkgs.stdenv.mkDerivation {
    pname = "scip-formatting";
    inherit version;
    src = ./.;
    nativeBuildInputs = with pkgs; [
      buf
      go
      gotools
      nixfmt
      prettier
    ];
    buildPhase = ''
      prettier --check '**/*.{ts,js(on)?,md,yml}'
      BUF_CACHE_DIR=$(mktemp -d) buf format --diff --exit-code scip.proto
      gofmt -d . | tee /dev/stderr | diff /dev/null -
      goimports -d . | tee /dev/stderr | diff /dev/null -
      nixfmt --check *.nix
    '';
    installPhase = "touch $out";
  };

  dotnet-bindings =
    let
      csprojVersion = builtins.head (
        builtins.match ".*<Version>([^<]+)</Version>.*" (builtins.readFile ./bindings/dotnet/Scip.csproj)
      );
    in
    assert pkgs.lib.assertMsg (
      csprojVersion == version
    ) "Version mismatch in bindings/dotnet/Scip.csproj: expected ${version}, got ${csprojVersion}";
    pkgs.buildDotnetModule {
      pname = "scip-bindings-dotnet";
      inherit version;
      src = ./bindings/dotnet;
      projectFile = "Scip.csproj";
      # Regenerate with:
      #   nix build .#checks.x86_64-linux.dotnet-bindings.passthru.fetch-deps
      #   ./result bindings/dotnet/deps.json
      nugetDeps = ./bindings/dotnet/deps.json;
      dotnet-sdk = pkgs.dotnetCorePackages.sdk_10_0;
      # A library has nothing to publish; the nupkg is the artifact.
      dontPublish = true;
      packNupkg = true;
      # LICENSE is a symlink to the repository root (matches
      # bindings/{haskell,rust,typescript}) and packing follows it.
      prePatch = ''
        cp --remove-destination ${./LICENSE} LICENSE
      '';
    };

  go-bindings = pkgs.buildGoModule {
    pname = "scip-bindings-go";
    inherit version;
    src = ./.;
    modRoot = "./bindings/go/scip";
    vendorHash = "sha256-f36BsvI5AWAnuxe2BWD5Bkb6Xb3kdIkkSw3Td2QlcrA=";
    env.GOWORK = "off";
    buildTags = [ "asserts" ];
    subPackages = [
      "."
      "memtest"
      "testutil"
    ];
    installPhase = "touch $out";
  };

  haskell-bindings =
    let
      cabal = pkgs.haskellPackages.callCabal2nix "scip" ./bindings/haskell { };
    in
    assert pkgs.lib.assertMsg (
      cabal.version == version
    ) "Version mismatch in bindings/haskell/scip.cabal: expected ${version}, got ${cabal.version}";
    cabal.overrideAttrs (oldAttrs: {
      prePatch = ''
        cp --remove-destination ${./LICENSE} LICENSE
      '';
      postPatch = (oldAttrs.postPatch or "") + ''
        ${pkgs.haskellPackages.cabal-install}/bin/cabal check
      '';
    });

  reprolang =
    let
      reprolangVersion = (builtins.fromJSON (builtins.readFile ./reprolang/package.json)).version;
    in
    assert pkgs.lib.assertMsg (
      reprolangVersion == version
    ) "Version mismatch in reprolang/package.json: expected ${version}, got ${reprolangVersion}";
    pkgs.buildGoModule {
      pname = "scip-reprolang";
      inherit version;
      src = ./.;
      modRoot = "./reprolang";
      vendorHash = "sha256-xSQqFbrbqhzxSGcW/ig3jkDRHMVxVXYaLOi3wMs/PMc=";
      proxyVendor = true;
      env.GOWORK = "off";
      buildInputs = [ pkgs.tree-sitter ];
      subPackages = [
        "grammar"
        "repro"
      ];
      installPhase = "touch $out";
    };

  reprolang-generated = pkgs.stdenv.mkDerivation {
    pname = "scip-reprolang-generated";
    inherit version;
    src = ./.;
    nativeBuildInputs = with pkgs; [
      nodejs
      prettier
      tree-sitter
    ];
    buildPhase = ''
      cd reprolang
      cp -r grammar grammar-before
      tree-sitter generate --abi 14 --output grammar
      prettier --write 'grammar/grammar.json' 'grammar/node-types.json'
      diff -rq grammar-before grammar
    '';
    installPhase = "touch $out";
  };

  rust-bindings =
    let
      cargoTomlVersion =
        (builtins.fromTOML (builtins.readFile ./bindings/rust/Cargo.toml)).package.version;
    in
    assert pkgs.lib.assertMsg (
      cargoTomlVersion == version
    ) "Version mismatch in bindings/rust/Cargo.toml: expected ${version}, got ${cargoTomlVersion}";
    pkgs.rustPlatform.buildRustPackage {
      pname = "scip-bindings-rust";
      inherit version;
      src = ./bindings/rust;
      cargoLock = {
        lockFile = ./bindings/rust/Cargo.lock;
      };
    };

  typescript-bindings =
    let
      packageJsonVersion =
        (builtins.fromJSON (builtins.readFile ./bindings/typescript/package.json)).version;
    in
    assert pkgs.lib.assertMsg (packageJsonVersion == version)
      "Version mismatch in bindings/typescript/package.json: expected ${version}, got ${packageJsonVersion}";
    pkgs.buildNpmPackage {
      pname = "scip-bindings-typescript";
      inherit version;
      src = ./bindings/typescript;
      npmDepsHash = "sha256-OiM5KpWXA5DTEtVeWH7AXpo7Ttg4NWY6OLx2WTRPGfE=";
      buildPhase = ''
        runHook preBuild
        npm run build
        runHook postBuild
      '';
      installPhase = "touch $out";
    };
}