{ # host package set (unused except for fetching nixpkgs)
  hostPkgs         ? import <nixpkgs> {}

, # versioned nixpkgs
  pkgs             ? import (hostPkgs.nix-update-source.fetch ./pkgs.json).src {}

, # versioned nixpkgs-older version for zmcat
  bleeding         ? import (hostPkgs.nix-update-source.fetch ./bleeding.json).src {}

, # fetcher alias for the remaining arguments
  fetched          ? s: (pkgs.nix-update-source.fetch s).src

, #source overrides: core nrm components
  aml-src          ? fetched aml/pin.json
, numabench-src    ? fetched numabench/pin.json
, excit-src        ? fetched excit/pin.json
, libnrm-src       ? fetched libnrm/pin.json
, nrm-src          ? fetched nrm/pin.json
, containers-src   ? fetched containers/pin.json

, #source overrides: applications
  amg-src          ? fetched amg/pin.json
, qmcpack-src      ? fetched qmcpack/pin.json
, openmc-src       ? fetched openmc/pin.json
, stream-src       ? fetched stream/pin.json
, lammps-src       ? fetched lammps/pin.json

  #source overrides: tooling
, repoquality-src  ? builtins.fetchGit {inherit (fetched repoquality/pin.json) url rev;}
, dhrun-src        ? builtins.fetchGit {inherit (fetched dhrun/pin.json) url rev;}
, powerplots-src   ? builtins.fetchGit {inherit (fetched powerplots/pin.json) url rev;}
, argonix-src      ? builtins.fetchGit {inherit (fetched argonix/pin.json) url rev;}
, experiments-src  ? fetched experiments/pin.json

, #used for hardware experiments.
  sudoPath         ? null

, #whether to graft apps on libnrm.
  graftLibnrm      ? false
}:
let
  callPackage = pkgs.lib.callPackageWith (pkgs // argopkgs);

  addBI = drv: bi: drv.overrideAttrs
    (old:{buildInputs=old.buildInputs ++ [ bi ];});

  argopkgs = rec {
    # library of nix expressions
    argolib       = import ../lib/utils.nix;
    # Argo components (source overridabel via argument)
    aml           = callPackage ./aml        {src=aml-src; inherit excit; inherit numabench;};
    numabench     = callPackage ./numabench  {src=numabench-src; hwloc = hwloc2;};
    excit         = callPackage ./excit      {src=excit-src;};
    nrm           = callPackage ./nrm        {src=nrm-src;};
    containers    = callPackage ./containers {src=containers-src;};
    libnrm        = callPackage ./libnrm     {src=libnrm-src;};
    libnrm-pinned = callPackage ./libnrm     {src=fetched libnrm/pin.json;};
    libnrm-pmpi   = libnrm.overrideAttrs (oldAttrs: rec {
      configureFlags = "--enable-pmpi";
      buildInputs = oldAttrs.buildInputs ++ [ pkgs.mpich2 ];
    });

    nrm-pytest    = nrm.overrideAttrs (old:{checkPhase="py.test";});
    aml-dist      = aml.overrideAttrs (old:{
      nativeBuildInputs = old.nativeBuildInputs ++ [ pkgs.doxygen ];
      buildPhase = "make dist";
      installPhase = ''
        mkdir -p $out
        cp *.tar.gz $out/
      '';
    });

    numabench-check = numabench.overrideAttrs(old: {
      buildPhase = "make check";
      installPhase =''
        mkdir -p $out/tests
        cp ./tests/*.log $out/tests
        cp ./tests/*.trs $out/tests
        cp -r ./tests/tmp $out/tests
        '';
    });
    excit-check = excit.overrideAttrs(old: {
      buildPhase = "make check";
    });

    # applications with replaceDependency for libnrm.
    repLibnrm = path: src: extra:
    let
      drv = callPackage path ({
        nrmSupport = true;
        src = src;
        libnrm = libnrm-pinned;
      }//extra);
      rebuilt = drv.override {libnrm = libnrm;};
      grafted = pkgs.replaceDependency {
        drv = drv;
        oldDependency = libnrm-pinned;
        newDependency = libnrm;
      };
    in if graftLibnrm then grafted else rebuilt;
    amg          = repLibnrm ./amg     amg-src     {};
    qmcpack      = repLibnrm ./qmcpack qmcpack-src {};
    openmc       = repLibnrm ./openmc  openmc-src  {};
    lammps       = repLibnrm ./lammps  lammps-src  {};
    stream       = repLibnrm ./stream  stream-src  {iterationCount="2000";};

    # data (static, non source overridable via arguments)
    openmc-data = fetched openmc/data.json;

    # tools
    checkpatch = callPackage ./checkpatch {src=pkgs.linux_testing.src;};
    zymake = callPackage ./zymake {
      inherit (pkgs.ocamlPackages) findlib ocamlbuild topkg batteries;
    };
    haskellPackages = pkgs.haskellPackages.override {
      overrides = self: super: with pkgs.haskell.lib;
      rec {
        panpipe        = (pkgs.haskell.lib.doJailbreak super.panpipe);
        spdx           = (pkgs.haskell.lib.doJailbreak super.spdx);
        monad-mock     = (pkgs.haskell.lib.doJailbreak super.monad-mock);
        generic-pretty = doJailbreak super.generic-pretty;

        #minor cabal and version fix
        panhandle    = (self.callCabal2nix "panhandle" (builtins.fetchGit {
                      inherit (panhandle-src) url rev; })) {};
        inline-r = dontCheck super.inline-r;
        argonix     = (self.callCabal2nix "argonix"     argonix-src     ) {};
        repoquality = (self.callCabal2nix "repoquality" repoquality-src ) {};
        powerplots  = (self.callCabal2nix "powerplots"  powerplots-src  ) {};

      };
    };

    bleedingHaskellPackages = bleeding.haskellPackages.override {
      overrides = self: super: with bleeding.haskell.lib;
      rec {
        dhrun       = (self.callCabal2nix "dhrun"       dhrun-src ) {};
      };
    };

    # re-export from hpkgs and add non-haskell build rule specialization
    inherit (haskellPackages) repoquality;
    inherit (bleedingHaskellPackages) dhall dhall-json;

    dhrun = bleedingHaskellPackages.dhrun.overrideAttrs (old:{
        installPhase = old.installPhase + ''
          mkdir -p $out/share/
          cp -r resources $out/share/
        '';
      });

    argonix = haskellPackages.argonix.overrideAttrs (old:{
        installPhase = old.installPhase + ''
          mkdir -p $out/share/
          $out/bin/argonix --bash-completion-script argonix > $out/share/argonix.sh
        '';
      });

    powerplots =
    let
      pkl = with pkgs.rPackages; [ docopt pracma tidyr readr magrittr formatR
          purrr wrapr knitr cowplot plotly lubridate dplyr ggplot2 fpp2
          prospectr gridExtra zoo xtable ggthemes data_table
        ];
      myR = (pkgs.rWrapper.override{ packages = [pkl];});
    in
    haskellPackages.powerplots.overrideDerivation (drv: rec {
      buildInputs = (drv.buildInputs or []) ++ [
        pkgs.makeWrapper
        myR
      ];

      installPhase = drv.installPhase + ''
        wrapProgram "$out/bin/powerplots" \
          --set R_LIBS_SITE `Rscript -e "Sys.getenv(\"R_LIBS_SITE\")"`
      '';

    });

    # fix for nrm
    pyzmq = pkgs.pythonPackages.pyzmq.override { zeromq3 = pkgs.zeromq; };

    hwloc2 = pkgs.hwloc.overrideAttrs (old:{
      src = pkgs.fetchurl {
        url = "https://download.open-mpi.org/release/hwloc/v2.0/hwloc-2.0.3.tar.gz";
        sha256 = "0707ml34ylrr8zwwhddp64q6q57248m9646f27jadcx5m93g5pk4";
      };
    });

    # ci/experimental environments
    test = pkgs.stdenv.mkDerivation rec {
      name = "testEnv";

      buildInputs = [
        # tooling may run mpiexec or hwloc:
        pkgs.mpich2
        pkgs.hwloc
        # these are needed for some reason:
        pkgs.coreutils
        pkgs.utillinux
        pkgs.git
        # argo tools
        dhrun
        # argo components
        containers
        nrm
      ];

      #required to be able to build the drv.
      installPhase = "mkdir $out";
      unpackPhase = "true";

      __noChroot = true;
      shellHook =''
        echo ""
        echo "ENTERING ENVIRONMENT: Sources of impurity for this build are: /tmp/ /etc/argo/ /var/run/ /var/lock/".
        echo "ENTERING ENVIRONMENT: Moreover, sandboxing is disabled, in particular because of:"
        echo "ENTERING ENVIRONMENT: /tmp/nrm-* sockets, /etc/argo, /var/run/, /var/lock/ which all need read access. "
        echo "ENTERING ENVIRONMENT: until these components are patched to allow for alternative paths, no sandbox use is possible."
        echo ""
      '';
      #argotk uses this environment variable.
      #OPENMC_PWD = "${argotk}/share/openmc";
    };

    analysis = pkgs.stdenv.mkDerivation rec {
      name = "analysis";
      src = experiments-src;

      #required to be able to build the drv.
      installPhase = ''
        mkdir -p $out
      '';
      unpackPhase = "true";

      buildInputs = [
        pkgs.pandoc
        (pkgs.rWrapper.override{ packages = with pkgs.rPackages; [
          pkgs.rlwrap
          pkgs.pandoc
          docopt
          pracma
          tidyr
          readr
          magrittr
          formatR
          purrr
          wrapr
          knitr
          cowplot
          plotly
          lubridate
          dplyr
          ggplot2
          fpp2
          prospectr
          gridExtra
          zoo
          xtable
          ggthemes
          data_table
        ];})
      ];
    };

    hanalysis = analysis.overrideAttrs (old:{
      buildInputs = old.buildInputs ++ [
        (haskellPackages.ghcWithPackages(p:[
          p.protolude
          p.optparse-applicative
          (p.inline-r.overrideAttrs(old:{doCheck=false;}))
        ]))
      ];
    });

    f = { mkDerivation, base, protolude, data-default
    , optparse-applicative, typed-process, inline-r
    , R, stdenv }:
    mkDerivation {
      pname = "hsr";
      version = "1.0.0";
      src = "";
      isLibrary = true;
      isExecutable = false;
      libraryHaskellDepends = [
        base
        protolude
        inline-r
        typed-process
        optparse-applicative
        data-default
      ];
      librarySystemDepends = [
        pkgs.pandoc
        R
        pkgs.rPackages.docopt
        pkgs.rPackages.pracma
        pkgs.rPackages.tidyr
        pkgs.rPackages.readr
        pkgs.rPackages.magrittr
        pkgs.rPackages.formatR
        pkgs.rPackages.purrr
        pkgs.rPackages.wrapr
        pkgs.rPackages.knitr
        pkgs.rPackages.cowplot
        pkgs.rPackages.plotly
        pkgs.rPackages.lubridate
        pkgs.rPackages.dplyr
        pkgs.rPackages.ggplot2
        pkgs.rPackages.fpp2
        pkgs.rPackages.prospectr
        pkgs.rPackages.gridExtra
        pkgs.rPackages.zoo
        pkgs.rPackages.xtable
        pkgs.rPackages.ggthemes
        pkgs.rPackages.data_table
      ];
      license = stdenv.lib.licenses.bsd3;
    };
    hanal = argolib.getHackEnv (pkgs//argopkgs)
      haskellPackages (haskellPackages.callPackage f {});

    report = analysis.overrideAttrs (old:{
      buildPhase = ''
        echo "analysis/zymakefolder.R ${powerexpe}"
        analysis/zymakefolder.R ${powerexpe}
      '';
      installPhase = ''
        mkdir -p $out
        cp -r index* $out
      '';
    });

    dhrunSpecs = pkgs.stdenv.mkDerivation rec {
      name = "dhrunSpecs";
      src = ../dhrun ;
      installPhase = ''
        mkdir -p $out
        cp -r $src/* $out
        substituteInPlace $out/assets/simple-H2O.xml --replace \
          H2O.HF.wfs.xml $out/assets/H2O.HF.wfs.xml
        substituteInPlace $out/assets/simple-H2O.xml --replace \
          O.BFD.xml $out/assets/O.BFD.xml
        substituteInPlace $out/assets/simple-H2O.xml --replace \
          H.BFD.xml $out/assets/H.BFD.xml
        substituteInPlace $out/lib.dh --replace \
          "dataDir = \"./\"" "dataDir = \"$out/\""
        substituteInPlace $out/lib.dh --replace \
          "https://xgitlab.cels.anl.gov/argo/dhrun/raw/master/" "./"
        ln -s ${dhrun}/share/resources $out/resources
        '';
      unpackPhase = "true";
    };

    doDhrun = dhrscript: test.overrideAttrs (old:{
      buildPhase = ''
        cat ${dhrscript} |\
        dhall resolve |\
        dhall normalize |\
        dhall-to-yaml |\
        dhrun run "-"
      '';
      buildInputs = old.buildInputs ++ [
        dhall-json
        pkgs.yq
        dhall
      ];
      DHRUNSPECS = "${dhrunSpecs}";
      DHRUNSHARE = "${dhrun}/share";
      installPhase = ''
        mkdir -p $out
        cp _output/* $out/
      '';
    });

    doDhrunApp = app :
    let
      dhrunscript = pkgs.writeText "test.dhall" ''
        let all = ${dhrunSpecs}/all-tests.dh
        in all.${app} True < NoCap = {=} | Cap : Text >
      '';
    in
    doDhrun dhrunscript;

    doDhrunKey = key:
    let
      dhrunscript = pkgs.writeText "test.dhall" ''
        let all = ${dhrunSpecs}/all-tests.dh in all.${key}
      '';
    in
    doDhrun dhrunscript;

    testHello       = doDhrunKey "hello";
    testRun         = doDhrunKey "run";
    testListen      = doDhrunKey "listen";
    testPerfwrapper = doDhrunKey "performance";
    testPower       = doDhrunKey "power";

    testSTREAM      = addBI (doDhrunApp "stream") stream;
    testAMG         = addBI (doDhrunApp "amg") amg;
    testOpenMC      = (addBI (doDhrunApp "openmc") openmc).overrideAttrs
      (old:{ OPENMC_CROSS_SECTIONS = "${openmc-data}/cross_sections.xml"; });
    testLAMMPS      = addBI (doDhrunApp "lammps") lammps;
    testQMCPack     = addBI (doDhrunApp "qmcpack") qmcpack ;

    testAll         = (doDhrunKey "hello").overrideAttrs
    (old:{
      buildInputs = old.buildInputs ++ [
        lammps
        qmcpack
        openmc
        stream
        amg
        openmc-data
      ];
      OPENMC_CROSS_SECTIONS = "${openmc-data}/cross_sections.xml";
      });

    powerexpe = testAll.overrideAttrs (old:{
      name = "power-experiments";
      buildInputs = old.buildInputs ++ [
        #debug tools
        pkgs.which
        #experiment tools
        zymake
      ];
      buildPhase = "zymake ${experiments-src}/experiments/zymakefile";
      installPhase = ''
        mkdir -p $out
        cp -r o/* $out
      '';
    });
  };


# re-exporting a full nixpkgs-like package set
in pkgs // argopkgs