default.nix

{ # 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
  pkgs-old         ? import (hostPkgs.nix-update-source.fetch ./pkgs-old.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
  argotk-src       ? builtins.fetchGit {inherit (fetched argotk/pin.json) url rev;}
, 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);

  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 ];
    });

    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;
        #argo tools
        argotk      = (self.callCabal2nix "argotk"      argotk-src      ) {};
        argonix     = (self.callCabal2nix "argonix"     argonix-src     ) {};
        repoquality = (self.callCabal2nix "repoquality" repoquality-src ) {};
        dhrun       = (self.callCabal2nix "dhrun"       dhrun-src ) {};
        powerplots  = (self.callCabal2nix "powerplots"  powerplots-src  ) {};

      };
    };

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

    argotk = haskellPackages.argotk.overrideAttrs (old:{
        buildInputs=old.buildInputs ++ [pkgs.hwloc];
        installPhase = old.installPhase + ''
          mkdir $out/share/
          ARGOTK_SHARE=share $out/bin/argotk --bash-completion-script argotk > $out/share/argotk.sh
          cp -r share/* $out/share/
          substituteInPlace $out/share/simple-H2O.xml --replace \
                H2O.HF.wfs.xml $out/share/H2O.HF.wfs.xml
          substituteInPlace $out/share/simple-H2O.xml --replace \
                O.BFD.xml $out/share/O.BFD.xml
          substituteInPlace $out/share/simple-H2O.xml --replace \
                H.BFD.xml $out/share/H.BFD.xml
        '';
      });

    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";
      };
    });

    # archived for sake of the simplicity of this file
    zmcat = pkgs-old.haskellPackages.callPackage ./zmcat {};
    zmqat = pkgs-old.haskellPackages.zmqat;

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

      buildInputs = [
        # argotk runs mpiexec:
        pkgs.mpich2
        # argotk uses hwloc to choose CPU counts:
        pkgs.hwloc
        # these are needed for some reason:
        pkgs.coreutils
        pkgs.utillinux
        pkgs.git
        # argo tools
        argotk
        # 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."
        source ${argotk}/share/argotk.sh # bash completion
        echo ""
      '';
      #argotk uses this environment variable.
      ARGOTK_SHARE = "${argotk}/share";
      OPENMC_CROSS_SECTIONS = "${openmc-data}/cross_sections.xml";
      OPENMC_PWD = "${argotk}/share/openmc";
    };

    testApplications = test.overrideAttrs (old:{
      name = "testEnv-with-applications";
      buildInputs = old.buildInputs ++ [
        lammps
        qmcpack
        openmc
        stream
        amg
        openmc-data
      ];
    });

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

    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
      '';
    });

    doArgotk = drv: command: drv.overrideAttrs (old:{
      buildPhase = "argotk "+command+" --verbose";
      installPhase = ''
        mkdir -p $out
        cp _output/* $out/
      '';
    });
    testHello       = doArgotk test "TestHello";
    testListen      = doArgotk test "TestListen";
    testPerfwrapper = doArgotk test "TestPerfwrapper";
    testPower       = doArgotk test "TestPower";
    testSTREAM      = doArgotk (test.overrideAttrs
      (old:{buildInputs=old.buildInputs++[ stream  ];})) "TestSTREAM";
    testAMG         = doArgotk (test.overrideAttrs
      (old:{buildInputs=old.buildInputs++[ amg     ];})) "TestAMG";
    testOpenMC      = doArgotk (test.overrideAttrs
      (old:{buildInputs=old.buildInputs++[ openmc  ];})) "TestOpenMC";
    testLAMMPS      = doArgotk (test.overrideAttrs
      (old:{buildInputs=old.buildInputs++[ lammps  ];})) "TestLAMMPS";
    testQMCPack     = doArgotk (test.overrideAttrs
      (old:{buildInputs=old.buildInputs++[ qmcpack ];})) "TestQMCPack";
    testAll         = doArgotk test "tests";

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