flake.nix

{
  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable";
    pre-commit-hooks.url = "github:cachix/git-hooks.nix";
    rust-overlay = {
      url = "github:oxalica/rust-overlay";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

  outputs = {
    self,
    nixpkgs,
    rust-overlay,
    ...
  }: let
    lib = nixpkgs.lib;
    supportedSystems = ["x86_64-linux" "aarch64-linux" "x86_64-darwin" "aarch64-darwin"];
    forEachSupportedSystem = f:
      lib.genAttrs supportedSystems (system:
        f {
          inherit system;
          pkgs = import nixpkgs {
            inherit system;
            config = {
              allowUnfree = true;
              android_sdk.accept_license = true;
            };
            overlays = [
              rust-overlay.overlays.default
              self.overlays.default
            ];
          };
        });

    perSystem = forEachSupportedSystem ({
      pkgs,
      system,
    }: let
      android = pkgs.androidenv.composeAndroidPackages {
        platformVersions = ["34"];
        buildToolsVersions = ["35.0.0"];
        abiVersions = ["x86_64"];
        includeEmulator = true;
        includeSystemImages = true;
        systemImageTypes = ["google_apis"];
        cmakeVersions = ["3.22.1"];
        ndkVersions = ["26.3.11579264"];
        includeNDK = true;
      };

      rustPackages = with pkgs; [
        rust-analyzer
        rustToolchain
        cargo-watch
        cargo-ndk
      ];

      rEnv = pkgs.rWrapper.override {
        packages = with pkgs.rPackages; [
          tidyverse
          ggplot2
          scales
          cowplot
          viridis
          ggpubr
        ];
      };

      commonTools = with pkgs; [
        curl
        wget
        pkg-config
        gradle
        openjdk17
        android-tools
        neovim
        kotlin-language-server
        ktlint
        jdt-language-server
        nodejs_22
        yarn

        libGL
        libxkbcommon
        alsa-lib
        zlib
        ncurses5
        udev

        typst
        tinymist
        typstyle

        rEnv
      ];

      libraries = with pkgs;
        [
          at-spi2-atk
          atkmm
          cairo
          gdk-pixbuf
          glib
          gtk3
          harfbuzz
          librsvg
          libsoup_3
          pango
          webkitgtk_4_1
          openssl
          cmake
          lz4
          boost
          protobuf
          sqlite
          libspatialite
          luajit
          zeromq
          rapidjson
          cxxopts
        ]
        ++ lib.optionals pkgs.stdenv.isLinux [prime-server];

      valhallaNativeInputs = with pkgs; [
        cmake
        pkg-config
        protobuf
        python3
      ];

      valhallaBuildInputs = with pkgs;
        [
          boost
          curl
          libspatialite
          luajit
          lz4
          protobuf
          sqlite
          zeromq
          zlib
          rapidjson
          cxxopts
        ]
        ++ lib.optionals pkgs.stdenv.isLinux [prime-server];

      # Create a separate NDK package with the correct version
      androidNdk =
        (pkgs.androidenv.composeAndroidPackages {
          ndkVersions = ["26.3.11579264"];
          includeNDK = true;
        }).ndk-bundle;

      rustPlatform = pkgs.makeRustPlatform {
        cargo = pkgs.rustToolchain.cargo;
        rustc = pkgs.rustToolchain.rustc;
      };

      workspaceSrc = pkgs.lib.cleanSource ./rust;

      streamletValhalla = rustPlatform.buildRustPackage {
        pname = "streamlet";
        version = "0.1.0";
        src = workspaceSrc;

        cargoLock = {
          lockFile = ./rust/Cargo.lock;
          outputHashes = {
            "osrm-binding-0.1.6" = "sha256-g0cHL1bFdSR1iRu17ACJM42Z27Z+QlwdeGxyZQ6KVZk=";
            "valhalla-0.6.7" = "sha256-bggyo6PqBZHMOmbPouETSmI3j5+V3DszD+8nDM3e6dk=";
          };
        };

        cargoBuildFlags = [
          "--package"
          "streamlet"
        ];
        cargoBuildFeatures = ["valhalla"];
        cargoCheckFeatures = ["valhalla"];
        doCheck = false;

        nativeBuildInputs = valhallaNativeInputs;
        buildInputs = valhallaBuildInputs;

        PROTOC = "${pkgs.protobuf}/bin/protoc";
      };

      mkAndroidEnv = extraInputs:
        pkgs.mkShell {
          buildInputs = extraInputs;

          ANDROID_SDK_ROOT = "${android.androidsdk}/libexec/android-sdk";
          ANDROID_HOME = "${android.androidsdk}/libexec/android-sdk";
          JAVA_HOME = pkgs.openjdk17;
          PROTOC = "${pkgs.protobuf}/bin/protoc";

          LD_LIBRARY_PATH = "${pkgs.lib.makeLibraryPath libraries}:$LD_LIBRARY_PATH";
          XDG_DATA_DIRS = "${pkgs.gsettings-desktop-schemas}/share/gsettings-schemas/${pkgs.gsettings-desktop-schemas.name}:${pkgs.gtk3}/share/gsettings-schemas/${pkgs.gtk3.name}:$XDG_DATA_DIRS";

          RUST_SRC_PATH = "${pkgs.rustToolchain}/lib/rustlib/src/rust/library";

          shellHook = ''
            export ANDROID_SDK_ROOT="${android.androidsdk}/libexec/android-sdk"
            export ANDROID_HOME="${android.androidsdk}/libexec/android-sdk"
            export ANDROID_NDK_ROOT="${androidNdk}/libexec/android-sdk/ndk-bundle"
            export ANDROID_NDK_HOME="$ANDROID_NDK_ROOT"
            export JAVA_HOME="${pkgs.openjdk17}"
            export PROTOC="${pkgs.protobuf}/bin/protoc"

            # SDK-CLI/Emulator/Platform-Tools in PATH
            export PATH="$ANDROID_SDK_ROOT/emulator:$ANDROID_SDK_ROOT/platform-tools:$ANDROID_SDK_ROOT/tools/bin:$ANDROID_SDK_ROOT/cmdline-tools/latest/bin:$PATH"

            echo
            echo "Dev shell active (${system})"
            echo "SDK : $ANDROID_SDK_ROOT"
            echo "NDK : $ANDROID_NDK_ROOT"
            echo "Java: $JAVA_HOME"
            echo "Protoc: $PROTOC"
            echo
          '';
        };
    in {
      packages = {
        streamlet-valhalla = streamletValhalla;
        default = streamletValhalla;
      };

      checks = {
        streamlet-valhalla = streamletValhalla;
      };

      devShells = {
        default = mkAndroidEnv ([
            android.androidsdk
          ]
          ++ rustPackages ++ commonTools ++ libraries);

        android = mkAndroidEnv ([
            android.androidsdk
          ]
          ++ rustPackages ++ commonTools ++ libraries);

        rust = pkgs.mkShell {
          buildInputs =
            rustPackages
            ++ [
              pkgs.curl
              pkgs.wget
              pkgs.pkg-config
            ]
            ++ libraries;

          LD_LIBRARY_PATH = "${pkgs.lib.makeLibraryPath libraries}:$LD_LIBRARY_PATH";
          XDG_DATA_DIRS = "${pkgs.gsettings-desktop-schemas}/share/gsettings-schemas/${pkgs.gsettings-desktop-schemas.name}:${pkgs.gtk3}/share/gsettings-schemas/${pkgs.gtk3.name}:$XDG_DATA_DIRS";
          RUST_SRC_PATH = "${pkgs.rustToolchain}/lib/rustlib/src/rust/library";
          PROTOC = "${pkgs.protobuf}/bin/protoc";

          shellHook = ''
            export PROTOC="${pkgs.protobuf}/bin/protoc"
            echo "Rust shell active (${system})"
          '';
        };
      };
    });
  in {
    overlays.default = final: prev: {
      rustToolchain = final.rust-bin.fromRustupToolchainFile ./rust/rust-toolchain.toml;
    };

    packages = lib.mapAttrs (_: value: value.packages) perSystem;
    checks = lib.mapAttrs (_: value: value.checks) perSystem;
    devShells = lib.mapAttrs (_: value: value.devShells) perSystem;
  };
}