{ nixpkgs ? import ./Bild/Nixpkgs.nix }:


let
  ghcCompiler = "ghc884";
  ghcjsCompiler = "ghcjs86";

  # provided by .envrc
  root = builtins.getEnv "BIZ_ROOT";

  selectAttrs = deps: packageSet:
    nixpkgs.lib.attrsets.attrVals deps packageSet;

  # returns true if a is a subset of b, where a and b are attrsets
  subset = a: b: builtins.all
    (x: builtins.elem x b) a;

  # 44 = lib.strings.stringLength "/nix/store/gia2r9mxhc900y1m97dlmr1g3rm3ich3-"
  dropNixStore = s: nixpkgs.lib.strings.substring 44 (nixpkgs.lib.strings.stringLength s) s;

  haskellDeps = hpkgs: import ./Bild/Deps/Haskell.nix hpkgs;

  mkGhcPackageSet = nixpkgs.haskell.packages.${ghcCompiler}.ghcWithHoogle;
  #mkGhcjsPackageSet = nixpkgs.haskell.packages.${ghcjsCompiler}.ghcWithPackages;

in rec {
  inherit (nixpkgs) lib stdenv pkgs sources;

  # a standard nix build for `bild` - this should be the only hand-written
  # builder we need
  bild = stdenv.mkDerivation {
    name = "bild";
    src = ../.;
    nativeBuildInputs = [ ghcPackageSetFull ];
    buildInputs = [ ghcPackageSetFull nixpkgs.makeWrapper ];
    propagatedBuildInputs = [ ghcPackageSetFull ];
    strictDeps = true;
    buildPhase = ''
      mkdir -p $out/bin
      ghc \
        -Werror \
        -i. \
        --make Biz/Bild.hs \
        -main-is Biz.Bild \
        -o $out/bin/bild
    '';
    installPhase = ''
      wrapProgram $out/bin/bild --prefix PATH : ${lib.makeBinPath [ ghcPackageSetFull ]}
    '';
  };

  # wrapper around bild
  runBildAnalyze = main: stdenv.mkDerivation {
    name = "bild-analysis";
    src = ../.;
    USER = "nixbld";
    HOSTNAME = "nix-sandbox";
    BIZ_ROOT = "$src";
    buildPhase = ''
      set -eux
      mkdir $out
      : analyzing with bild
      ${bild}/bin/bild --analyze ${main} 1> $out/analysis.json 2> $out/stderr
      set +eux
    '';
    installPhase = "exit 0";
  };

  # gather data needed for compiling by analyzing the main module
  analyze = main:
    builtins.head
      (lib.trivial.importJSON
        (runBildAnalyze main + "/analysis.json"));

  ghcPackageSetFull = mkGhcPackageSet haskellDeps;

  ghc = main:
    let
      data = analyze main;
      ghc = mkGhcPackageSet (hp: selectAttrs data.langdeps hp);
      module = lib.strings.concatStringsSep "." data.namespace.path;
    in stdenv.mkDerivation {
      name = module;
      src = ../.;
      nativeBuildInputs = [ ghc ] ++ selectAttrs data.sysdeps nixpkgs.pkgs;
      strictDeps = true;
      buildPhase = ''
        set -eux
        mkdir -p $out/bin
        : compiling with ghc
        ${ghc}/bin/ghc \
          -Werror \
          -i. \
          --make ${main} \
          -main-is ${module} \
          -o $out/bin/${data.out}
      '';
      # the install process was handled above
      installPhase = "exit 0";
    } // { env = ghc; };

  #ghcjs = main:
  #  let
  #    data = analyze main;
  #    ghcjs = mkGhcjsPackageSet (hp: selectAttrs data.deps hp);
  #  in stdenv.mkDerivation {
  #    name = data.module;
  #    src = ../.;
  #    nativeBuildInputs = [ ghcjs ];
  #    strictDeps = true;
  #    buildPhase = ''
  #      mkdir -p $out/static
  #      # compile with ghcjs
  #      ${ghcjs}/bin/ghcjs \
  #        -Werror \
  #        -i. \
  #        --make ${main} \
  #        -main-is ${data.module} \
  #        -o ${data.out}
  #      # optimize js output
  #      ${nixpkgs.pkgs.closurecompiler}/bin/closure-compiler \
  #        ${data.out}/all.js > $out/static/${data.out}
  #    '';
  #    installPhase = "exit 0";
  #  } // { env = ghcjs; };

  env = pkgs.mkShell {
    name = "bizdev";
    buildInputs = with nixpkgs.pkgs; [
      # haskell deps
      (mkGhcPackageSet haskellDeps)
      # ghcjs doesn't need everything, and many things fail to build
      #(mkGhcjsPackageSet (hp: with hp; [
      #  aeson
      #  clay
      #  containers
      #  miso
      #  protolude
      #  servant
      #  split
      #  text
      #  ghcjs-base
      #]))

      # python deps
      (python38.withPackages (p:
        [ p.black p.pylint ]))

      # tools
      haskell.packages.${ghcCompiler}.apply-refact
      cmark
      figlet
      haskell.packages.${ghcCompiler}.fast-tags
      hlint
      lolcat
      niv.niv
      nixops
      ormolu
      python37Packages.black
      python37Packages.pylint
      shellcheck
      wemux
      gmnisrv
      gmni
    ] ++ lib.optional nixpkgs.stdenv.isLinux [
      # scheme deps (i think these are broken on macOS)
      guile
      #inspekt3d
      #libfive

      ccze
    ];
    shellHook = ". ${./Bild/ShellHook.sh}";
  };

  os = cfg: (nixpkgs.nixos (args: cfg)).toplevel;
}