{
  description = "spacial-data-experiments";

  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable";
    flake-utils.url = "github:numtide/flake-utils";
    quebec-cities-poly = {
      url = "github:didiercrunch/cities";
      flake = false;
    };
  };
  outputs = { self, nixpkgs, flake-utils, quebec-cities-poly }:
    flake-utils.lib.eachDefaultSystem (system:
      let
        pkgs = nixpkgs.legacyPackages.${system};

        poly2geojson = pkgs.rustPlatform.buildRustPackage rec {
          pname = "poly2geojson";
          version = "0.1.3";

          src = pkgs.fetchFromGitHub {
            owner = "frafra";
            repo = pname;
            rev = "2fbf2383765fe043d43d53b91ddbfe50c0129bb1";
            hash = "sha256-BMRl6fRqQlibuGxg5hBHz7r1cvionNYEZe9YcZuL0oU=";
          };
          cargoHash = "sha256-pCegHF6SsCIsCQ/b+N34xTMjw2PjPB0pi30Y9sWIcV4=";
        };

        osmosis = pkgs.stdenv.mkDerivation {
          name = "osmosis";
          src = pkgs.fetchzip {
            url =
              "https://github.com/openstreetmap/osmosis/releases/download/0.49.2/osmosis-0.49.2.zip";
            hash = "sha256-hmD/pnEEJsl2NkODon4XZcZ3ZQ7+fx/JvWTR4xrRoug=";
          };
          buildInputs = [ ];
          buildPhase = "";
          installPhase = ''
            cp -r . $out
          '';
        };

        custom-osmium-tool = pkgs.stdenv.mkDerivation rec {
          pname = "osmium-tool";
          version = "1.16.0";

          src = pkgs.fetchFromGitHub {
            owner = "osmcode";
            repo = "osmium-tool";
            rev = "8ed94a5da2a24b233a77732bfaa8c75fc32ea505";
            sha256 = "sha256-YxjInUqcVfrBvAdBA/pd2J7NEBp6FvoQ97S+aW9x7jE=";
          };

          nativeBuildInputs = with pkgs; [ cmake installShellFiles pandoc ];

          buildInputs = with pkgs; [
            boost
            bzip2
            expat
            libosmium
            lz4
            protozero
            zlib
            nlohmann_json
          ];

          doCheck = false;
          doInstallCheck = false;

          postInstall = ''
            installShellCompletion --zsh ../zsh_completion/_osmium
          '';
        };

        duckdb-spatial = pkgs.clangStdenv.mkDerivation rec {
          pname = "duckdb-spatial";
          version = "master";

          src = pkgs.fetchFromGitHub {
            owner = "duckdb";
            repo = "duckdb-spatial";
            rev = "7f861c037567dadaeff9cb5dcde4e5f2e87a4e14";
            sha256 = "sha256-8kfNofzbmPJ7+qKKzsr7LVu1mMDwGhy5nQj6/kRhYLg=";
          };
          librarySystemDepends = [ pkgs.zlib ];
          executableSystemDepends = [ pkgs.zlib ];

          cmakeFlags =
            [ "-DVCPKG_TARGET_TRIPLET=${system}" "-DSPATIAL_USE_NETWORK=0" ];

          nativeBuildInputs = with pkgs; [
            cmake
            installShellFiles
            pandoc
            pkg-config
            zlib
          ];

          buildInputs = with pkgs; [ geographiclib openssl geos curl zlib ];

          doCheck = false;
        };

        static-server-url = "https://static.home.all-dressed-programming.com";
        geofabrik-base-url =
          "${static-server-url}/download.geofabrik.de/north-america/canada/";

        osm-quebec."2020" = pkgs.fetchurl {
          url = "${geofabrik-base-url}quebec-200101.osm.pbf";
          hash = "sha256-RYoz4Qo/xwiEVBoA4xRHHpt8kvNS/mHskJBmR4+3vQk=";
        };
        osm-quebec."2021" = pkgs.fetchurl {
          url = "${geofabrik-base-url}quebec-210101.osm.pbf";
          hash = "sha256-kKi/5hCVHaVvMVFAJWpJGPybmKwDu0QXePimYnHBKKk=";
        };
        osm-quebec."2022" = pkgs.fetchurl {
          url = "${geofabrik-base-url}quebec-220101.osm.pbf";
          hash = "sha256-iZUm+vMiDH6eyf4kmee6O8z+lN/voyjAt4RtzmSU6Wo=";
        };
        osm-quebec."2023" = pkgs.fetchurl {
          url = "${geofabrik-base-url}quebec-230101.osm.pbf";
          hash = "sha256-AReFCvBIz42RBcOYgC25ZJaBXADW1lIzSpCI+vdrWX0=";
        };
        osm-quebec."2024" = pkgs.fetchurl {
          url = "${geofabrik-base-url}quebec-240101.osm.pbf";
          hash = "sha256-lcbn4mks4NlnwU3QwQOFdLICxFGapDC0PR/h0HlIR1E=";
        };
        osm-quebec."2025" = pkgs.fetchurl {
          url = "${geofabrik-base-url}quebec-250101.osm.pbf";
          hash = "sha256-QLIflsZuv8r2+mGVARrGkXyjWZ7qGzdSODpVka8iK8c=";
        };

        data-dir = osm-data:
          pkgs.stdenv.mkDerivation {
            name = "data-dir";
            src = ./scripts;
            buildInputs =
              [ poly2geojson pkgs.jdk23 osmosis custom-osmium-tool ];
            buildPhase = ''
              mkdir -p cities/canada/quebec
              cp ${quebec-cities-poly}/canada/quebec/* cities/canada/quebec
              chmod u+w cities/canada/quebec
              ${pkgs.babashka}/bin/bb  to-geojson.clj --osm-file ${osm-data} --paths cities/canada/quebec/*.poly
            '';
            installPhase = ''
              cp -r cities $out
            '';
          };

        historical-data-dir = pkgs.stdenv.mkDerivation {
          name = "historical-data-dir";
          src = ./scripts;
          buildInputs = [ ];
          buildPhase = "";
          installPhase = ''
            mkdir -p $out
            ln -s ${data-dir osm-quebec."2020"} $out/2020
            ln -s ${data-dir osm-quebec."2021"} $out/2021
            ln -s ${data-dir osm-quebec."2022"} $out/2022
            ln -s ${data-dir osm-quebec."2023"} $out/2023
            ln -s ${data-dir osm-quebec."2024"} $out/2024
            ln -s ${data-dir osm-quebec."2025"} $out/2025
          '';
        };

        processed-duckdb-file = pkgs.fetchurl {
          url = "${static-server-url}/yongestreet/duckdb/2025-01-06.duckdb";
          hash = "sha256-jZEkKg/D3MOVWprVGmsc/ev2fY6TVcN3tD3NH23B2h4=";
        };

        web-server = pkgs.buildDotnetModule {
          pname = "YongeStreet";
          version = "0.1.0";
          src = ./.;
          nugetDeps = ./nuget-deps.nix;
          projectFile = "YongeStreet/YongeStreet.csproj";
          dotnetBuildFlags = [ "--no-self-contained" ];
          dotnet-sdk = pkgs.dotnetCorePackages.sdk_8_0;
          dotnet-runtime = pkgs.dotnetCorePackages.aspnetcore_8_0;
        };

        yonge-street = pkgs.writeShellApplication {
          name = "yonge-street";
          runtimeInputs = [ ];
          text = ''
            cd ${web-server}/lib/YongeStreet
            export PREPROCESSED_DUCKDB_FILE="${processed-duckdb-file}"
            exec ${web-server}/bin/YongeStreet
          '';
        };

        python-virtual-env = pkgs.python312.withPackages (ps: [
          ps.matplotlib
          ps.jupyter
          ps.tqdm
          ps.duckdb
          ps.pandas
          ps.unidecode
          ps.geopy
          ps.click
          ps.jinja2
        ]);

      in {
        packages = {
          default = yonge-street;
          yonge-street = yonge-street;
          historical-data-dir = historical-data-dir;
          poly2geojson = poly2geojson;
          osmosis = osmosis;
          duckdb-spatial = duckdb-spatial;
          web-server = web-server;
        };
        devShell = pkgs.mkShell {
          name = "spacial-data-experiments";
          buildInputs = with pkgs; [
            duckdb
            http-server
            sqlfluff
            poly2geojson
            gdal
            custom-osmium-tool
            python-virtual-env
            dotnet-sdk_8
            nuget-to-nix
          ];
        };
        nixosModules = { config, lib, ... }: {
          options.services.all-dressed-programming.yonge-street = {
            enable = lib.mkEnableOption "enable YongeStreet server";
            port = lib.mkOption {
              type = lib.types.int;
              default = 9876;
              description = "The tcp port the YongeStreet will serve on.";
            };
          };
          #  options.services.all-dressed-programming.yonge-street
          config = lib.mkIf
            config.services.all-dressed-programming.yonge-street.enable {
              users.groups.yonge-street = { };

              users.users.yonge-street = {
                createHome = false;
                isSystemUser = true;
                group = "yonge-street";
              };

              systemd.services.yonge-street = {
                wantedBy = [ "multi-user.target" ];
                environment.DOTNET_HTTP_PORTS = (builtins.toString
                  config.services.all-dressed-programming.yonge-street.port);
                serviceConfig = {
                  User = "yonge-street";
                  Group = "yonge-street";
                  Restart = "always";
                  ExecStart = "${yonge-street}/bin/yonge-street";
                };
              };
            };
        };
      });
}