{ channel ? "stable", pkgs ? import <nixpkgs> {} }:

let
  helloService  = pkgs.callPackage ./service-hello {};
  worldService  = pkgs.callPackage ./service-world {};
  joinerService = pkgs.callPackage ./service-joiner {};
  personApiTypes = pkgs.callPackage ./person-api-types {};
  personService = pkgs.callPackage ./service-person { inherit personApiTypes; };
  kubenix       = pkgs.callPackage ./nix/kubenix.nix {};

  buildConfig = t: kubenix.buildResources { configuration = import ./configuration.nix { type = t; }; };

  helloImage = pkgs.dockerTools.buildLayeredImage {
    name = "hello-service";
    tag = "latest";
    config.Cmd = [ "${helloService}/bin/service-hello" ];
  };

  worldImage = pkgs.dockerTools.buildLayeredImage {
    name = "world-service";
    tag = "latest";
    config.Cmd = [ "${worldService}/bin/service-world" ];
  };

  joinerImage = pkgs.dockerTools.buildLayeredImage {
    name = "joiner-service";
    tag = "latest";
    config.Cmd = [ "${joinerService}/bin/service-joiner" ];
  };

  personImage = pkgs.dockerTools.buildLayeredImage {
    name = "person-service";
    tag = "latest";
    config.Cmd = [ "${personService}/bin/service-person" ];
  };
in rec {
  inherit helloImage worldImage joinerImage personImage;

  test-deployment = pkgs.callPackage ./nix/test-deployment.nix { };

  deploy-to-kind = pkgs.callPackage ./nix/deploy-to-kind.nix {
    inherit helloImage worldImage joinerImage;

    config = buildConfig "dev";
  };

  config = buildConfig "dev";

  redeploy = pkgs.writeScriptBin "redeploy" ''
    cat ${config} | ${pkgs.kubectl}/bin/kubectl apply -f -
  '';

  deploy-and-test = pkgs.mkShell {
    buildInputs = [ pkgs.kind deploy-to-kind test-deployment ];

    shellHook = ''
      deploy-to-kind
      export KUBECONFIG=$(kind get kubeconfig-path)
      wait-for-deployment hello
      test-deployment
      kind delete cluster
    '';
  };

  postgresDb = "helloworlddb";
  postgresUser = "helloworlduser";
  postgresPassword = "asdfghjkl";

  postgresContainerName = "helloworld-dev-db";

  run-dev-postgres-container = pkgs.writeScriptBin "run-dev-postgres-container" ''
    ${pkgs.docker}/bin/docker run \
      --name ${postgresContainerName} \
      -e POSTGRES_PASSWORD="${postgresPassword}" \
      -p 5432:5432 \
      -m 512m \
      -d \
      --rm \
      postgres

    sleep 2 # because postgres needs to spin up
    docker exec -it ${postgresContainerName} psql -U postgres -c "CREATE USER ${postgresUser} PASSWORD '${postgresPassword}' SUPERUSER CREATEDB INHERIT LOGIN"
    docker exec -it ${postgresContainerName} createdb -U postgres ${postgresDb}
  '';

  destroy-dev-postgres-container = pkgs.writeScriptBin "destroy-dev-postgres-container" ''
    docker stop ${postgresContainerName}
  '';

  shell = let
    moz_overlay = import (
      builtins.fetchTarball https://github.com/mozilla/nixpkgs-mozilla/archive/master.tar.gz
    );

    pkgs = import <nixpkgs> { overlays = [ moz_overlay ]; };
    rustchannel = pkgs.rustChannelOf { inherit channel; };
  in
  pkgs.mkShell {
    buildInputs = with pkgs; [
      kind
      deploy-to-kind
      test-deployment
      redeploy
      run-dev-postgres-container
      destroy-dev-postgres-container
      curl
      docker
      kubectl
      diesel-cli

      rustchannel.rust-std
      rustchannel.rust
      rustchannel.rustc
      rustchannel.cargo

      cmake
      curl
      gcc
      openssl
      pkgconfig
      postgresql
    ];

    POSTGRES_PASSWORD = "${postgresPassword}";
    DATABASE_URL="postgres://${postgresUser}:${postgresPassword}@localhost/${postgresDb}";

    LIBCLANG_PATH = "${pkgs.llvmPackages.libclang}/lib";
  };

}